opencode-translate 1.0.1 → 1.0.2

package/README.md

@@ -35,7 +35,8 @@ 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
     }]
   ]
 }
@@ -56,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.1",
+  "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/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/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(