opencode-translate 1.0.2 → 1.0.3

package/README.md

@@ -36,7 +36,8 @@ Add to `~/.config/opencode/opencode.jsonc`:
     ["opencode-translate", {
       "model": "openai/gpt-5.4-mini", // model to use for translation
       "variant": "minimal",            // optional model variant / thinking effort
-      "lang": "Korean"                // language you speak
+      "lang": "Korean",               // language you speak
+      "assistantTranslation": "final-message" // or "each-part"
     }]
   ]
 }
@@ -60,4 +61,5 @@ All subsequent messages in the same session are translated automatically — no
 | `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.2",
+  "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() : ""
@@ -36,6 +48,7 @@ export function resolveOptions(options: Record<string, unknown>): ResolvedTransl
     trigger: trigger.length > 0 ? trigger : [...DEFAULT_TRIGGER],
     lang,
     verbose: options.verbose === true,
+    assistantTranslation: resolveAssistantTranslationMode(options.assistantTranslation),
   }
 }
 

package/src/constants/types.ts

@@ -10,8 +10,11 @@ export interface ResolvedTranslateOptions {
   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
@@ -41,6 +44,7 @@ interface MessageLike {
   id: string
   sessionID: string
   role: string
+  summary?: boolean
 }
 
 export interface TextPartLike {
@@ -156,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>>
+  }
 }