opencode-translate 0.2.1 → 0.2.2

package/README.md

@@ -44,7 +44,7 @@ Hooks never throw. If the translator fails (network error, auth failure, provide
 3. Falls back to sending the original (untranslated) user text to the model.
 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.
+A stalled provider request is additionally bounded by a 180s hard timeout per translation call, so a hung upstream cannot block the OpenCode session.
 
 ## Install
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-translate",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "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/index.ts

@@ -19,7 +19,7 @@ export function __resetActivationCacheForTest() {
 export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, deps: HookDependencies = {}): Hooks {
   if (process.env.OPENCODE_TRANSLATE_DISABLE === "1") return {}
 
-  const client = ctx.client as unknown as PluginClientLike
+  const client = ctx.client as PluginClientLike
   const options = resolveOptions(rawOptions)
   const hookContext: HookContext = {
     client,

package/src/activation/question-hooks.ts

@@ -12,8 +12,19 @@ import { logError } from "./logging"
 import { resolveSessionState } from "./state"
 import { type HookContext, QUESTION_TOOL_ID } from "./types"
 
+const QUESTION_SNAPSHOT_LIMIT = 1_000
+
 const questionSnapshots = new Map<string, QuestionSnapshot>()
 
+function pruneQuestionSnapshots() {
+  while (questionSnapshots.size > QUESTION_SNAPSHOT_LIMIT) {
+    for (const callID of questionSnapshots.keys()) {
+      questionSnapshots.delete(callID)
+      break
+    }
+  }
+}
+
 export function resetQuestionSnapshots() {
   questionSnapshots.clear()
 }
@@ -26,8 +37,8 @@ export function createToolExecuteBeforeHook(ctx: HookContext): NonNullable<Hooks
       const activeState = resolved.state
       if (!activeState) return
 
-      const args = output.args as unknown
-      if (!isQuestionArgs(args)) return
+      if (!isQuestionArgs(output.args)) return
+      const args = output.args
 
       const original = snapshotQuestions(args)
       if (activeState.translate_user_lang !== LLM_LANGUAGE) {
@@ -48,6 +59,7 @@ export function createToolExecuteBeforeHook(ctx: HookContext): NonNullable<Hooks
       }
 
       questionSnapshots.set(input.callID, { original, translated: snapshotQuestions(args) })
+      pruneQuestionSnapshots()
     } catch (error) {
       await logError(ctx.client, error)
     }
@@ -64,24 +76,20 @@ export function createToolExecuteAfterHook(ctx: HookContext): NonNullable<Hooks[
 
       const resolved = await resolveSessionState(ctx.client, ctx.directory, input.sessionID)
       const activeState = resolved.state
-      const translateCustomAnswer =
-        activeState && activeState.translate_user_lang !== LLM_LANGUAGE
-          ? (text: string) =>
-              ctx.translator.translateText({
-                text,
-                sourceLanguage: activeState.translate_user_lang,
-                targetLanguage: LLM_LANGUAGE,
-                direction: "inbound",
-              })
-          : undefined
+      if (!activeState || activeState.translate_user_lang === LLM_LANGUAGE) {
+        await restoreQuestionOutput(output as QuestionToolOutput, snapshot)
+        return
+      }
 
       await restoreQuestionOutput(output as QuestionToolOutput, snapshot, {
-        ...(translateCustomAnswer ? { translateCustomAnswer } : {}),
+        translateCustomAnswer: (text: string) =>
+          ctx.translator.translateText({
+            text,
+            sourceLanguage: activeState.translate_user_lang,
+            targetLanguage: LLM_LANGUAGE,
+            direction: "inbound",
+          }),
         onTranslationError: async (error) => {
-          if (!activeState) {
-            await logError(ctx.client, error)
-            return
-          }
           await logError(
             ctx.client,
             buildInboundTranslationError(activeState.translate_user_lang, normalizeReason(error)),

package/src/auth/index.ts

@@ -18,12 +18,8 @@ import { refreshAnthropic, refreshOpenAI } from "./refresh"
 import { ensureOAuthInfo, normalizeProviderKey, readAuthMap } from "./store"
 import type { AuthDependencies, AuthRuntime, ResolvedCredential } from "./types"
 
-const credentialCache = new Map<string, ResolvedCredential>()
-const oauthRefreshInflight = new Map<string, Promise<OAuthInfo>>()
-
 export function __resetAuthCachesForTest() {
-  credentialCache.clear()
-  oauthRefreshInflight.clear()
+  // Resolver instances own their caches; this remains as a stable test helper.
 }
 
 function isMissingCredentialError(error: unknown): boolean {
@@ -72,6 +68,8 @@ export function createCredentialResolver(
   options: ResolvedTranslateOptions,
   deps: AuthDependencies = {},
 ) {
+  const credentialCache = new Map<string, ResolvedCredential>()
+  const oauthRefreshInflight = new Map<string, Promise<OAuthInfo>>()
   const runtime: AuthRuntime = {
     fetchImpl: deps.fetchImpl ?? fetch,
     sleep: deps.sleep ?? ((ms: number) => sleep(ms)),
@@ -84,13 +82,14 @@ export function createCredentialResolver(
     if (!info) return undefined
     if (info.expires >= now() + 60_000) return info
 
-    const existing = oauthRefreshInflight.get(providerID)
+    const inflightKey = `${providerID}:${info.refresh}`
+    const existing = oauthRefreshInflight.get(inflightKey)
     if (existing) return existing
 
     const refreshPromise = refreshProviderOAuth(providerID, info, client, runtime).finally(() => {
-      oauthRefreshInflight.delete(providerID)
+      oauthRefreshInflight.delete(inflightKey)
     })
-    oauthRefreshInflight.set(providerID, refreshPromise)
+    oauthRefreshInflight.set(inflightKey, refreshPromise)
     return refreshPromise
   }
 

package/src/question-tool.ts

@@ -76,35 +76,47 @@ export function isQuestionArgs(value: unknown): value is QuestionArgs {
   return true
 }
 
-async function assignTranslation(
-  container: Record<string, string>,
-  key: string,
-  translate: (text: string) => Promise<string>,
-): Promise<void> {
-  const original = container[key]
-  if (!original || original.length === 0) return
-  const translated = await translate(original)
-  container[key] = unwrapEchoedTextEnvelope(translated)
+async function translatedDisplayText(text: string, translate: (text: string) => Promise<string>): Promise<string> {
+  if (text.length === 0) return text
+  return unwrapEchoedTextEnvelope(await translate(text))
 }
 
-// Translate every display-facing string in `args` in parallel. The caller can
-// snapshot the translated form afterward with `snapshotQuestions`.
+// Translate every display-facing string in parallel, then commit the translated
+// clone only after every translation succeeds.
 export async function translateQuestionArgs(
   args: QuestionArgs,
   translate: (text: string) => Promise<string>,
 ): Promise<void> {
+  const translatedQuestions = snapshotQuestions(args)
   const jobs: Promise<void>[] = []
 
-  for (const q of args.questions) {
-    jobs.push(assignTranslation(q as unknown as Record<string, string>, "question", translate))
-    jobs.push(assignTranslation(q as unknown as Record<string, string>, "header", translate))
+  for (const q of translatedQuestions) {
+    jobs.push(
+      (async () => {
+        q.question = await translatedDisplayText(q.question, translate)
+      })(),
+    )
+    jobs.push(
+      (async () => {
+        q.header = await translatedDisplayText(q.header, translate)
+      })(),
+    )
     for (const option of q.options) {
-      jobs.push(assignTranslation(option as unknown as Record<string, string>, "label", translate))
-      jobs.push(assignTranslation(option as unknown as Record<string, string>, "description", translate))
+      jobs.push(
+        (async () => {
+          option.label = await translatedDisplayText(option.label, translate)
+        })(),
+      )
+      jobs.push(
+        (async () => {
+          option.description = await translatedDisplayText(option.description, translate)
+        })(),
+      )
     }
   }
 
   await Promise.all(jobs)
+  args.questions.splice(0, args.questions.length, ...translatedQuestions)
 }
 
 // Given a user-selected label, find the matching translated option and return

package/src/translator/index.ts

@@ -1,5 +1,5 @@
 import { setTimeout as sleep } from "node:timers/promises"
-import { generateText } from "ai"
+import { generateText, type LanguageModel } from "ai"
 import { createCredentialResolver } from "../auth"
 import {
   buildAuthUnavailableError,
@@ -73,20 +73,20 @@ export function createTranslator(
     const credentials = await credentialResolver.resolve(options.translatorModel)
     const factory = await loadFactory(providerID)
     const provider = instantiateProvider(factory, providerID, credentials)
-    const model = instantiateModel(provider, modelID)
+    const model = instantiateModel(provider, modelID) as LanguageModel
 
     const rawTranslated = await withRetry(async () => {
       try {
-        const result = (await withTimeout(
+        const result = await withTimeout(
           generateTextImpl({
-            model: model as never,
+            model,
             system: buildSystemPrompt(input),
             ...(supportsTemperature(providerID, modelID) ? { temperature: 0 } : {}),
             prompt: buildUserPrompt(input),
-          }) as Promise<{ text: string }>,
+          }),
           timeoutMs,
           "Translator generateText",
-        )) as { text: string }
+        )
         return result.text
       } catch (error) {
         if (isAuthMessage(error)) throw error