opencode-translate 0.3.6 → 1.0.1

package/README.md

@@ -1,14 +1,19 @@
 # opencode-translate
 
+> Use opencode in your native language. LLM always hears English.
+
 ![banner](https://github.com/user-attachments/assets/0bb6739c-abc5-4c3e-837e-2aaf5533a359)
 
+## Demo
+
+![demo](./assets/demo.gif)
+
 ## Why
 
 LLMs are worse in non-English. Benchmarks confirm it on every frontier model.
 
 - **Claude Opus 4.7 / GPT-5.5 / Gemini 3.1 Pro**: identical coding tasks scored **5/5 in English** but dropped to **0–1/5 in Arabic and Korean** ([LILT, 2025](https://lilt.com/blog/multilingual-ai-coding-gap-non-english-developers)).
 - **Anthropic's own numbers**: Japanese 96.9%, Korean 96.6%, Yoruba 80.3% — English is always the baseline ([Anthropic docs](https://platform.claude.com/docs/en/build-with-claude/multilingual-support)).
-- **Translation Barrier Hypothesis** (JHU, IJCNLP 2025): LLMs reason in an English-dominant latent space, then translate at the last layers — every translation step is a source of error.
 - **Token tax**: Korean ~1.25×, Japanese ~1.25×, Arabic ~3× more tokens per equivalent content. Higher cost, smaller effective context.
 
 This plugin lets you write in your language while the model works in English — best of both worlds.
@@ -29,7 +34,7 @@ Add to `~/.config/opencode/opencode.jsonc`:
 {
   "plugin": [
     ["opencode-translate", {
-      "model": "anthropic/claude-haiku-4-5", // model to use for translation
+      "model": "openai/gpt-5.4-mini", // model to use for translation
       "lang": "Korean"                        // language you speak
     }]
   ]

package/package.json

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

package/src/activation/question-hooks.ts

@@ -4,6 +4,7 @@ import {
   isQuestionArgs,
   type QuestionSnapshot,
   type QuestionToolOutput,
+  restoreQuestionArgs,
   restoreQuestionOutput,
   snapshotQuestions,
   translateQuestionArgs,
@@ -58,7 +59,11 @@ export function createToolExecuteBeforeHook(ctx: HookContext): NonNullable<Hooks
         }
       }
 
-      questionSnapshots.set(input.callID, { original, translated: snapshotQuestions(args) })
+      questionSnapshots.set(input.callID, {
+        original,
+        translated: snapshotQuestions(args),
+        userLanguage: activeState.translate_user_lang,
+      })
       pruneQuestionSnapshots()
     } catch (error) {
       await logError(ctx.client, error)
@@ -73,10 +78,9 @@ export function createToolExecuteAfterHook(ctx: HookContext): NonNullable<Hooks[
       const snapshot = questionSnapshots.get(input.callID)
       if (!snapshot) return
       questionSnapshots.delete(input.callID)
+      if (isQuestionArgs(input.args)) restoreQuestionArgs(input.args, snapshot.original)
 
-      const resolved = await resolveSessionState(ctx.client, ctx.directory, input.sessionID)
-      const activeState = resolved.state
-      if (!activeState || activeState.translate_user_lang === LLM_LANGUAGE) {
+      if (snapshot.userLanguage === LLM_LANGUAGE) {
         await restoreQuestionOutput(output as QuestionToolOutput, snapshot)
         return
       }
@@ -85,15 +89,12 @@ export function createToolExecuteAfterHook(ctx: HookContext): NonNullable<Hooks[
         translateCustomAnswer: (text: string) =>
           ctx.translator.translateText({
             text,
-            sourceLanguage: activeState.translate_user_lang,
+            sourceLanguage: snapshot.userLanguage,
             targetLanguage: LLM_LANGUAGE,
             direction: "inbound",
           }),
         onTranslationError: async (error) => {
-          await logError(
-            ctx.client,
-            buildInboundTranslationError(activeState.translate_user_lang, normalizeReason(error)),
-          )
+          await logError(ctx.client, buildInboundTranslationError(snapshot.userLanguage, normalizeReason(error)))
         },
       })
     } catch (error) {

package/src/question-tool.ts

@@ -29,6 +29,7 @@ export interface QuestionArgs {
 export interface QuestionSnapshot {
   original: TextRecord[]
   translated: TextRecord[]
+  userLanguage: string
 }
 
 export interface QuestionToolOutput {
@@ -56,6 +57,10 @@ export function snapshotQuestions(args: QuestionArgs): TextRecord[] {
   return args.questions.map(cloneQuestion)
 }
 
+export function restoreQuestionArgs(args: QuestionArgs, original: readonly TextRecord[]): void {
+  args.questions.splice(0, args.questions.length, ...original.map(cloneQuestion))
+}
+
 export function isQuestionArgs(value: unknown): value is QuestionArgs {
   if (!value || typeof value !== "object") return false
   const questions = (value as Record<string, unknown>).questions
@@ -142,31 +147,55 @@ async function restoreLabel(
   }
 }
 
-// Reconstruct the exact output string the question tool would have produced
-// if it had been called with the original English args. Mirrors the format
-// in `packages/opencode/src/tool/question.ts` (as of opencode 1.14.x).
-export async function buildRestoredOutput(
+async function restoreQuestionAnswers(
   original: readonly TextRecord[],
   translated: readonly TextRecord[],
   answers: readonly (readonly string[])[],
   options: RestoreQuestionOutputOptions = {},
-): Promise<string> {
-  const formattedParts = await Promise.all(
+): Promise<string[][]> {
+  return Promise.all(
     original.map(async (q, i) => {
       const selected = answers[i] ?? []
       const translatedOptions = translated[i]?.options ?? []
       const originalOptions = q.options
-      const restored = await Promise.all(
-        selected.map((label) => restoreLabel(label, translatedOptions, originalOptions, options)),
-      )
-      const rendered = restored.length > 0 ? restored.join(", ") : "Unanswered"
-      return `"${q.question}"="${rendered}"`
+      return Promise.all(selected.map((label) => restoreLabel(label, translatedOptions, originalOptions, options)))
     }),
   )
+}
+
+function formatRestoredOutput(original: readonly TextRecord[], answers: readonly (readonly string[])[]): string {
+  const formattedParts = original.map((q, i) => {
+    const restored = answers[i] ?? []
+    const rendered = restored.length > 0 ? restored.join(", ") : "Unanswered"
+    return `"${q.question}"="${rendered}"`
+  })
   const formatted = formattedParts.join(", ")
   return `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`
 }
 
+// Reconstruct the exact output string the question tool would have produced
+// if it had been called with the original English args. Mirrors the format
+// in `packages/opencode/src/tool/question.ts` (as of opencode 1.14.x).
+export async function buildRestoredOutput(
+  original: readonly TextRecord[],
+  translated: readonly TextRecord[],
+  answers: readonly (readonly string[])[],
+  options: RestoreQuestionOutputOptions = {},
+): Promise<string> {
+  const restoredAnswers = await restoreQuestionAnswers(original, translated, answers, options)
+  return formatRestoredOutput(original, restoredAnswers)
+}
+
+function mutableMetadata(output: QuestionToolOutput): Record<string, unknown> {
+  if (output.metadata && typeof output.metadata === "object" && !Array.isArray(output.metadata)) {
+    return output.metadata as Record<string, unknown>
+  }
+
+  const metadata: Record<string, unknown> = {}
+  output.metadata = metadata
+  return metadata
+}
+
 export async function restoreQuestionOutput(
   output: QuestionToolOutput,
   snapshot: QuestionSnapshot,
@@ -175,5 +204,7 @@ export async function restoreQuestionOutput(
   if (typeof output.output !== "string") return
   const answersRaw = (output.metadata as { answers?: readonly (readonly string[])[] } | undefined)?.answers
   const answers = Array.isArray(answersRaw) ? answersRaw : []
-  output.output = await buildRestoredOutput(snapshot.original, snapshot.translated, answers, options)
+  const restoredAnswers = await restoreQuestionAnswers(snapshot.original, snapshot.translated, answers, options)
+  output.output = formatRestoredOutput(snapshot.original, restoredAnswers)
+  mutableMetadata(output).answers = restoredAnswers
 }