opencode-translate 1.0.0 → 1.0.2

package/README.md

@@ -1,5 +1,7 @@
 # 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
@@ -32,8 +34,9 @@ Add to `~/.config/opencode/opencode.jsonc`:
 {
   "plugin": [
     ["opencode-translate", {
-      "model": "anthropic/claude-haiku-4-5", // model to use for translation
-      "lang": "Korean"                        // language you speak
+      "model": "openai/gpt-5.4-mini", // model to use for translation
+      "variant": "minimal",            // optional model variant / thinking effort
+      "lang": "Korean"                // language you speak
     }]
   ]
 }
@@ -54,6 +57,7 @@ All subsequent messages in the same session are translated automatically — no
 | Option | Type | Default | Description |
 | --- | --- | --- | --- |
 | `model` | string | required | Translator model in `provider/model-id` form |
+| `variant` | string | optional | Translator model variant / thinking effort (for example, `"minimal"`, `"high"`, or `"max"`) |
 | `lang` | string | required | Language you speak (e.g. `"Korean"`, `"Japanese"`) |
 | `trigger` | string[] | `["$en"]` | Keywords that activate translation |
 | `verbose` | boolean | `false` | Print translation logs |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-translate",
-  "version": "1.0.0",
+  "version": "1.0.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/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/constants/options.ts

@@ -21,6 +21,7 @@ export function resolveOptions(options: Record<string, unknown>): ResolvedTransl
       `[${PLUGIN_NAME}:INVALID_OPTIONS] options.lang is required. Set it to the user's language, e.g. "Korean" or "Japanese".`,
     )
   }
+  const variant = typeof options.variant === "string" ? options.variant.trim() : ""
 
   const rawTrigger = Array.isArray(options.trigger)
     ? options.trigger
@@ -31,6 +32,7 @@ export function resolveOptions(options: Record<string, unknown>): ResolvedTransl
 
   return {
     model,
+    ...(variant ? { variant } : {}),
     trigger: trigger.length > 0 ? trigger : [...DEFAULT_TRIGGER],
     lang,
     verbose: options.verbose === true,

package/src/constants/types.ts

@@ -6,6 +6,7 @@ type ProviderSource = "env" | "config" | "custom" | "api"
 
 export interface ResolvedTranslateOptions {
   model: string
+  variant?: string
   trigger: string[]
   lang: string
   verbose: boolean
@@ -67,6 +68,7 @@ export interface ProviderModelInfo {
   }
   headers?: Record<string, string>
   options?: Record<string, unknown>
+  variants?: Record<string, Record<string, unknown>>
   capabilities?: {
     temperature?: boolean
   }

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
 }

package/src/translator/index.ts

@@ -13,6 +13,7 @@ import { buildSystemPrompt, buildUserPrompt, unwrapEchoedTextEnvelope } from "..
 import { __resetSyntheticPartIDForTest } from "./part-id"
 import {
   __resetProviderFactoryCacheForTest,
+  buildVariantProviderOptions,
   instantiateModel,
   instantiateProvider,
   loadFactory,
@@ -73,6 +74,7 @@ export function createTranslator(
     const { providerID, modelID } = parseTranslatorModel(options.model)
     const credentials = await credentialResolver.resolve(options.model)
     const modelInfo = resolveModelInfo(credentials.provider, modelID)
+    const variantProviderOptions = buildVariantProviderOptions(providerID, modelID, modelInfo, options.variant)
     const factory = await loadFactory(providerID, modelInfo)
     const provider = instantiateProvider(factory, providerID, credentials, modelInfo)
     const providerOptions = { ...(credentials.provider?.options ?? {}), ...(modelInfo.options ?? {}) }
@@ -85,6 +87,7 @@ export function createTranslator(
             model,
             system: buildSystemPrompt(input),
             ...(supportsTemperature(providerID, modelID, modelInfo) ? { temperature: 0 } : {}),
+            ...(variantProviderOptions ? { providerOptions: variantProviderOptions } : {}),
             prompt: buildUserPrompt(input),
           }),
           timeoutMs,

package/src/translator/provider.ts

@@ -1,4 +1,4 @@
-import type { AuthInfo, FetchLike, ProviderInfo, ProviderModelInfo } from "../constants"
+import { type AuthInfo, type FetchLike, PLUGIN_NAME, type ProviderInfo, type ProviderModelInfo } from "../constants"
 
 const providerFactoryCache = new Map<string, unknown>()
 
@@ -23,6 +23,26 @@ const CREATE_EXPORT_FALLBACK: Record<string, string[]> = {
   "@openrouter/ai-sdk-provider": ["createOpenRouter", "openrouter"],
 }
 
+const PROVIDER_OPTIONS_KEY: Record<string, string> = {
+  "@ai-sdk/amazon-bedrock": "bedrock",
+  "@ai-sdk/amazon-bedrock/mantle": "openai",
+  "@ai-sdk/anthropic": "anthropic",
+  "@ai-sdk/azure": "openai",
+  "@ai-sdk/gateway": "gateway",
+  "@ai-sdk/github-copilot": "openai",
+  "@ai-sdk/google": "google",
+  "@ai-sdk/google-vertex": "vertex",
+  "@ai-sdk/google-vertex/anthropic": "anthropic",
+  "@ai-sdk/openai": "openai",
+  "@openrouter/ai-sdk-provider": "openrouter",
+  "ai-gateway-provider": "openaiCompatible",
+}
+
+type JsonValue = null | string | number | boolean | JsonObject | JsonArray
+type JsonObject = { [key: string]: JsonValue | undefined }
+type JsonArray = JsonValue[]
+type VariantProviderOptions = Record<string, JsonObject>
+
 interface ProviderCredentials {
   provider?: ProviderInfo
   authInfo?: AuthInfo
@@ -73,6 +93,40 @@ export function resolveModelInfo(provider: ProviderInfo | undefined, modelID: st
   return provider?.models?.[modelID] ?? { id: modelID, api: { id: modelID } }
 }
 
+function sdkProviderOptionsKey(providerID: string, model?: ProviderModelInfo): string {
+  const packageName = model?.api?.npm
+  if (packageName && PROVIDER_OPTIONS_KEY[packageName]) return PROVIDER_OPTIONS_KEY[packageName]
+  if (packageName === "@ai-sdk/openai-compatible" || packageName === "@ai-sdk/openai") return providerID.split(".")[0]
+  return providerID
+}
+
+function invalidVariantError(providerID: string, modelID: string, model: ProviderModelInfo, variant: string) {
+  const variants = Object.keys(model.variants ?? {}).sort()
+  const modelName = `${providerID}/${modelID}`
+  if (variants.length === 0) {
+    return new Error(
+      `[${PLUGIN_NAME}:INVALID_VARIANT] options.variant "${variant}" is not available for "${modelName}". This model has no configurable variants.`,
+    )
+  }
+  return new Error(
+    `[${PLUGIN_NAME}:INVALID_VARIANT] options.variant "${variant}" is not available for "${modelName}". Available variants: ${variants.join(", ")}.`,
+  )
+}
+
+export function buildVariantProviderOptions(
+  providerID: string,
+  modelID: string,
+  model: ProviderModelInfo,
+  variant?: string,
+): VariantProviderOptions | undefined {
+  if (!variant) return undefined
+  const selected = model.variants?.[variant]
+  if (!selected) throw invalidVariantError(providerID, modelID, model, variant)
+  const providerOptions = selected as JsonObject
+  if (model.api?.npm === "@ai-sdk/azure") return { openai: providerOptions, azure: providerOptions }
+  return { [sdkProviderOptionsKey(providerID, model)]: providerOptions }
+}
+
 function headerRecord(value: unknown): Record<string, string> {
   if (!value || typeof value !== "object" || Array.isArray(value)) return {}
   return Object.fromEntries(