opencode-translate 1.0.6 → 2.0.0

package/src/question-tool.ts

@@ -1,234 +0,0 @@
-// Translation layer for OpenCode's built-in `question` tool.
-//
-// Flow:
-//   1. Agent (main LLM, English-only) invokes the `question` tool with an
-//      `args.questions[]` payload in English.
-//   2. `tool.execute.before` hook translates all question text, headers, and
-//      option labels + descriptions into the configured `lang` so the question
-//      prompt renders in the user's language.
-//   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. 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.
-
-import { unwrapEchoedTextEnvelope } from "./prompts"
-
-type TextRecord = { question: string; header: string; options: OptionRecord[]; multiple?: boolean; custom?: boolean }
-type OptionRecord = { label: string; description: string }
-
-export interface QuestionArgs {
-  questions: TextRecord[]
-}
-
-export interface QuestionSnapshot {
-  original: TextRecord[]
-  translated: TextRecord[]
-  userLanguage: string
-}
-
-export interface QuestionToolOutput {
-  title?: string
-  output?: string
-  metadata?: { answers?: readonly (readonly string[])[] } | Record<string, unknown>
-}
-
-export interface RestoreQuestionOutputOptions {
-  translateCustomAnswers?: (texts: readonly string[]) => Promise<readonly string[]>
-  onTranslationError?: (error: unknown) => Promise<void> | void
-}
-
-interface TranslatableField {
-  text: string
-  set(value: string): void
-}
-
-interface CustomAnswerSlot {
-  questionIndex: number
-  answerIndex: number
-  text: string
-}
-
-function cloneQuestion(q: TextRecord): TextRecord {
-  return {
-    question: q.question,
-    header: q.header,
-    options: q.options.map((option) => ({ label: option.label, description: option.description })),
-    ...(q.multiple !== undefined ? { multiple: q.multiple } : {}),
-    ...(q.custom !== undefined ? { custom: q.custom } : {}),
-  }
-}
-
-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
-  if (!Array.isArray(questions)) return false
-  for (const q of questions) {
-    if (!q || typeof q !== "object") return false
-    const record = q as Record<string, unknown>
-    if (typeof record.question !== "string") return false
-    if (typeof record.header !== "string") return false
-    if (!Array.isArray(record.options)) return false
-    for (const opt of record.options) {
-      if (!opt || typeof opt !== "object") return false
-      const optRecord = opt as Record<string, unknown>
-      if (typeof optRecord.label !== "string") return false
-      if (typeof optRecord.description !== "string") return false
-    }
-  }
-  return true
-}
-
-// Translate every display-facing string in one batch, then commit the
-// translated clone only after the batch succeeds.
-export async function translateQuestionArgs(
-  args: QuestionArgs,
-  translate: (texts: readonly string[]) => Promise<readonly string[]>,
-): Promise<void> {
-  const translatedQuestions = snapshotQuestions(args)
-  const fields: TranslatableField[] = []
-
-  function addField(text: string, set: (value: string) => void) {
-    if (text.length === 0) return
-    fields.push({ text, set })
-  }
-
-  for (const q of translatedQuestions) {
-    addField(q.question, (value) => {
-      q.question = value
-    })
-    addField(q.header, (value) => {
-      q.header = value
-    })
-    for (const option of q.options) {
-      addField(option.label, (value) => {
-        option.label = value
-      })
-      addField(option.description, (value) => {
-        option.description = value
-      })
-    }
-  }
-
-  if (fields.length === 0) return
-
-  const translated = await translate(fields.map((field) => field.text))
-  if (translated.length !== fields.length) {
-    throw new Error(`Question translator returned ${translated.length} translations for ${fields.length} fields`)
-  }
-  for (const [index, field] of fields.entries()) {
-    field.set(unwrapEchoedTextEnvelope(translated[index]))
-  }
-  args.questions.splice(0, args.questions.length, ...translatedQuestions)
-}
-
-function restoreOptionLabel(
-  selectedLabel: string,
-  translatedOptions: readonly OptionRecord[],
-  originalOptions: readonly OptionRecord[],
-): string | undefined {
-  const idx = translatedOptions.findIndex((option) => option.label === selectedLabel)
-  if (idx < 0) return undefined
-  return originalOptions[idx]?.label ?? selectedLabel
-}
-
-async function restoreQuestionAnswers(
-  original: readonly TextRecord[],
-  translated: readonly TextRecord[],
-  answers: readonly (readonly string[])[],
-  options: RestoreQuestionOutputOptions = {},
-): Promise<string[][]> {
-  const translateCustomAnswers = options.translateCustomAnswers
-  const customSlots: CustomAnswerSlot[] = []
-  const restored = original.map((q, questionIndex) => {
-    const selected = answers[questionIndex] ?? []
-    const translatedOptions = translated[questionIndex]?.options ?? []
-    const originalOptions = q.options
-
-    return selected.map((label, answerIndex) => {
-      const restoredLabel = restoreOptionLabel(label, translatedOptions, originalOptions)
-      if (restoredLabel !== undefined) return restoredLabel
-      if (!translateCustomAnswers || label.trim().length === 0) return label
-
-      customSlots.push({ questionIndex, answerIndex, text: label })
-      return label
-    })
-  })
-
-  if (!translateCustomAnswers || customSlots.length === 0) return restored
-
-  try {
-    const translatedCustomAnswers = await translateCustomAnswers(customSlots.map((slot) => slot.text))
-    if (translatedCustomAnswers.length !== customSlots.length) {
-      throw new Error(
-        `Question custom-answer translator returned ${translatedCustomAnswers.length} translations for ${customSlots.length} answers`,
-      )
-    }
-    for (const [index, slot] of customSlots.entries()) {
-      restored[slot.questionIndex][slot.answerIndex] = unwrapEchoedTextEnvelope(translatedCustomAnswers[index])
-    }
-  } catch (error) {
-    await options.onTranslationError?.(error)
-  }
-
-  return restored
-}
-
-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,
-  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 : []
-  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

@@ -1,172 +0,0 @@
-import { setTimeout as sleep } from "node:timers/promises"
-import { generateText, type LanguageModel } from "ai"
-import { createCredentialResolver } from "../auth"
-import {
-  buildAuthUnavailableError,
-  PLUGIN_NAME,
-  type PluginClientLike,
-  type ProviderInfo,
-  parseTranslatorModel,
-  type ResolvedTranslateOptions,
-} from "../constants"
-import {
-  buildBatchSystemPrompt,
-  buildBatchUserPrompt,
-  buildSystemPrompt,
-  buildUserPrompt,
-  parseBatchSegments,
-  unwrapEchoedTextEnvelope,
-} from "../prompts"
-import { __resetSyntheticPartIDForTest } from "./part-id"
-import {
-  __resetProviderFactoryCacheForTest,
-  buildVariantProviderOptions,
-  instantiateModel,
-  instantiateProvider,
-  loadFactory,
-  resolveModelInfo,
-  supportsTemperature,
-} from "./provider"
-import { withRetry } from "./retry"
-import type { TranslateTextInput, TranslateTextsInput, TranslatorDependencies } from "./types"
-
-const DEFAULT_TRANSLATE_TIMEOUT_MS = 180_000
-
-function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs)
-    promise.then(
-      (value) => {
-        clearTimeout(timer)
-        resolve(value)
-      },
-      (error) => {
-        clearTimeout(timer)
-        reject(error)
-      },
-    )
-  })
-}
-
-function isAuthMessage(error: unknown): boolean {
-  if (!(error instanceof Error)) return false
-  return error.message.includes(":AUTH_UNAVAILABLE]") || error.message.includes(":OAUTH_REFRESH_FAILED]")
-}
-
-function modelProviderHint(providerID: string, provider?: ProviderInfo): Error {
-  return buildAuthUnavailableError(providerID, provider?.env[0] || "the provider's API key env var")
-}
-
-export function __resetTranslatorCachesForTest() {
-  __resetProviderFactoryCacheForTest()
-  __resetSyntheticPartIDForTest()
-}
-
-export function createTranslator(
-  client: PluginClientLike,
-  options: ResolvedTranslateOptions,
-  deps: TranslatorDependencies = {},
-) {
-  const sleepImpl = deps.sleep ?? ((ms: number) => sleep(ms))
-  const now = deps.now ?? (() => Date.now())
-  const generateTextImpl = deps.generateTextImpl ?? generateText
-  const credentialResolver = deps.credentialResolver ?? createCredentialResolver(client)
-  const timeoutMs = deps.timeoutMs ?? DEFAULT_TRANSLATE_TIMEOUT_MS
-
-  async function generateFromPrompts(system: string, prompt: string): Promise<string> {
-    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 ?? {}) }
-    const model = instantiateModel(provider, modelID, providerID, modelInfo, providerOptions) as LanguageModel
-
-    return withRetry(async () => {
-      try {
-        const result = await withTimeout(
-          generateTextImpl({
-            model,
-            system,
-            ...(supportsTemperature(providerID, modelID, modelInfo) ? { temperature: 0 } : {}),
-            ...(variantProviderOptions ? { providerOptions: variantProviderOptions } : {}),
-            prompt,
-          }),
-          timeoutMs,
-          "Translator generateText",
-        )
-        return result.text
-      } catch (error) {
-        if (isAuthMessage(error)) throw error
-        if (credentials.mode === "default" && credentialResolver.isMissingCredentialError(error)) {
-          throw modelProviderHint(providerID, credentials.provider)
-        }
-        throw error
-      }
-    }, sleepImpl)
-  }
-
-  async function translateText(input: TranslateTextInput): Promise<string> {
-    if (!input.text) return input.text
-    if (input.sourceLanguage === input.targetLanguage) return input.text
-
-    const startedAt = now()
-    const rawTranslated = await generateFromPrompts(buildSystemPrompt(input), buildUserPrompt(input))
-    const translated = unwrapEchoedTextEnvelope(rawTranslated)
-
-    if (options.verbose) {
-      await client.app.log({
-        body: {
-          service: PLUGIN_NAME,
-          level: "info",
-          message: "translated",
-          extra: {
-            direction: input.direction,
-            chars_in: input.text.length,
-            chars_out: translated.length,
-            ms: now() - startedAt,
-            cached: false,
-            model: options.model,
-          },
-        },
-      })
-    }
-
-    return translated
-  }
-
-  async function translateTexts(input: TranslateTextsInput): Promise<string[]> {
-    if (input.texts.length === 0) return []
-    if (input.sourceLanguage === input.targetLanguage) return [...input.texts]
-
-    const startedAt = now()
-    const rawTranslated = await generateFromPrompts(buildBatchSystemPrompt(input), buildBatchUserPrompt(input))
-    const translated = parseBatchSegments(rawTranslated, input.texts.length).map(unwrapEchoedTextEnvelope)
-
-    if (options.verbose) {
-      await client.app.log({
-        body: {
-          service: PLUGIN_NAME,
-          level: "info",
-          message: "translated",
-          extra: {
-            direction: input.direction,
-            chars_in: input.texts.reduce((total, text) => total + text.length, 0),
-            chars_out: translated.reduce((total, text) => total + text.length, 0),
-            segments: input.texts.length,
-            ms: now() - startedAt,
-            cached: false,
-            model: options.model,
-          },
-        },
-      })
-    }
-
-    return translated
-  }
-
-  return { translateText, translateTexts }
-}
-
-export { __resetSyntheticPartIDForTest, createSyntheticPartID, hashText } from "./part-id"

package/src/translator/part-id.ts

@@ -1,43 +0,0 @@
-import { createHash, randomBytes } from "node:crypto"
-
-const PART_ID_LENGTH = 26
-const PART_ID_PREFIX = "prt"
-const BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-
-let partLastTimestamp = 0
-let partCounter = 0
-
-export function __resetSyntheticPartIDForTest() {
-  partLastTimestamp = 0
-  partCounter = 0
-}
-
-function randomBase62(length: number): string {
-  const bytes = randomBytes(length)
-  let result = ""
-  for (let index = 0; index < length; index += 1) {
-    result += BASE62_CHARS[bytes[index] % BASE62_CHARS.length]
-  }
-  return result
-}
-
-export function hashText(text: string): string {
-  return createHash("sha256").update(text, "utf8").digest("hex").slice(0, 16)
-}
-
-export function createSyntheticPartID(): string {
-  const currentTimestamp = Date.now()
-  if (currentTimestamp !== partLastTimestamp) {
-    partLastTimestamp = currentTimestamp
-    partCounter = 0
-  }
-  partCounter += 1
-
-  const encoded = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(partCounter)
-  const timeBytes = Buffer.alloc(6)
-  for (let index = 0; index < 6; index += 1) {
-    timeBytes[index] = Number((encoded >> BigInt(40 - 8 * index)) & BigInt(0xff))
-  }
-
-  return `${PART_ID_PREFIX}_${timeBytes.toString("hex")}${randomBase62(PART_ID_LENGTH - 12)}`
-}