Integrate upstream Responses websocket and compaction updates

Merge czy-all into dev after preserving local Responses handling while accepting upstream websocket safety, rate-limit adaptation, session header normalization, and server-side compaction changes.

Constraint: best-of-both-worlds workflow requires dev-side conflict resolution with user-approved hunks

Rejected: resolving conflicts on czy-all | would pollute the upstream buffer branch

Confidence: high

Scope-risk: moderate

Directive: keep future czy-all updates as pure caozhiyuan/dev synchronization only

Tested: bun run lint:all --fix; bun run build; bun test; bun run typecheck

Not-tested: live Copilot upstream behavior

Author: cuipengfei

desktop/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-api-desktop",
-  "version": "1.10.25",
+  "version": "1.10.29",
   "description": "Copilot API Desktop App",
   "main": "out/main/index.js",
   "scripts": {

desktop/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@jeffreycao/copilot-api",
-  "version": "1.10.25",
+  "version": "1.10.29",
   "description": "OpenAI and Anthropic-compatible gateway for GitHub Copilot or Codex or third-party providers.",
   "keywords": [
     "ai-gateway",

package-lock.json

@@ -457,10 +457,9 @@ const handleWithCopilotResponses = async ({
     )
   }
 
-  applyResponsesApiContextManagement(
-    payload,
-    selectedModel.capabilities.limits.max_prompt_tokens,
-  )
+  // Smaller than the client compaction threshold, use server-side compaction to maintain cache hit rate
+  const maxPromptTokens = selectedModel?.capabilities.limits.max_prompt_tokens
+  applyResponsesApiContextManagement(payload, maxPromptTokens, 0.8)
 
   debugJson(logger, "Translated Responses payload:", payload)
 

package.json

@@ -4,6 +4,9 @@ import { events, type ServerSentEventMessage } from "fetch-event-stream"
 
 import type {
   CreateResponsesReturn,
+  ResponseInputContent,
+  ResponseInputItem,
+  ResponseInputMessage,
   ResponsesPayload,
   ResponseErrorEvent,
   ResponsesResult,
@@ -132,7 +135,7 @@ export function buildCodexResponsesHeaders(
     headers.set("originator", "opencode")
     const sessionId = requestContext.getStore()?.sessionAffinity
     if (sessionId) {
-      headers.set("session_id", sessionId)
+      headers.set("session-id", sessionId)
     }
   }
   return headers
@@ -161,7 +164,7 @@ export function buildCodexResponsesWebSocketPayload(
   payload: ResponsesPayload,
 ): CodexResponsesWebSocketPayload {
   const websocketPayload: CodexResponsesWebSocketPayload = {
-    ...payload,
+    ...normalizeCodexResponsesPayload(payload),
     type: "response.create",
   }
 
@@ -199,24 +202,13 @@ export async function forwardCodexResponses(
     transport?: ResponsesTransport
   } = {},
 ): Promise<CreateResponsesReturn> {
-  const normalizedPayload: ResponsesPayload = {
-    ...payload,
-    store: false,
-    temperature: undefined,
-    top_p: undefined,
-    max_output_tokens: undefined,
-    metadata: undefined,
-  }
-
   const transport = resolveCodexResponsesTransport(options.transport)
-  if (normalizedPayload.stream && transport === "websocket") {
-    return forwardCodexResponsesOverWebSocket(
-      normalizedPayload,
-      requestHeaders,
-      baseUrl,
-    )
+  if (payload.stream && transport === "websocket") {
+    return forwardCodexResponsesOverWebSocket(payload, requestHeaders, baseUrl)
   }
 
+  const normalizedPayload = normalizeCodexResponsesPayload(payload)
+
   const response = await fetch(resolveCodexResponsesUrl(baseUrl), {
     method: "POST",
     headers: buildCodexResponsesHeaders(requestHeaders, {
@@ -236,6 +228,136 @@ export async function forwardCodexResponses(
   return (await response.json()) as ResponsesResult
 }
 
+const normalizeCodexResponsesPayload = (
+  payload: ResponsesPayload,
+): ResponsesPayload => {
+  const normalizedPayload: ResponsesPayload = {
+    ...payload,
+    store: false,
+  }
+
+  delete normalizedPayload.temperature
+  delete normalizedPayload.top_p
+  delete normalizedPayload.max_output_tokens
+  delete normalizedPayload.metadata
+
+  if (
+    (typeof normalizedPayload.instructions === "string"
+      && normalizedPayload.instructions.trim().length > 0)
+    || !Array.isArray(normalizedPayload.input)
+  ) {
+    return normalizedPayload
+  }
+
+  const instructions: Array<string> = []
+  let messageCount = 0
+  const remainingInput = normalizedPayload.input.filter((inputItem) => {
+    const message = getResponseInputMessage(inputItem)
+    if (!message) {
+      return true
+    }
+
+    messageCount += 1
+    if (message.role !== "system" || messageCount > 3) {
+      return true
+    }
+
+    const systemPrompt = getTextContent(message.content)
+    if (systemPrompt === undefined) {
+      return true
+    }
+    if (systemPrompt.trim().length > 0) {
+      instructions.push(systemPrompt)
+    }
+
+    return false
+  })
+
+  if (remainingInput.length === normalizedPayload.input.length) {
+    return normalizedPayload
+  }
+
+  if (instructions.length > 0) {
+    // Codex expects system prompts in instructions instead of input messages.
+    normalizedPayload.instructions = instructions.join("\n\n")
+  }
+
+  if (remainingInput.length > 0) {
+    normalizedPayload.input = remainingInput
+  } else {
+    delete normalizedPayload.input
+  }
+
+  return normalizedPayload
+}
+
+const getResponseInputMessage = (
+  inputItem: ResponseInputItem,
+): ResponseInputMessage | undefined => {
+  if (typeof inputItem !== "object" || inputItem === null) {
+    return undefined
+  }
+
+  const { role, type } = inputItem as {
+    role?: unknown
+    type?: unknown
+  }
+  if (typeof role !== "string" || (type !== undefined && type !== "message")) {
+    return undefined
+  }
+
+  return inputItem as ResponseInputMessage
+}
+
+const getTextContent = (
+  content: ResponseInputMessage["content"],
+): string | undefined => {
+  if (typeof content === "string") {
+    return content
+  }
+
+  if (content === undefined) {
+    return ""
+  }
+
+  if (!Array.isArray(content)) {
+    return undefined
+  }
+
+  const textBlocks: Array<string> = []
+  for (const contentBlock of content) {
+    const text = getTextBlock(contentBlock)
+    if (text === undefined) {
+      return undefined
+    }
+
+    if (text.length > 0) {
+      textBlocks.push(text)
+    }
+  }
+
+  return textBlocks.join("\n\n")
+}
+
+const getTextBlock = (
+  contentBlock: ResponseInputContent,
+): string | undefined => {
+  if (typeof contentBlock !== "object" || contentBlock === null) {
+    return undefined
+  }
+
+  const { text, type } = contentBlock as {
+    text?: unknown
+    type?: unknown
+  }
+
+  if (type !== undefined && type !== "input_text" && type !== "output_text") {
+    return undefined
+  }
+
+  return typeof text === "string" ? text : undefined
+}
+
 const buildCodexResponsesWebSocketPoolKey = (
   payload: ResponsesPayload,
   headers: Record<string, string>,
@@ -250,9 +372,9 @@ const buildCodexResponsesWebSocketPoolKey = (
   const headerFingerprint = createHash("sha256")
     .update(
       JSON.stringify(
-        Object.entries(headers).sort(([left], [right]) =>
-          left.localeCompare(right),
-        ),
+        Object.entries(headers)
+          .filter(([headerName]) => !headerName.toLowerCase().includes("trace"))
+          .sort(([left], [right]) => left.localeCompare(right)),
       ),
     )
     .digest("hex")

src/routes/responses/handler.ts

@@ -372,6 +372,10 @@ export interface ResponseErrorEvent {
   param: string | null
   sequence_number: number
   type: "error"
+  error?: {
+    code: string | null
+    message: string
+  }
 }
 
 export interface ResponseFunctionCallArgumentsDeltaEvent {
@@ -451,6 +455,12 @@ export type ResponsesStream = ReturnType<typeof events>
 export type CreateResponsesReturn = ResponsesResult | ResponsesStream
 export type ResponsesTransport = "http" | "websocket"
 
+type ResponsesStreamChunk = {
+  data?: string
+  event?: string
+  id?: string | number
+}
+
 interface ResponsesRequestOptions {
   vision: boolean
   initiator: "agent" | "user"
@@ -698,14 +708,26 @@ export const getResponsesWebSocketInitiator = (
 const createPooledResponsesWebSocketStream = (
   request: ResponsesWebSocketRequest,
 ): ResponsesStream =>
-  createPooledWebSocketStream(request, {
-    createChunk: createResponsesWebSocketStreamChunk,
-    isTerminalChunk: isTerminalResponsesStreamChunk,
-    openErrorMessage: "Failed to create responses websocket",
-    streamErrorMessage: "Responses websocket stream error",
-    terminalChunkMissingMessage:
-      "Responses websocket ended without a terminal response",
-  }) as ResponsesStream
+  createResponsesSafeStream(
+    createPooledWebSocketStream(request, {
+      createChunk: createResponsesWebSocketStreamChunk,
+      isTerminalChunk: isTerminalResponsesStreamChunk,
+      openErrorMessage: "Failed to create responses websocket",
+      streamErrorMessage: "Responses websocket stream error",
+      terminalChunkMissingMessage:
+        "Responses websocket ended without a terminal response",
+    }),
+  )
+
+const createResponsesSafeStream = async function* (
+  source: AsyncIterable<ResponsesStreamChunk>,
+): AsyncGenerator<ResponsesStreamChunk, void, unknown> {
+  try {
+    yield* source
+  } catch (error) {
+    yield createResponsesErrorServerSentEventChunk(getErrorMessage(error))
+  }
+}
 
 export const buildResponsesWebSocketPayload = (
   payload: ResponsesPayload,
@@ -754,10 +776,20 @@ const createResponsesWebSocketStreamChunk = (
       copilot_quota_snapshots?: Record<string, CopilotQuotaSnapshot>
       id?: unknown
       type?: unknown
+      error?: {
+        code: string | null
+        message: string
+      }
+      code?: string | null
+      message?: string
     }
     if (parsed.type === "response.completed") {
       logCopilotQuotaSnapshots(parsed.copilot_quota_snapshots)
     }
+    if (parsed.type === "error" && parsed.error) {
+      parsed.code = parsed.error.code
+      parsed.message = parsed.error.message
+    }
     return {
       data: JSON.stringify(parsed),
       event: typeof parsed.type === "string" ? parsed.type : undefined,
@@ -785,3 +817,28 @@ const isTerminalResponsesStreamChunk = (chunk: { data?: string }): boolean => {
     return false
   }
 }
+
+const createResponsesErrorServerSentEventChunk = (
+  message: string,
+): ResponsesStreamChunk => {
+  const errorEvent: ResponseErrorEvent = {
+    code: null,
+    message,
+    param: null,
+    sequence_number: 0,
+    type: "error",
+  }
+
+  return {
+    data: JSON.stringify(errorEvent),
+    event: errorEvent.type,
+  }
+}
+
+const getErrorMessage = (error: unknown): string => {
+  if (error instanceof Error && error.message) {
+    return error.message
+  }
+
+  return String(error)
+}