Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

【架构优化】从 extractJSONObject 中拆出 result 事件解码 streamResultEventValue 并合并重复的摘要兜底 clarifySummaryFallback (#827)

fx-kurumiad33e1472fa3
diff --git a/internal/httpapi/stream.go b/internal/httpapi/stream.go
index af6b1639..904e2548 100644
--- a/internal/httpapi/stream.go
+++ b/internal/httpapi/stream.go
@@ -1069,17 +1069,8 @@ func extractJSONObject(raw string) (any, string) {
continue
}
if fmt.Sprint(event["type"]) == "result" {
- if msg, ok := event["result"].(string); ok {
- if v, ok := parseStreamJSONObject(msg); ok {
- resultVal, resultRaw = v, msg
- } else if strings.TrimSpace(msg) != "" {
- resultVal = map[string]any{"summary": msg, "questions": []any{}, "ready": false}
- resultRaw = msg
- }
- } else if obj, ok := event["result"].(map[string]any); ok {
- if v, ok := unwrapStreamJSONEnvelope(obj); ok {
- resultVal, resultRaw = v, line
- }
+ if v, src, ok := streamResultEventValue(event, line); ok {
+ resultVal, resultRaw = v, src
}
continue
}
@@ -1101,7 +1092,34 @@ func extractJSONObject(raw string) (any, string) {
if fallback != nil {
return fallback, fallbackRaw
}
- return map[string]any{"summary": raw, "questions": []any{}, "ready": false}, raw
+ return clarifySummaryFallback(raw), raw
+}
+
+// streamResultEventValue decodes the payload of one stream-json "result"
+// event. A string result is parsed as JSON, or wrapped as a not-ready summary
+// when it is non-blank prose; an object result is unwrapped from its envelope
+// and reported with the whole event line as its raw source.
+func streamResultEventValue(event map[string]any, line string) (any, string, bool) {
+ switch result := event["result"].(type) {
+ case string:
+ if v, ok := parseStreamJSONObject(result); ok {
+ return v, result, true
+ }
+ if strings.TrimSpace(result) != "" {
+ return clarifySummaryFallback(result), result, true
+ }
+ case map[string]any:
+ if v, ok := unwrapStreamJSONEnvelope(result); ok {
+ return v, line, true
+ }
+ }
+ return nil, "", false
+}
+
+// clarifySummaryFallback wraps free text as a not-ready clarify payload with
+// no questions.
+func clarifySummaryFallback(text string) map[string]any {
+ return map[string]any{"summary": text, "questions": []any{}, "ready": false}
}
func unwrapStreamJSONEnvelope(v any) (any, bool) {
diff --git a/internal/httpapi/stream_result_event_test.go b/internal/httpapi/stream_result_event_test.go
new file mode 100644
index 00000000..c137d335
--- /dev/null
+++ b/internal/httpapi/stream_result_event_test.go
@@ -0,0 +1,98 @@
+package httpapi
+
+import (
+ "reflect"
+ "testing"
+)
+
+func TestStreamResultEventValueDecodesResultPayload(t *testing.T) {
+ const line = `{"type":"result","result":{"summary":"obj"}}`
+ cases := []struct {
+ name string
+ event map[string]any
+ want any
+ wantSrc string
+ wantOK bool
+ }{
+ {
+ name: "json string",
+ event: map[string]any{"type": "result", "result": "```json\n{\"summary\":\"s\",\"ready\":true}\n```"},
+ want: map[string]any{"summary": "s", "ready": true},
+ wantSrc: "```json\n{\"summary\":\"s\",\"ready\":true}\n```",
+ wantOK: true,
+ },
+ {
+ name: "prose string",
+ event: map[string]any{"type": "result", "result": "just prose"},
+ want: map[string]any{"summary": "just prose", "questions": []any{}, "ready": false},
+ wantSrc: "just prose",
+ wantOK: true,
+ },
+ {
+ name: "blank string",
+ event: map[string]any{"type": "result", "result": " \n\t"},
+ wantOK: false,
+ },
+ {
+ name: "object envelope",
+ event: map[string]any{"type": "result", "result": map[string]any{"type": "result", "result": map[string]any{"summary": "obj"}}},
+ want: map[string]any{"summary": "obj"},
+ wantSrc: line,
+ wantOK: true,
+ },
+ {
+ name: "missing result",
+ event: map[string]any{"type": "result"},
+ wantOK: false,
+ },
+ {
+ name: "non-string non-object result",
+ event: map[string]any{"type": "result", "result": float64(1)},
+ wantOK: false,
+ },
+ }
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ got, src, ok := streamResultEventValue(tc.event, line)
+ if ok != tc.wantOK {
+ t.Fatalf("ok = %v, want %v", ok, tc.wantOK)
+ }
+ if !ok {
+ if got != nil || src != "" {
+ t.Fatalf("unexpected value on miss: %#v, %q", got, src)
+ }
+ return
+ }
+ if !reflect.DeepEqual(got, tc.want) {
+ t.Fatalf("value = %#v, want %#v", got, tc.want)
+ }
+ if src != tc.wantSrc {
+ t.Fatalf("src = %q, want %q", src, tc.wantSrc)
+ }
+ })
+ }
+}
+
+func TestExtractJSONObjectKeepsEarlierResultWhenLaterResultIsBlank(t *testing.T) {
+ raw := `{"type":"result","result":"{\"summary\":\"first\",\"ready\":true}"}` + "\n" +
+ `{"type":"result","result":" "}`
+ got, src := extractJSONObject(raw)
+ want := map[string]any{"summary": "first", "ready": true}
+ if !reflect.DeepEqual(got, want) {
+ t.Fatalf("value = %#v, want %#v", got, want)
+ }
+ if src != `{"summary":"first","ready":true}` {
+ t.Fatalf("src = %q", src)
+ }
+}
+
+func TestExtractJSONObjectFallsBackToSummaryForPlainText(t *testing.T) {
+ got, src := extractJSONObject(" plain words ")
+ want := clarifySummaryFallback("plain words")
+ if !reflect.DeepEqual(got, want) || src != "plain words" {
+ t.Fatalf("got %#v, %q", got, src)
+ }
+ if want["ready"] != false || len(want["questions"].([]any)) != 0 {
+ t.Fatalf("clarifySummaryFallback shape = %#v", want)
+ }
+}