opencode-translate 0.0.14 → 0.0.16

package/README.md

@@ -123,6 +123,14 @@ Tradeoffs:
 
 If you prefer a plain API key, set `ANTHROPIC_API_KEY` in the environment or pass `apiKey` in plugin options. The plugin prefers explicit `apiKey`, then `ANTHROPIC_API_KEY`, then OAuth.
 
+## OpenAI OAuth Support
+
+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`, 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.
+
 ## Manual Smoke Test
 
 1. Install the plugin and configure `sourceLanguage: "ko"`, `displayLanguage: "ko"`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-translate",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "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

@@ -78,6 +78,151 @@ function setUserAgent(headers: Headers, packageVersion?: string) {
   headers.set("User-Agent", packageVersion ? `${USER_AGENT.replace("0.0.0", packageVersion)}` : USER_AGENT)
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value)
+}
+
+function textFromContent(content: unknown): string | undefined {
+  if (typeof content === "string") return content
+  if (!Array.isArray(content)) return undefined
+
+  const text = content
+    .map((part) => (isRecord(part) && typeof part.text === "string" ? part.text : undefined))
+    .filter((value): value is string => value !== undefined)
+    .join("\n")
+
+  return text || undefined
+}
+
+function normalizeCodexContent(role: string, content: unknown): Record<string, unknown>[] {
+  const textType = role === "assistant" ? "output_text" : "input_text"
+  if (typeof content === "string") return [{ type: textType, text: content }]
+  if (!Array.isArray(content)) return []
+
+  const result: Record<string, unknown>[] = []
+  for (const part of content) {
+    if (!isRecord(part)) continue
+    const type = part.type
+    if (type === "input_text" || type === "output_text") {
+      result.push({ ...part, type: textType })
+      continue
+    }
+    if (type === "input_image") {
+      result.push({ ...part })
+      continue
+    }
+    if (typeof part.text === "string") {
+      result.push({ type: textType, text: part.text })
+    }
+  }
+
+  return result
+}
+
+function normalizeCodexInputItem(item: unknown, instructions: string[]): unknown | undefined {
+  if (!isRecord(item)) return item
+  const role = typeof item.role === "string" ? item.role : undefined
+
+  if (role === "system" || role === "developer") {
+    const text = textFromContent(item.content)
+    if (text) instructions.push(text)
+    return undefined
+  }
+
+  if (item.type === "message" && role) {
+    const content = normalizeCodexContent(role, item.content)
+    return content.length > 0 ? { ...item, role, content } : undefined
+  }
+
+  if (role) {
+    const content = normalizeCodexContent(role, item.content)
+    return content.length > 0 ? { type: "message", role, content } : undefined
+  }
+
+  return item
+}
+
+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, originalStream: false }
+  }
+
+  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, originalStream }
+
+  const instructions: string[] = []
+  if (typeof parsed.instructions === "string" && parsed.instructions) instructions.push(parsed.instructions)
+
+  const input = sourceInput
+    .map((item) => normalizeCodexInputItem(item, instructions))
+    .filter((item): item is unknown => item !== 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 parseCodexSSEResponse(text: string): unknown | undefined {
+  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.done" || parsed.type === "response.completed") && parsed.response) {
+        return parsed.response
+      }
+    } catch {}
+  }
+  return undefined
+}
+
+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 {
   const message = normalizeReason(error).toLowerCase()
   return (
@@ -244,7 +389,6 @@ async function refreshOpenAI(
     grant_type: "refresh_token",
     refresh_token: info.refresh,
     client_id: "app_EMoamEEZ73f0CkXaXp7hrann",
-    scope: "openid profile email offline_access",
   })
   const response = await withRetry(
     () =>
@@ -392,6 +536,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
@@ -411,10 +556,17 @@ 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 = 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")
         }
       }
 
@@ -442,11 +594,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
     }
   }
 

package/src/translator.ts

@@ -210,6 +210,12 @@ function instantiateModel(provider: unknown, modelID: string): unknown {
   throw new Error(`Unable to instantiate model "${modelID}"`)
 }
 
+function supportsTemperature(providerID: string, modelID: string): boolean {
+  if (providerID !== "openai") return true
+  if (modelID.startsWith("o1") || modelID.startsWith("o3") || modelID.startsWith("o4-mini")) return false
+  return !(modelID.startsWith("gpt-5") && !modelID.startsWith("gpt-5-chat"))
+}
+
 function isAuthMessage(error: unknown): boolean {
   if (!(error instanceof Error)) return false
   return error.message.includes(":AUTH_UNAVAILABLE]") || error.message.includes(":OAUTH_REFRESH_FAILED]")
@@ -272,7 +278,7 @@ export function createTranslator(
               targetLanguage: input.targetLanguage,
               text: input.text,
             }),
-            temperature: 0,
+            ...(supportsTemperature(providerID, modelID) ? { temperature: 0 } : {}),
             prompt: buildUserPrompt({
               sourceLanguage: input.sourceLanguage,
               targetLanguage: input.targetLanguage,