From 0aa27d1857d85cbc2cec496a2f2cd1b662df8ce9 Mon Sep 17 00:00:00 2001 From: cooper Date: Fri, 6 Nov 2026 09:22:13 -0800 Subject: [PATCH] fix: recover setup replies missing the final JSON brace Completed provider replies can omit only the outer closing brace. Recover that delimiter only after strict decoding and semantic validation, and recover saved replies before requesting another model response. Preserve frozen-plan guards and reject incomplete nested content. Fixes stackpanel-0h7. --- .../cmd/cli/setup_agent_reply.go | 21 ++-- .../cmd/cli/setup_agent_reply_test.go | 103 +++++++++++++++++- .../internal/setupagent/prompt.go | 12 +- .../internal/setupagent/reply_test.go | 62 +++++++++++ 4 files changed, 186 insertions(+), 12 deletions(-) create mode 100644 apps/stackpanel-go/internal/setupagent/reply_test.go diff --git a/apps/stackpanel-go/cmd/cli/setup_agent_reply.go b/apps/stackpanel-go/cmd/cli/setup_agent_reply.go index 5d607259..7bda726b 100644 --- a/apps/stackpanel-go/cmd/cli/setup_agent_reply.go +++ b/apps/stackpanel-go/cmd/cli/setup_agent_reply.go @@ -40,16 +40,19 @@ func runSetupAgentReply(ctx context.Context, agent setupagent.Agent, phase setup if pending.Phase != phase { return nil, fmt.Errorf("saved reply belongs to %s, not %s; use --restart to review a new plan", pending.Phase, phase) } - ui.Warning(fmt.Sprintf("%s returned malformed setup JSON. Requesting a corrected reply · retry 1 of 1. Your choices are saved.", agent.ID)) - request.ReadOnly = true - request.Prompt = setupagent.ReplyCorrectionPrompt(phase, pending.Message, pending.Problem) - result, err := setupagent.Run(ctx, agent, request) + reply, err := setupagent.ParseReply(pending.Message) if err != nil { - return nil, fmt.Errorf("%s reply correction failed; original reply saved for retry: %w", agent.ID, err) - } - reply, err := setupagent.ParseReply(result.Message) - if err != nil { - return nil, fmt.Errorf("%s returned an invalid reply after one formatting retry; original reply saved: %w", agent.ID, err) + ui.Warning(fmt.Sprintf("%s returned malformed setup JSON. Requesting a corrected reply · retry 1 of 1. Your choices are saved.", agent.ID)) + request.ReadOnly = true + request.Prompt = setupagent.ReplyCorrectionPrompt(phase, pending.Message, pending.Problem) + result, err := setupagent.Run(ctx, agent, request) + if err != nil { + return nil, fmt.Errorf("%s reply correction failed; original reply saved for retry: %w", agent.ID, err) + } + reply, err = setupagent.ParseReply(result.Message) + if err != nil { + return nil, fmt.Errorf("%s returned an invalid reply after one formatting retry; original reply saved: %w", agent.ID, err) + } } if reply.Status == "blocked" { return nil, fmt.Errorf("%s could not recover its reply: %s", agent.ID, reply.Summary) diff --git a/apps/stackpanel-go/cmd/cli/setup_agent_reply_test.go b/apps/stackpanel-go/cmd/cli/setup_agent_reply_test.go index 079c30a1..355de6c5 100644 --- a/apps/stackpanel-go/cmd/cli/setup_agent_reply_test.go +++ b/apps/stackpanel-go/cmd/cli/setup_agent_reply_test.go @@ -56,7 +56,14 @@ func TestSetupReplyCorrectionResumesWithoutRepeatingWork(t *testing.T) { if phase == setupagent.Inspection { message = `{"status":"plan","plan":{"summary":"Create app","expectations":{"version":1,"files":["src/main.ts"],"config":[{"path":["enable"],"equals":true}],"commands":[{"id":"build","scope":"build","dir":".","argv":["bun","run","build"]}]}}}` } - malformed := strings.TrimSuffix(message, "}") // The user's missing outer brace. + // Missing content still requires a model correction. A missing final + // outer brace alone is recovered without another invocation. + malformed := strings.TrimSuffix(message, "}") + if phase == setupagent.Inspection { + malformed = strings.TrimSuffix(malformed, "}") + } else { + malformed = strings.TrimSuffix(malformed, `"`) + } writeSetupReplyEvents(t, fixture, "original", malformed) writeSetupReplyEvents(t, fixture, "correction", malformed) state := &setupManifest{Version: 1, Root: root, Stage: "apply", path: setupStatePath(root), @@ -126,7 +133,7 @@ func TestSetupReplyDoesNotRetryProviderFailure(t *testing.T) { func TestSetupReplyCorrectionCannotReplaceAcceptedPlan(t *testing.T) { agent, fixture := setupReplyFixture(t) - writeSetupReplyEvents(t, fixture, "original", `{"status":"complete","summary":"Done"`) + writeSetupReplyEvents(t, fixture, "original", `{"status":"complete","summary":"Done`) writeSetupReplyEvents(t, fixture, "correction", `{"status":"plan","plan":{"summary":"Weaken checks","expectations":{"version":1,"config":[{"path":["enable"],"equals":true}]}}}`) var output bytes.Buffer ui := tui.NewSetupUI(context.Background(), false, &output) @@ -137,3 +144,95 @@ func TestSetupReplyCorrectionCannotReplaceAcceptedPlan(t *testing.T) { t.Fatalf("accepted replacement plan: %v", err) } } + +func TestSetupReplyMissingFinalOuterBraceDoesNotRetry(t *testing.T) { + for _, phase := range []setupagent.Phase{setupagent.Inspection, setupagent.Setup} { + t.Run(string(phase), func(t *testing.T) { + agent, fixture := setupReplyFixture(t) + message := `{"status":"complete","summary":"Created agreed files"}` + if phase == setupagent.Inspection { + message = `{"status":"plan","plan":{"summary":"Configure app","expectations":{"version":1,"config":[{"path":["enable"],"equals":true}]}}}` + } + writeSetupReplyEvents(t, fixture, "original", strings.TrimSuffix(message, "}")) + var output bytes.Buffer + ui := tui.NewSetupUI(context.Background(), false, &output) + defer ui.Close() + state := &setupManifest{} + reply, err := runSetupAgentReply(context.Background(), agent, phase, setupagent.RunRequest{ + Dir: t.TempDir(), ReadOnly: phase == setupagent.Inspection, + }, state, ui) + if err != nil || reply == nil || state.PendingReply != nil { + t.Fatalf("recover reply: %+v, state %+v, error %v", reply, state.PendingReply, err) + } + if strings.Contains(output.String(), "malformed") { + t.Fatal("recoverable reply displayed a malformed JSON warning") + } + if _, err := os.Stat(filepath.Join(fixture, "correction-calls")); !os.IsNotExist(err) { + t.Fatalf("recoverable reply invoked correction: %v", err) + } + }) + } +} + +func TestSetupSavedReplyMissingFinalOuterBraceDoesNotRetry(t *testing.T) { + for _, phase := range []setupagent.Phase{setupagent.Inspection, setupagent.Setup, setupagent.Repair} { + t.Run(string(phase), func(t *testing.T) { + setupStateTestEnvironment(t) + agent, fixture := setupReplyFixture(t) + root := t.TempDir() + message := `{"status":"complete","summary":"Created agreed files"}` + if phase == setupagent.Inspection { + message = `{"status":"plan","plan":{"summary":"Configure app","expectations":{"version":1,"config":[{"path":["enable"],"equals":true}]}}}` + } + state := &setupManifest{Version: 1, Root: root, Stage: "apply", path: setupStatePath(root), + Plan: &setupagent.Plan{Expectations: reconcile.Expectations{Version: 1, RequiredChecks: []string{"keep-check"}}}, + Request: setupagent.SetupRequest{Root: root, Answers: []setupagent.Answer{{ID: "framework", Values: []string{"Bun"}}}}, + PendingReply: &setupReplyRecovery{Phase: phase, Message: strings.TrimSuffix(message, "}"), Problem: "invalid setup reply: unexpected EOF"}, + } + if err := state.save(); err != nil { + t.Fatal(err) + } + loaded, err := loadSetupManifest(root) + if err != nil { + t.Fatal(err) + } + var output bytes.Buffer + ui := tui.NewSetupUI(context.Background(), false, &output) + defer ui.Close() + reply, err := runSetupAgentReply(context.Background(), agent, phase, setupagent.RunRequest{ + Dir: root, ReadOnly: phase == setupagent.Inspection, + }, loaded, ui) + if err != nil || reply == nil { + t.Fatalf("recover saved reply: %+v, error %v", reply, err) + } + saved, err := loadSetupManifest(root) + if err != nil || saved.PendingReply != nil || len(saved.Request.Answers) != 1 || + saved.Plan == nil || len(saved.Plan.Expectations.RequiredChecks) != 1 || saved.Plan.Expectations.RequiredChecks[0] != "keep-check" { + t.Fatalf("lost saved state: %+v, error %v", saved, err) + } + if strings.Contains(output.String(), "malformed") { + t.Fatal("recoverable saved reply displayed a malformed JSON warning") + } + for _, name := range []string{"original-calls", "correction-calls"} { + if _, err := os.Stat(filepath.Join(fixture, name)); !os.IsNotExist(err) { + t.Fatalf("recoverable saved reply invoked %s: %v", name, err) + } + } + }) + } +} + +func TestSetupSavedReplyCannotReplaceAcceptedPlan(t *testing.T) { + agent, _ := setupReplyFixture(t) + var output bytes.Buffer + ui := tui.NewSetupUI(context.Background(), false, &output) + defer ui.Close() + state := &setupManifest{PendingReply: &setupReplyRecovery{ + Phase: setupagent.Setup, + Message: `{"status":"plan","plan":{"summary":"Weaken checks","expectations":{"version":1,"config":[{"path":["enable"],"equals":true}]}}`, + }} + _, err := runSetupAgentReply(context.Background(), agent, setupagent.Setup, setupagent.RunRequest{Dir: t.TempDir()}, state, ui) + if err == nil || !strings.Contains(err.Error(), "unexpected status") || state.PendingReply == nil { + t.Fatalf("accepted replacement plan from saved reply: %v", err) + } +} diff --git a/apps/stackpanel-go/internal/setupagent/prompt.go b/apps/stackpanel-go/internal/setupagent/prompt.go index 982629e4..485fc3a7 100644 --- a/apps/stackpanel-go/internal/setupagent/prompt.go +++ b/apps/stackpanel-go/internal/setupagent/prompt.go @@ -2,6 +2,7 @@ package setupagent import ( "encoding/json" + "errors" "fmt" "io" "path/filepath" @@ -101,7 +102,16 @@ func ParseReply(message string) (*Reply, error) { return nil, fmt.Errorf("agent reply exceeds size limit") } var reply Reply - if err := decodeStrict(message, &reply); err != nil { + err := decodeStrict(message, &reply) + if errors.Is(err, io.ErrUnexpectedEOF) && len(message) < maxMessageBytes { + // Completed provider replies can omit their final outer brace. Recover + // only that delimiter; incomplete nested content still fails decoding. + var recovered Reply + if decodeStrict(message+"}", &recovered) == nil { + reply, err = recovered, nil + } + } + if err != nil { // Accept the original inspection protocol during the experiment's transition. if plan, planErr := ParsePlan(message); planErr == nil { return &Reply{Status: "plan", Plan: plan}, nil diff --git a/apps/stackpanel-go/internal/setupagent/reply_test.go b/apps/stackpanel-go/internal/setupagent/reply_test.go new file mode 100644 index 00000000..848cb122 --- /dev/null +++ b/apps/stackpanel-go/internal/setupagent/reply_test.go @@ -0,0 +1,62 @@ +package setupagent + +import ( + "context" + "reflect" + "strings" + "testing" +) + +func TestRunRecoversReplyMissingFinalOuterBrace(t *testing.T) { + plan := `{"status":"plan","plan":` + validPlan + `}` + for _, tt := range []struct { + name, message string + readOnly bool + }{ + {"inspection", plan, true}, + {"setup", complete, false}, + } { + t.Run(tt.name, func(t *testing.T) { + agent := fakeAgent(t, "codex") + // The provider completed normally, but omitted only the reply's + // outermost closing brace. Its nested plan remains complete. + t.Setenv("STACKPANEL_TEST_AGENT_EVENTS", codexEvents(strings.TrimSuffix(tt.message, "}"))) + result, err := Run(context.Background(), agent, RunRequest{Dir: t.TempDir(), ReadOnly: tt.readOnly}) + if err != nil { + t.Fatal(err) + } + actual, err := ParseReply(result.Message) + if err != nil { + t.Fatalf("completed provider reply was rejected: %v", err) + } + expected, err := ParseReply(tt.message) + if err != nil || !reflect.DeepEqual(actual, expected) { + t.Fatalf("recovery changed reply: got %+v, want %+v (%v)", actual, expected, err) + } + }) + } +} + +func TestReplyRecoveryRejectsIncompleteOrInvalidContents(t *testing.T) { + for _, tt := range []struct{ name, message string }{ + {"nested object", `{"status":"plan","plan":` + strings.TrimSuffix(validPlan, "}")}, + {"nested array", `{"status":"needs_input","questions":[{"id":"framework","prompt":"Framework?","kind":"text","required":true}`}, + {"unfinished string", `{"status":"complete","summary":"Done`}, + {"missing value", `{"status":"complete","summary":`}, + {"trailing comma", `{"status":"complete","summary":"Done",`}, + {"unknown field", `{"status":"complete","summary":"Done","unexpected":true`}, + {"invalid plan", `{"status":"plan","plan":{"summary":"No checks","expectations":{"version":1,"config":[]}}`}, + } { + t.Run(tt.name, func(t *testing.T) { + agent := fakeAgent(t, "codex") + t.Setenv("STACKPANEL_TEST_AGENT_EVENTS", codexEvents(tt.message)) + result, err := Run(context.Background(), agent, RunRequest{Dir: t.TempDir(), ReadOnly: true}) + if err != nil { + t.Fatal(err) + } + if _, err := ParseReply(result.Message); err == nil { + t.Fatal("accepted incomplete or invalid reply") + } + }) + } +}