opencode-translate 0.0.15 → 0.0.17

package/README.md

@@ -127,7 +127,7 @@ If you prefer a plain API key, set `ANTHROPIC_API_KEY` in the environment or pas
 
 If `translatorModel` uses OpenAI and OpenCode auth is backed by the ChatGPT/Codex OAuth flow, the plugin reuses those OAuth credentials for translation requests.
 
-For OAuth-backed OpenAI requests, the plugin routes the OpenAI AI SDK request to `https://chatgpt.com/backend-api/codex/responses` and normalizes the request body to Codex's expected typed `input` shape. This supports models such as `openai/gpt-5.5` when your ChatGPT plan has access.
+For OAuth-backed OpenAI requests, the plugin routes the OpenAI AI SDK request to `https://chatgpt.com/backend-api/codex/responses`, adds the required Codex beta/originator headers, normalizes the request body to Codex's expected typed `input` shape, and converts Codex SSE responses back to JSON for translation calls. This supports models such as `openai/gpt-5.5` when your ChatGPT plan has access.
 
 If you prefer a plain API key, set `OPENAI_API_KEY` in the environment or pass `apiKey` in plugin options. The plugin prefers explicit `apiKey`, then `OPENAI_API_KEY`, then OAuth.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-translate",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "OpenCode plugin that lets the user chat in a configured source language while the main chat loop only sees English.",
   "type": "module",
   "main": "src/index.ts",

package/src/auth.ts

@@ -142,24 +142,30 @@ function normalizeCodexInputItem(item: unknown, instructions: string[]): unknown
   return item
 }
 
-function rewriteOpenAICodexBody(body: BodyInit | null | undefined): BodyInit | null | undefined {
-  if (typeof body !== "string") return body
+interface CodexBodyRewrite {
+  body: BodyInit | null | undefined
+  originalStream: boolean
+}
+
+function rewriteOpenAICodexBody(body: BodyInit | null | undefined): CodexBodyRewrite {
+  if (typeof body !== "string") return { body, originalStream: false }
 
   let parsed: unknown
   try {
     parsed = JSON.parse(body)
   } catch {
-    return body
+    return { body, originalStream: false }
   }
 
-  if (!isRecord(parsed)) return body
+  if (!isRecord(parsed)) return { body, originalStream: false }
+  const originalStream = parsed.stream === true
 
   const sourceInput = Array.isArray(parsed.input)
     ? parsed.input
     : Array.isArray(parsed.messages)
       ? parsed.messages
       : undefined
-  if (!sourceInput) return body
+  if (!sourceInput) return { body, originalStream }
 
   const instructions: string[] = []
   if (typeof parsed.instructions === "string" && parsed.instructions) instructions.push(parsed.instructions)
@@ -168,18 +174,110 @@ function rewriteOpenAICodexBody(body: BodyInit | null | undefined): BodyInit | n
     .map((item) => normalizeCodexInputItem(item, instructions))
     .filter((item): item is unknown => item !== undefined)
 
-  return JSON.stringify({
-    ...parsed,
-    instructions: instructions.join("\n\n"),
-    input,
-    tools: Array.isArray(parsed.tools) ? parsed.tools : [],
-    tool_choice: typeof parsed.tool_choice === "string" ? parsed.tool_choice : "auto",
-    parallel_tool_calls: typeof parsed.parallel_tool_calls === "boolean" ? parsed.parallel_tool_calls : false,
-    store: typeof parsed.store === "boolean" ? parsed.store : false,
-    stream: typeof parsed.stream === "boolean" ? parsed.stream : false,
-    include: Array.isArray(parsed.include) ? parsed.include : [],
-    messages: undefined,
-  })
+  const include = Array.isArray(parsed.include)
+    ? parsed.include.filter((item): item is string => typeof item === "string")
+    : []
+  if (!include.includes("reasoning.encrypted_content")) include.push("reasoning.encrypted_content")
+
+  return {
+    body: JSON.stringify({
+      ...parsed,
+      instructions: instructions.join("\n\n"),
+      input,
+      tools: Array.isArray(parsed.tools) ? parsed.tools : [],
+      tool_choice: typeof parsed.tool_choice === "string" ? parsed.tool_choice : "auto",
+      parallel_tool_calls: typeof parsed.parallel_tool_calls === "boolean" ? parsed.parallel_tool_calls : false,
+      store: false,
+      stream: true,
+      include,
+      max_output_tokens: undefined,
+      max_completion_tokens: undefined,
+      messages: undefined,
+    }),
+    originalStream,
+  }
+}
+
+function normalizeCodexOutputItem(item: unknown, index: number): unknown | undefined {
+  if (!isRecord(item)) return undefined
+  if (item.type !== "message" || item.role !== "assistant") return item
+  if (!Array.isArray(item.content)) return undefined
+
+  const content: Record<string, unknown>[] = []
+  for (const part of item.content) {
+    if (!isRecord(part) || part.type !== "output_text" || typeof part.text !== "string") continue
+    content.push({ ...part, annotations: Array.isArray(part.annotations) ? part.annotations : [] })
+  }
+
+  if (content.length === 0) return undefined
+  return {
+    ...item,
+    id: typeof item.id === "string" ? item.id : `msg_opencode_translate_${index}`,
+    role: "assistant",
+    content,
+  }
+}
+
+function buildCodexTextOutput(text: string): Record<string, unknown> {
+  return {
+    type: "message",
+    id: "msg_opencode_translate_0",
+    role: "assistant",
+    content: [{ type: "output_text", text, annotations: [] }],
+  }
+}
+
+function parseCodexSSEResponse(text: string): unknown | undefined {
+  let finalResponse: unknown
+  let deltaText = ""
+  const outputItems: unknown[] = []
+
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.startsWith("data: ")) continue
+    const payload = line.slice(6).trim()
+    if (!payload || payload === "[DONE]") continue
+    try {
+      const parsed = JSON.parse(payload) as Record<string, unknown>
+      if (parsed.type === "response.output_text.delta" && typeof parsed.delta === "string") {
+        deltaText += parsed.delta
+        continue
+      }
+      if (
+        (parsed.type === "response.output_item.done" || parsed.type === "response.output_item.added") &&
+        parsed.item
+      ) {
+        outputItems.push(parsed.item)
+        continue
+      }
+      if ((parsed.type === "response.done" || parsed.type === "response.completed") && parsed.response) {
+        finalResponse = parsed.response
+      }
+    } catch {}
+  }
+
+  if (!finalResponse && !deltaText && outputItems.length === 0) return undefined
+
+  const response: Record<string, unknown> = isRecord(finalResponse)
+    ? { ...finalResponse }
+    : { id: "resp_opencode_translate" }
+  const existingOutput: unknown[] = Array.isArray(response.output) ? response.output : []
+  const sourceOutput = existingOutput.length > 0 ? existingOutput : outputItems
+  const normalizedOutput = sourceOutput
+    .map((item, index) => normalizeCodexOutputItem(item, index))
+    .filter((item): item is unknown => item !== undefined)
+
+  response.output = normalizedOutput.length > 0 ? normalizedOutput : deltaText ? [buildCodexTextOutput(deltaText)] : []
+  return response
+}
+
+async function convertCodexSSEToJSON(response: Response): Promise<Response> {
+  const headers = new Headers(response.headers)
+  const text = await response.text()
+  const parsed = parseCodexSSEResponse(text)
+  if (!parsed) return new Response(text, { status: response.status, statusText: response.statusText, headers })
+
+  headers.set("content-type", "application/json; charset=utf-8")
+  return new Response(JSON.stringify(parsed), { status: response.status, statusText: response.statusText, headers })
 }
 
 function isMissingCredentialError(error: unknown): boolean {
@@ -495,6 +593,7 @@ export function createCredentialResolver(
         input instanceof URL ? new URL(input.href) : new URL(typeof input === "string" ? input : input.url)
 
       let nextBody = init?.body
+      let convertCodexResponse = false
 
       if (providerID === "anthropic") {
         // Match the Claude Code CLI fingerprint so Anthropic's OAuth rate-limit
@@ -514,11 +613,16 @@ export function createCredentialResolver(
           inputUrl.hostname === "api.openai.com" &&
           (inputUrl.pathname === "/v1/chat/completions" || inputUrl.pathname === "/v1/responses")
         ) {
+          const rewritten = rewriteOpenAICodexBody(nextBody)
           inputUrl.protocol = "https:"
           inputUrl.hostname = "chatgpt.com"
           inputUrl.pathname = "/backend-api/codex/responses"
           inputUrl.search = ""
-          nextBody = rewriteOpenAICodexBody(nextBody)
+          nextBody = rewritten.body
+          convertCodexResponse = !rewritten.originalStream
+          headers.set("OpenAI-Beta", "responses=experimental")
+          headers.set("originator", "codex_cli_rs")
+          headers.set("accept", "text/event-stream")
           headers.delete("content-length")
         }
       }
@@ -547,11 +651,13 @@ export function createCredentialResolver(
         }
       }
 
-      return fetchImpl(inputUrl, {
+      const response = await fetchImpl(inputUrl, {
         ...init,
         headers,
         body: nextBody,
       })
+      if (convertCodexResponse && response.ok) return convertCodexSSEToJSON(response)
+      return response
     }
   }