opencode-translate 1.0.1 → 1.0.3

package/README.md

@@ -35,7 +35,9 @@ Add to `~/.config/opencode/opencode.jsonc`:
   "plugin": [
     ["opencode-translate", {
       "model": "openai/gpt-5.4-mini", // model to use for translation
-      "lang": "Korean"                        // language you speak
+      "variant": "minimal",            // optional model variant / thinking effort
+      "lang": "Korean",               // language you speak
+      "assistantTranslation": "final-message" // or "each-part"
     }]
   ]
 }
@@ -56,6 +58,8 @@ 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 |
+| `assistantTranslation` | `"each-part" \| "final-message"` | `"final-message"` | Translate only the final assistant text part after the loop becomes idle, or opt into translating each text part as it completes |
 | `verbose` | boolean | `false` | Print translation logs |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-translate",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "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/event.ts

@@ -0,0 +1,132 @@
+import type { Hooks } from "@opencode-ai/plugin"
+import { isTextPart, LLM_LANGUAGE, type MessageWithPartsLike, type TextPartLike, unwrapData } from "../constants"
+import { composeTranslatedAssistantText, composeTranslationFailureText, extractEnglishHistoryText } from "../formatting"
+import { getDisplayLanguageLabel } from "../labels"
+import { logError } from "./logging"
+import { resolveSessionState } from "./state"
+import type { HookContext } from "./types"
+
+type EventHook = NonNullable<Hooks["event"]>
+
+const inFlightFinalTranslations = new Set<string>()
+
+function latestAssistantMessage(messages: MessageWithPartsLike[]): MessageWithPartsLike | undefined {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index]
+    if (message.info.role === "assistant" && message.info.summary !== true) return message
+  }
+  return undefined
+}
+
+function lastNonEmptyTextPart(message: MessageWithPartsLike): (TextPartLike & { text: string }) | undefined {
+  for (let index = message.parts.length - 1; index >= 0; index -= 1) {
+    const part = message.parts[index]
+    if (isTextPart(part) && part.text.trim().length > 0) return part
+  }
+  return undefined
+}
+
+async function composeFinalAssistantText(
+  ctx: HookContext,
+  text: string,
+  targetLanguage: string,
+  label: string,
+): Promise<string> {
+  try {
+    const translated = await ctx.translator.translateText({
+      text,
+      sourceLanguage: LLM_LANGUAGE,
+      targetLanguage,
+      direction: "outbound",
+    })
+    return composeTranslatedAssistantText(text, label, translated)
+  } catch (error) {
+    await logError(ctx.client, error)
+    return composeTranslationFailureText(text)
+  }
+}
+
+async function patchPartViaServer(ctx: HookContext, sessionID: string, part: TextPartLike) {
+  if (!ctx.serverUrl) throw new Error("client.part.update is required for final-message assistant translation")
+
+  const url = new URL(
+    `/session/${encodeURIComponent(sessionID)}/message/${encodeURIComponent(part.messageID)}/part/${encodeURIComponent(part.id)}`,
+    ctx.serverUrl,
+  )
+  if (ctx.directory) url.searchParams.set("directory", ctx.directory)
+
+  const response = await fetch(url, {
+    method: "PATCH",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(part),
+  })
+  if (!response.ok) {
+    throw new Error(`Failed to update final assistant translation part: HTTP ${response.status}`)
+  }
+}
+
+async function updatePart(ctx: HookContext, sessionID: string, part: TextPartLike) {
+  const partUpdater = ctx.client.part?.update
+  if (partUpdater) {
+    const input = {
+      sessionID,
+      messageID: part.messageID,
+      partID: part.id,
+      ...(ctx.directory ? { directory: ctx.directory } : {}),
+      part,
+    }
+    await partUpdater.call(ctx.client.part, input, { throwOnError: true })
+    return
+  }
+
+  await patchPartViaServer(ctx, sessionID, part)
+}
+
+async function translateFinalAssistantMessage(ctx: HookContext, sessionID: string) {
+  if (inFlightFinalTranslations.has(sessionID)) return
+  inFlightFinalTranslations.add(sessionID)
+  try {
+    const resolved = await resolveSessionState(ctx.client, ctx.directory, sessionID)
+    const activeState = resolved.state
+    if (!activeState) return
+    if (activeState.translate_user_lang === LLM_LANGUAGE) return
+
+    const messages = unwrapData(
+      await ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { ...(ctx.directory ? { directory: ctx.directory } : {}), limit: 20 },
+        throwOnError: true,
+      }),
+    )
+    const message = latestAssistantMessage(messages)
+    if (!message) return
+
+    const part = lastNonEmptyTextPart(message)
+    if (!part) return
+
+    const label = getDisplayLanguageLabel(activeState.translate_user_lang)
+    if (extractEnglishHistoryText(part.text, { nonce: activeState.translate_nonce, label }) !== part.text) return
+
+    const updatedPart = {
+      ...part,
+      text: await composeFinalAssistantText(ctx, part.text, activeState.translate_user_lang, label),
+    }
+
+    await updatePart(ctx, sessionID, updatedPart)
+  } finally {
+    inFlightFinalTranslations.delete(sessionID)
+  }
+}
+
+export function createEventHook(ctx: HookContext): EventHook {
+  return async (input) => {
+    if (ctx.options.assistantTranslation !== "final-message") return
+    if (input.event.type !== "session.idle") return
+
+    try {
+      await translateFinalAssistantMessage(ctx, input.event.properties.sessionID)
+    } catch (error) {
+      await logError(ctx.client, error)
+    }
+  }
+}

package/src/activation/index.ts

@@ -2,6 +2,7 @@ import type { Hooks, PluginInput, PluginOptions } from "@opencode-ai/plugin"
 import { type PluginClientLike, resolveOptions } from "../constants"
 import { createTranslator } from "../translator"
 import { createChatMessageHook } from "./chat-message"
+import { createEventHook } from "./event"
 import { createMessagesTransformHook } from "./messages-transform"
 import { createToolExecuteAfterHook, createToolExecuteBeforeHook, resetQuestionSnapshots } from "./question-hooks"
 import { resetSessionStateCache } from "./state"
@@ -24,15 +25,19 @@ export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, de
   const hookContext: HookContext = {
     client,
     directory: ctx.directory,
+    serverUrl: ctx.serverUrl,
     options,
     translator: deps.translator ?? createTranslator(client, options),
   }
 
-  return {
+  const hooks: Hooks = {
     "chat.message": createChatMessageHook(hookContext),
     "experimental.chat.messages.transform": createMessagesTransformHook(hookContext),
     "experimental.text.complete": createTextCompleteHook(hookContext),
     "tool.execute.before": createToolExecuteBeforeHook(hookContext),
     "tool.execute.after": createToolExecuteAfterHook(hookContext),
   }
+
+  if (options.assistantTranslation === "final-message") hooks.event = createEventHook(hookContext)
+  return hooks
 }

package/src/activation/text-complete.ts

@@ -11,6 +11,8 @@ type TextCompleteHook = NonNullable<Hooks["experimental.text.complete"]>
 export function createTextCompleteHook(ctx: HookContext): TextCompleteHook {
   return async (input, output) => {
     try {
+      if (ctx.options.assistantTranslation === "final-message") return
+
       const resolved = await resolveSessionState(ctx.client, ctx.directory, input.sessionID)
       const activeState = resolved.state
       if (!activeState) return

package/src/activation/types.ts

@@ -36,6 +36,7 @@ export interface HookDependencies {
 export interface HookContext {
   client: PluginClientLike
   directory?: string
+  serverUrl?: URL
   options: ResolvedTranslateOptions
   translator: TranslatorLike
 }

package/src/constants/options.ts

@@ -1,5 +1,17 @@
 import { AUTH_ENV_FALLBACK, DEFAULT_TRIGGER, PLUGIN_NAME } from "./plugin"
-import type { ProviderInfo, ResolvedTranslateOptions } from "./types"
+import type { AssistantTranslationMode, ProviderInfo, ResolvedTranslateOptions } from "./types"
+
+const ASSISTANT_TRANSLATION_MODES = new Set<AssistantTranslationMode>(["each-part", "final-message"])
+
+function resolveAssistantTranslationMode(value: unknown): AssistantTranslationMode {
+  if (value === undefined) return "final-message"
+  if (typeof value === "string" && ASSISTANT_TRANSLATION_MODES.has(value as AssistantTranslationMode)) {
+    return value as AssistantTranslationMode
+  }
+  throw new Error(
+    `[${PLUGIN_NAME}:INVALID_OPTIONS] options.assistantTranslation must be "each-part" or "final-message".`,
+  )
+}
 
 export function resolveOptions(options: Record<string, unknown>): ResolvedTranslateOptions {
   const model = typeof options.model === "string" ? options.model.trim() : ""
@@ -21,6 +33,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,9 +44,11 @@ export function resolveOptions(options: Record<string, unknown>): ResolvedTransl
 
   return {
     model,
+    ...(variant ? { variant } : {}),
     trigger: trigger.length > 0 ? trigger : [...DEFAULT_TRIGGER],
     lang,
     verbose: options.verbose === true,
+    assistantTranslation: resolveAssistantTranslationMode(options.assistantTranslation),
   }
 }
 

package/src/constants/types.ts

@@ -6,11 +6,15 @@ type ProviderSource = "env" | "config" | "custom" | "api"
 
 export interface ResolvedTranslateOptions {
   model: string
+  variant?: string
   trigger: string[]
   lang: string
   verbose: boolean
+  assistantTranslation: AssistantTranslationMode
 }
 
+export type AssistantTranslationMode = "each-part" | "final-message"
+
 export interface TranslateState {
   translate_enabled: true
   translate_user_lang: string
@@ -40,6 +44,7 @@ interface MessageLike {
   id: string
   sessionID: string
   role: string
+  summary?: boolean
 }
 
 export interface TextPartLike {
@@ -67,6 +72,7 @@ export interface ProviderModelInfo {
   }
   headers?: Record<string, string>
   options?: Record<string, unknown>
+  variants?: Record<string, Record<string, unknown>>
   capabilities?: {
     temperature?: boolean
   }
@@ -154,4 +160,17 @@ export interface PluginClientLike {
       }
     }): Promise<unknown>
   }
+  part?: {
+    update(
+      input: {
+        sessionID: string
+        messageID: string
+        partID: string
+        directory?: string
+        workspace?: string
+        part?: TextPartLike
+      },
+      options?: { throwOnError?: boolean },
+    ): Promise<TextPartLike | SDKResponseLike<TextPartLike>>
+  }
 }

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(