fix(responses): dead export, explicit types, X-Initiator and error tests (#4)

- Delete unused `ResponseStreamEvent` interface from create-responses.ts
- Add explicit `Promise<ResponsesResponse | AsyncGenerator<ServerSentEventMessage, void, unknown>>` return type to `createResponses`
- Wire `forwardError` into responses route so upstream 4xx/5xx propagates correctly
- Expand tests/responses-route.test.ts: new "createResponses behavior" describe block with X-Initiator=agent (assistant message), X-Initiator=user (pure user), X-Initiator=agent (function_call_output), and upstream 429 error path
- Remove spurious `// eslint-disable-next-line require-atomic-updates` comment; fix underlying lint issue

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: HXYerror

src/routes/responses/route.ts

@@ -1,9 +1,17 @@
 import { Hono } from "hono"
 
+import { forwardError } from "~/lib/error"
+
 import { handleResponses } from "./handler"
 
 const responses = new Hono()
 
-responses.post("/", handleResponses)
+responses.post("/", async (c) => {
+  try {
+    return await handleResponses(c)
+  } catch (error) {
+    return await forwardError(c, error)
+  }
+})
 
 export default responses

src/services/copilot/create-responses.ts

@@ -1,3 +1,5 @@
+import type { ServerSentEventMessage } from "fetch-event-stream"
+
 import consola from "consola"
 import { events } from "fetch-event-stream"
 
@@ -52,7 +54,11 @@ export function isAgentCall(payload: ResponsesPayload): boolean {
 // Service client
 // ---------------------------------------------------------------------------
 
-export const createResponses = async (payload: ResponsesPayload) => {
+export const createResponses = async (
+  payload: ResponsesPayload,
+): Promise<
+  ResponsesResponse | AsyncGenerator<ServerSentEventMessage, void, unknown>
+> => {
   if (!state.copilotToken) throw new Error("Copilot token not found")
 
   const enableVision = inputHasImages(payload)
@@ -82,12 +88,3 @@ export const createResponses = async (payload: ResponsesPayload) => {
 
   return (await response.json()) as ResponsesResponse
 }
-
-// ---------------------------------------------------------------------------
-// Streaming event types for Responses API SSE
-// ---------------------------------------------------------------------------
-
-export interface ResponseStreamEvent {
-  type: string // "response.created" | "response.output_text.delta" | etc.
-  [key: string]: unknown
-}

tests/responses-route.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, mock, beforeAll } from "bun:test"
+import { describe, test, expect, mock, beforeAll, beforeEach } from "bun:test"
 
 import { state } from "../src/lib/state"
 import { server } from "../src/server"
@@ -75,10 +75,8 @@ describe("POST /v1/responses — wired handler", () => {
   })
 
   test("missing copilot token returns 500", async () => {
-    // Temporarily clear the token via a describe-level wrapper so the
-    // assignment happens synchronously (no await between read and write).
-    const tokenBackup = state.copilotToken
-    state.copilotToken = undefined // synchronous — no race condition
+    // Temporarily clear the token — write is synchronous, no await in between.
+    state.copilotToken = undefined
 
     const res = await server.request("/v1/responses", {
       method: "POST",
@@ -87,7 +85,145 @@ describe("POST /v1/responses — wired handler", () => {
     })
     expect(res.status).toBe(500)
 
-    // eslint-disable-next-line require-atomic-updates
-    state.copilotToken = tokenBackup
+    state.copilotToken = "test-token"
+  })
+})
+
+// ---------------------------------------------------------------------------
+// createResponses behavior: X-Initiator header and error propagation
+// ---------------------------------------------------------------------------
+
+describe("createResponses behavior", () => {
+  // Restore state before each test in this block
+  beforeEach(() => {
+    state.copilotToken = "test-token"
+    state.vsCodeVersion = "1.99.0"
+    state.accountType = "individual"
+    state.manualApprove = false
+  })
+
+  test("X-Initiator = agent when assistant message present", async () => {
+    const captureMock = mock(
+      (_url: string, opts: { headers: Record<string, string> }) =>
+        Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve(mockResponseBody),
+          headers: opts.headers,
+        }),
+    )
+    // @ts-expect-error – mock doesn't implement full fetch signature
+    globalThis.fetch = captureMock
+
+    await server.request("/v1/responses", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-4o",
+        stream: false,
+        input: [
+          { type: "message", role: "user", content: "hello" },
+          { type: "message", role: "assistant", content: "hi there" },
+        ],
+      }),
+    })
+
+    expect(captureMock).toHaveBeenCalled()
+    const sentHeaders = (
+      captureMock.mock.calls[0][1] as { headers: Record<string, string> }
+    ).headers
+    expect(sentHeaders["X-Initiator"]).toBe("agent")
+
+    // Restore default mock
+    // @ts-expect-error – mock doesn't implement full fetch signature
+    globalThis.fetch = fetchMock
+  })
+
+  test("X-Initiator = user for pure user messages", async () => {
+    const captureMock = mock(
+      (_url: string, opts: { headers: Record<string, string> }) =>
+        Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve(mockResponseBody),
+          headers: opts.headers,
+        }),
+    )
+    // @ts-expect-error – mock doesn't implement full fetch signature
+    globalThis.fetch = captureMock
+
+    await server.request("/v1/responses", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-4o",
+        stream: false,
+        input: [{ type: "message", role: "user", content: "just a user" }],
+      }),
+    })
+
+    expect(captureMock).toHaveBeenCalled()
+    const sentHeaders = (
+      captureMock.mock.calls[0][1] as { headers: Record<string, string> }
+    ).headers
+    expect(sentHeaders["X-Initiator"]).toBe("user")
+
+    // @ts-expect-error – mock doesn't implement full fetch signature
+    globalThis.fetch = fetchMock
+  })
+
+  test("X-Initiator = agent for function_call_output item", async () => {
+    const captureMock = mock(
+      (_url: string, opts: { headers: Record<string, string> }) =>
+        Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve(mockResponseBody),
+          headers: opts.headers,
+        }),
+    )
+    // @ts-expect-error – mock doesn't implement full fetch signature
+    globalThis.fetch = captureMock
+
+    await server.request("/v1/responses", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-4o",
+        stream: false,
+        input: [
+          { type: "function_call_output", call_id: "call_1", output: "{}" },
+        ],
+      }),
+    })
+
+    expect(captureMock).toHaveBeenCalled()
+    const sentHeaders = (
+      captureMock.mock.calls[0][1] as { headers: Record<string, string> }
+    ).headers
+    expect(sentHeaders["X-Initiator"]).toBe("agent")
+
+    // @ts-expect-error – mock doesn't implement full fetch signature
+    globalThis.fetch = fetchMock
+  })
+
+  test("upstream 4xx returns error response", async () => {
+    const errorMock = mock(() =>
+      Promise.resolve({
+        ok: false,
+        status: 429,
+        text: () => Promise.resolve("rate limited"),
+      }),
+    )
+    // @ts-expect-error – mock doesn't implement full fetch signature
+    globalThis.fetch = errorMock
+
+    const res = await server.request("/v1/responses", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: "gpt-4o", stream: false, input: [] }),
+    })
+
+    expect(res.status).toBe(429)
+
+    // @ts-expect-error – mock doesn't implement full fetch signature
+    globalThis.fetch = fetchMock
   })
 })