opencode-translate 0.1.0 → 0.1.2

package/README.md

@@ -4,12 +4,12 @@
 
 ## What It Does
 
-- Activates once per root session when the first user message contains a trigger keyword such as `$en`.
+- Activates once per root session when any root-session user message contains a trigger keyword such as `$en`.
 - Translates user-authored text parts from `sourceLanguage` to English before the main LLM sees them.
 - 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
@@ -42,7 +42,7 @@ Hooks never throw. If the translator fails (network error, auth failure, provide
 1. Logs the error via `client.app.log` (visible with `verbose: true`).
 2. Emits a `⚠️ Translation failed: …` synthetic part.
 3. Falls back to sending the original (untranslated) user text to the model.
-4. On first-turn activation failure, it also rolls back activation so the next turn retries cleanly.
+4. On activation-turn failure, it also rolls back activation so the next turn retries cleanly.
 
 A stalled provider request is additionally bounded by a 60s hard timeout per translation call, so a hung upstream cannot block the OpenCode session.
 
@@ -75,7 +75,7 @@ opencode auth login anthropic
 export ANTHROPIC_API_KEY=...
 ```
 
-Start a brand-new session and put the trigger in the first message:
+Put the trigger in the message where translation should begin. Earlier messages in the session are left as-is:
 
 ```text
 $en 프로젝트 루트의 package.json을 읽고 요약해줘

package/package.json

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

@@ -32,7 +32,12 @@ import {
 } from "./question-tool"
 import { createSyntheticPartID, createTranslator, hashText } from "./translator"
 
-const sessionStateCache = new Map<string, TranslateState | null>()
+const INACTIVE_ROOT_SESSION = "inactive-root"
+const INACTIVE_CHILD_SESSION = "inactive-child"
+
+type CachedSessionState = TranslateState | typeof INACTIVE_ROOT_SESSION | typeof INACTIVE_CHILD_SESSION
+
+const sessionStateCache = new Map<string, CachedSessionState>()
 const questionSnapshots = new Map<string, QuestionSnapshot>()
 const QUESTION_TOOL_ID = "question"
 
@@ -249,10 +254,26 @@ async function resolveSessionState(
 ): Promise<ResolvedSessionState> {
   const cached = sessionStateCache.get(sessionID)
   if (cached !== undefined) {
+    if (cached === INACTIVE_ROOT_SESSION) {
+      return {
+        sessionActive: false,
+        canActivate: true,
+        storedMessages: [],
+      }
+    }
+
+    if (cached === INACTIVE_CHILD_SESSION) {
+      return {
+        sessionActive: false,
+        canActivate: false,
+        storedMessages: [],
+      }
+    }
+
     return {
-      sessionActive: Boolean(cached),
+      sessionActive: true,
       canActivate: false,
-      state: cached ?? undefined,
+      state: cached,
       storedMessages: [],
     }
   }
@@ -265,7 +286,7 @@ async function resolveSessionState(
     }),
   )
   if (session.parentID != null) {
-    sessionStateCache.set(sessionID, null)
+    sessionStateCache.set(sessionID, INACTIVE_CHILD_SESSION)
     return { sessionActive: false, canActivate: false, storedMessages: [] }
   }
 
@@ -279,13 +300,13 @@ async function resolveSessionState(
   const state = extractStoredState(storedMessages)
   if (state) {
     sessionStateCache.set(sessionID, state)
-  } else if (storedMessages.length > 0) {
-    sessionStateCache.set(sessionID, null)
+  } else {
+    sessionStateCache.set(sessionID, INACTIVE_ROOT_SESSION)
   }
 
   return {
     sessionActive: Boolean(state),
-    canActivate: storedMessages.length === 0,
+    canActivate: !state,
     state: state ?? undefined,
     storedMessages,
   }
@@ -326,8 +347,6 @@ export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, de
             }
             activatedThisTurn = true
             sessionStateCache.set(input.sessionID, activeState)
-          } else {
-            sessionStateCache.set(input.sessionID, null)
           }
         }
 
@@ -424,7 +443,7 @@ export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, de
         // user-authored part, roll back activation so the next turn does a
         // clean retry instead of cementing broken state.
         if (activatedThisTurn && translationErrors.length > 0 && eligibleIndex === translationErrors.length) {
-          sessionStateCache.set(input.sessionID, null)
+          sessionStateCache.set(input.sessionID, INACTIVE_ROOT_SESSION)
           return
         }
 
@@ -536,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)
@@ -579,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)
 }