fix(executor): handle CommandCode in-stream errors for combo and account fallback

CommandCode returns errors as a type:"error" event inside an HTTP 200
NDJSON stream instead of a non-200 status, so the existing combo/account
fallback logic (keyed off response.status) never triggered and the error
text was streamed to the client as if it were content.

Peek the first NDJSON events before committing to a stream; on a
type:"error" event, abort and return a proper 4xx/5xx Response instead.
Normal streams are replayed losslessly (buffered prefix + rest of the
stream) through the existing translator, so the happy path is unchanged.
Add CommandCodeExecutor.parseError() so parseUpstreamError() can extract
a clean message/status from the synthesized error body.

tests/unit/commandcode-executor.test.js

@@ -0,0 +1,192 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  parseCommandCodeError,
+  inspectAndWrapCommandCodeResponse,
+  CommandCodeExecutor,
+} from "../../open-sse/executors/commandcode.js";
+import { handleComboChat } from "../../open-sse/services/combo.js";
+
+function createNdjsonStream(lines) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start(controller) {
+      for (const line of lines) {
+        controller.enqueue(encoder.encode(typeof line === "string" ? line : JSON.stringify(line) + "\n"));
+      }
+      controller.close();
+    },
+  });
+}
+
+describe("parseCommandCodeError", () => {
+  it("parses user exact error payload with statusCode 503 and isRetryable", () => {
+    const event = {
+      type: "error",
+      error: {
+        type: "server_error",
+        message: "Service temporarily unavailable. Please try again shortly.",
+        statusCode: 503,
+        isRetryable: true,
+      },
+    };
+    const parsed = parseCommandCodeError(event);
+    expect(parsed.statusCode).toBe(503);
+    expect(parsed.message).toBe("Service temporarily unavailable. Please try again shortly.");
+    expect(parsed.type).toBe("server_error");
+  });
+
+  it("handles string error message", () => {
+    const event = {
+      type: "error",
+      message: "Rate limit exceeded. Please wait 30s.",
+    };
+    const parsed = parseCommandCodeError(event);
+    expect(parsed.statusCode).toBe(429);
+    expect(parsed.message).toBe("Rate limit exceeded. Please wait 30s.");
+  });
+
+  it("handles plain error string in error property", () => {
+    const event = {
+      type: "error",
+      error: "Unauthorized access",
+    };
+    const parsed = parseCommandCodeError(event);
+    expect(parsed.statusCode).toBe(401);
+    expect(parsed.message).toBe("Unauthorized access");
+  });
+});
+
+describe("inspectAndWrapCommandCodeResponse", () => {
+  it("converts initial upstream 200 with error event to 503 Response", async () => {
+    const ndjsonBody = createNdjsonStream([
+      JSON.stringify({
+        type: "error",
+        error: {
+          type: "server_error",
+          message: "Service temporarily unavailable. Please try again shortly.",
+          statusCode: 503,
+          isRetryable: true,
+        },
+      }) + "\n",
+    ]);
+
+    const fakeResponse = new Response(ndjsonBody, {
+      status: 200,
+      headers: { "Content-Type": "text/event-stream" },
+    });
+
+    const result = await inspectAndWrapCommandCodeResponse(fakeResponse, "poolside/laguna-s-2.1-free");
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe(503);
+
+    const body = await result.json();
+    expect(body.error.message).toContain("Service temporarily unavailable");
+    expect(body.error.code).toBe(503);
+  });
+
+  it("converts initial upstream 200 with start/start-step followed by error to 503 Response", async () => {
+    const ndjsonBody = createNdjsonStream([
+      JSON.stringify({ type: "start" }) + "\n",
+      JSON.stringify({ type: "start-step" }) + "\n",
+      JSON.stringify({
+        type: "error",
+        error: {
+          type: "server_error",
+          message: "Service temporarily unavailable. Please try again shortly.",
+          statusCode: 503,
+          isRetryable: true,
+        },
+      }) + "\n",
+    ]);
+
+    const fakeResponse = new Response(ndjsonBody, {
+      status: 200,
+      headers: { "Content-Type": "text/event-stream" },
+    });
+
+    const result = await inspectAndWrapCommandCodeResponse(fakeResponse, "poolside/laguna-s-2.1-free");
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe(503);
+
+    const body = await result.json();
+    expect(body.error.message).toContain("Service temporarily unavailable");
+  });
+
+  it("streams successful responses when content is emitted", async () => {
+    const ndjsonBody = createNdjsonStream([
+      JSON.stringify({ type: "start" }) + "\n",
+      JSON.stringify({ type: "text-delta", text: "Hello from Laguna" }) + "\n",
+      JSON.stringify({ type: "finish" }) + "\n",
+    ]);
+
+    const fakeResponse = new Response(ndjsonBody, {
+      status: 200,
+      headers: { "Content-Type": "text/event-stream" },
+    });
+
+    const result = await inspectAndWrapCommandCodeResponse(fakeResponse, "poolside/laguna-s-2.1-free");
+    expect(result.ok).toBe(true);
+    expect(result.status).toBe(200);
+
+    const text = await result.text();
+    expect(text).toContain("Hello from Laguna");
+    expect(text).toContain("data: [DONE]");
+  });
+});
+
+describe("CommandCode in Combo Fallback", () => {
+  it("automatically falls back to next model when commandcode returns 503 error", async () => {
+    const log = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      debug: vi.fn(),
+    };
+
+    const handleSingleModel = vi.fn(async (body, modelStr) => {
+      if (modelStr === "commandcode/poolside/laguna-s-2.1-free") {
+        // Simulated failed CommandCode response
+        return new Response(
+          JSON.stringify({
+            error: {
+              message: "Service temporarily unavailable. Please try again shortly.",
+              type: "server_error",
+              code: 503,
+            },
+          }),
+          { status: 503, headers: { "Content-Type": "application/json" } }
+        );
+      }
+
+      if (modelStr === "openai/gpt-4o-mini") {
+        // Fallback model succeeds
+        return new Response(
+          JSON.stringify({
+            id: "chatcmpl-test",
+            choices: [{ message: { role: "assistant", content: "Fallback success!" } }],
+          }),
+          { status: 200, headers: { "Content-Type": "application/json" } }
+        );
+      }
+
+      return new Response("Not found", { status: 404 });
+    });
+
+    const comboResponse = await handleComboChat({
+      body: { messages: [{ role: "user", content: "Hello" }] },
+      models: ["commandcode/poolside/laguna-s-2.1-free", "openai/gpt-4o-mini"],
+      handleSingleModel,
+      log,
+      comboName: "test-combo",
+      comboStrategy: "fallback",
+    });
+
+    expect(comboResponse.ok).toBe(true);
+    expect(comboResponse.status).toBe(200);
+
+    const data = await comboResponse.json();
+    expect(data.choices[0].message.content).toBe("Fallback success!");
+    expect(handleSingleModel).toHaveBeenCalledTimes(2);
+    expect(handleSingleModel).toHaveBeenNthCalledWith(1, expect.anything(), "commandcode/poolside/laguna-s-2.1-free");
+    expect(handleSingleModel).toHaveBeenNthCalledWith(2, expect.anything(), "openai/gpt-4o-mini");
+  });
+});