opencode-translate 0.1.1 → 0.1.2

package/README.md

@@ -9,7 +9,7 @@
 - Stores the original user text, plus a cached English translation in part metadata.
 - Shows a visible `→ EN: ...` preview under each translated user text part.
 - Translates assistant text parts from English into `displayLanguage` when each text part completes.
-- Translates the built-in `question` tool's question text, header, and every option's label and description into `displayLanguage` so the TUI confirmation dialog is in the user's language. The tool output string returned to the LLM is restored to English, keeping the chat history English-only.
+- Translates the built-in `question` tool's question text, header, and every option's label and description into `displayLanguage` so the TUI confirmation dialog is in the user's language. The tool output string returned to the LLM is restored to English, including translation of non-empty custom answers.
 - Stores assistant text as:
 
 ```md

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-translate",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "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/activation.ts

@@ -555,35 +555,36 @@ export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, de
     },
     // Translate the built-in `question` tool so the TUI dialog renders in
     // the user's displayLanguage. The tool output string is restored back
-    // to English in `tool.execute.after` so the main LLM context stays
-    // English-only.
+    // to English in `tool.execute.after`; typed custom answers also go
+    // through the inbound user-message translation path.
     "tool.execute.before": async (input, output) => {
       try {
         if (input.tool !== QUESTION_TOOL_ID) return
         const resolved = await resolveSessionState(client, ctx.directory, input.sessionID)
         const activeState = resolved.state
         if (!activeState) return
-        if (activeState.translate_display_lang === LLM_LANGUAGE) return
 
         const args = output.args as unknown
         if (!isQuestionArgs(args)) return
 
         const original = snapshotQuestions(args)
-        try {
-          await translateQuestionArgs(args, (text) =>
-            translator.translateText({
-              text,
-              sourceLanguage: LLM_LANGUAGE,
-              targetLanguage: activeState.translate_display_lang,
-              direction: "outbound",
-            }),
-          )
-        } catch (error) {
-          // Translation failed: restore the originals so the dialog at least
-          // renders in English instead of a half-translated mess.
-          args.questions.splice(0, args.questions.length, ...snapshotQuestions({ questions: original }))
-          await logError(client, error)
-          return
+        if (activeState.translate_display_lang !== LLM_LANGUAGE) {
+          try {
+            await translateQuestionArgs(args, (text) =>
+              translator.translateText({
+                text,
+                sourceLanguage: LLM_LANGUAGE,
+                targetLanguage: activeState.translate_display_lang,
+                direction: "outbound",
+              }),
+            )
+          } catch (error) {
+            // Translation failed: restore the originals so the dialog at least
+            // renders in English instead of a half-translated mess.
+            args.questions.splice(0, args.questions.length, ...snapshotQuestions({ questions: original }))
+            await logError(client, error)
+            return
+          }
         }
 
         const translated = snapshotQuestions(args)
@@ -598,7 +599,32 @@ export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, de
         const snapshot = questionSnapshots.get(input.callID)
         if (!snapshot) return
         questionSnapshots.delete(input.callID)
-        restoreQuestionOutput(output as QuestionToolOutput, snapshot)
+        const resolved = await resolveSessionState(client, ctx.directory, input.sessionID)
+        const activeState = resolved.state
+        const translateCustomAnswer =
+          activeState && activeState.translate_source_lang !== LLM_LANGUAGE
+            ? (text: string) =>
+                translator.translateText({
+                  text,
+                  sourceLanguage: activeState.translate_source_lang,
+                  targetLanguage: LLM_LANGUAGE,
+                  direction: "inbound",
+                })
+            : undefined
+
+        await restoreQuestionOutput(output as QuestionToolOutput, snapshot, {
+          ...(translateCustomAnswer ? { translateCustomAnswer } : {}),
+          onTranslationError: async (error) => {
+            if (!activeState) {
+              await logError(client, error)
+              return
+            }
+            await logError(
+              client,
+              buildInboundTranslationError(activeState.translate_source_lang, normalizeReason(error)),
+            )
+          },
+        })
       } catch (error) {
         await logError(client, error)
       }

package/src/question-tool.ts

@@ -9,8 +9,10 @@
 //   3. OpenCode publishes `question.asked`; the TUI shows the translated
 //      dialog and the user picks an option (or types a custom answer).
 //   4. `tool.execute.after` hook reverses the substitution using the
-//      snapshot we captured in step 2, so the tool output string delivered
-//      back to the LLM stays in English.
+//      snapshot we captured in step 2. Selected options are restored by
+//      label mapping; non-empty custom answers are translated like normal
+//      user messages, so the output delivered back to the LLM stays in
+//      English.
 //
 // A per-callID snapshot is kept so mapping a user-selected translated label
 // back to its original English label is deterministic.
@@ -35,6 +37,11 @@ export interface QuestionToolOutput {
   metadata?: { answers?: readonly (readonly string[])[] } | Record<string, unknown>
 }
 
+export interface RestoreQuestionOutputOptions {
+  translateCustomAnswer?: (text: string) => Promise<string>
+  onTranslationError?: (error: unknown) => Promise<void> | void
+}
+
 function cloneQuestion(q: TextRecord): TextRecord {
   return {
     question: q.question,
@@ -80,9 +87,8 @@ async function assignTranslation(
   container[key] = unwrapEchoedTextEnvelope(translated)
 }
 
-// Translate every display-facing string in `args` in parallel. Returns the
-// snapshot of the translated form so the caller can pair it with the
-// pre-translation snapshot taken with `snapshotQuestions`.
+// Translate every display-facing string in `args` in parallel. The caller can
+// snapshot the translated form afterward with `snapshotQuestions`.
 export async function translateQuestionArgs(
   args: QuestionArgs,
   translate: (text: string) => Promise<string>,
@@ -101,44 +107,61 @@ export async function translateQuestionArgs(
   await Promise.all(jobs)
 }
 
-// Given the user-selected labels (`answers`), find the matching translated
-// option and return its original English label. If no match (e.g. a custom
-// free-text answer), return the label verbatim so the LLM still sees what
-// the user actually typed.
-function restoreLabel(
+// Given a user-selected label, find the matching translated option and return
+// its original English label. If no match exists, OpenCode only gives us the
+// raw answer string, so treat non-empty text as a custom answer and translate
+// it through the same source-language -> English path as normal user messages.
+async function restoreLabel(
   selectedLabel: string,
   translatedOptions: readonly OptionRecord[],
   originalOptions: readonly OptionRecord[],
-): string {
+  options: RestoreQuestionOutputOptions,
+): Promise<string> {
   const idx = translatedOptions.findIndex((option) => option.label === selectedLabel)
-  if (idx < 0) return selectedLabel
-  return originalOptions[idx]?.label ?? selectedLabel
+  if (idx >= 0) return originalOptions[idx]?.label ?? selectedLabel
+  if (!options.translateCustomAnswer || selectedLabel.trim().length === 0) return selectedLabel
+
+  try {
+    const translated = await options.translateCustomAnswer(selectedLabel)
+    return unwrapEchoedTextEnvelope(translated)
+  } catch (error) {
+    await options.onTranslationError?.(error)
+    return selectedLabel
+  }
 }
 
 // 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 function buildRestoredOutput(
+export async function buildRestoredOutput(
   original: readonly TextRecord[],
   translated: readonly TextRecord[],
   answers: readonly (readonly string[])[],
-): string {
-  const formatted = original
-    .map((q, i) => {
+  options: RestoreQuestionOutputOptions = {},
+): Promise<string> {
+  const formattedParts = await Promise.all(
+    original.map(async (q, i) => {
       const selected = answers[i] ?? []
       const translatedOptions = translated[i]?.options ?? []
       const originalOptions = q.options
-      const restored = selected.map((label) => restoreLabel(label, translatedOptions, originalOptions))
+      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}"`
-    })
-    .join(", ")
+    }),
+  )
+  const formatted = formattedParts.join(", ")
   return `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`
 }
 
-export function restoreQuestionOutput(output: QuestionToolOutput, snapshot: QuestionSnapshot): void {
+export async function restoreQuestionOutput(
+  output: QuestionToolOutput,
+  snapshot: QuestionSnapshot,
+  options: RestoreQuestionOutputOptions = {},
+): Promise<void> {
   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 = buildRestoredOutput(snapshot.original, snapshot.translated, answers)
+  output.output = await buildRestoredOutput(snapshot.original, snapshot.translated, answers, options)
 }