opencode-translate 0.2.1 → 0.2.3

package/README.md

@@ -44,7 +44,7 @@ Hooks never throw. If the translator fails (network error, auth failure, provide
 3. Falls back to sending the original (untranslated) user text to the model.
 4. On activation-turn failure, it also rolls back activation so the next turn retries cleanly.
 
-A stalled provider request is additionally bounded by a 60s hard timeout per translation call, so a hung upstream cannot block the OpenCode session.
+A stalled provider request is additionally bounded by a 180s hard timeout per translation call, so a hung upstream cannot block the OpenCode session.
 
 ## Install
 
@@ -101,6 +101,12 @@ Using this plugin means text goes to two model providers per turn:
 
 If you need strict single-provider or self-hosted-only behavior, do not enable this plugin.
 
+## Authentication
+
+Translator requests are made through the AI SDK directly, but provider setup mirrors OpenCode's resolved provider metadata from `client.provider.list()`: provider/model package metadata, configured provider options, model headers, resolved env/API keys, and plugin-auth-loader options that OpenCode exposes there.
+
+For OAuth records that OpenCode does not expose through the plugin SDK, the plugin reads OpenCode auth content/files and adapts the request only where direct AI SDK calls need it.
+
 ## Anthropic OAuth Support
 
 If `translatorModel` uses Anthropic and OpenCode auth is backed by Anthropic OAuth (Claude Pro/Max), the plugin reuses those OAuth credentials for translation requests.
@@ -121,7 +127,7 @@ Tradeoffs:
 - OpenCode upstream removed Anthropic OAuth support for legal / policy reasons. Installing this plugin reintroduces an equivalent code path in your environment.
 - Translator requests contribute to your Claude Pro/Max rate limit alongside OpenCode's main chat.
 
-If you prefer a plain API key, set `ANTHROPIC_API_KEY` in the environment or pass `apiKey` in plugin options. The plugin prefers explicit `apiKey`, then `ANTHROPIC_API_KEY`, then OAuth.
+If you prefer a plain API key, set `ANTHROPIC_API_KEY`, use `opencode auth login anthropic`, or pass `apiKey` in plugin options.
 
 ## OpenAI OAuth Support
 
@@ -129,7 +135,7 @@ If `translatorModel` uses OpenAI and OpenCode auth is backed by the ChatGPT/Code
 
 For OAuth-backed OpenAI requests, the plugin routes the OpenAI AI SDK request to `https://chatgpt.com/backend-api/codex/responses`, adds the required Codex beta/originator headers, normalizes the request body to Codex's expected typed `input` shape, and converts Codex SSE responses back to JSON for translation calls. This supports models such as `openai/gpt-5.5` when your ChatGPT plan has access.
 
-If you prefer a plain API key, set `OPENAI_API_KEY` in the environment or pass `apiKey` in plugin options. The plugin prefers explicit `apiKey`, then `OPENAI_API_KEY`, then OAuth.
+If you prefer a plain API key, set `OPENAI_API_KEY`, use `opencode auth login openai`, or pass `apiKey` in plugin options.
 
 ## Manual Smoke Test
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-translate",
-  "version": "0.2.1",
+  "version": "0.2.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/index.ts

@@ -19,7 +19,7 @@ export function __resetActivationCacheForTest() {
 export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, deps: HookDependencies = {}): Hooks {
   if (process.env.OPENCODE_TRANSLATE_DISABLE === "1") return {}
 
-  const client = ctx.client as unknown as PluginClientLike
+  const client = ctx.client as PluginClientLike
   const options = resolveOptions(rawOptions)
   const hookContext: HookContext = {
     client,

package/src/activation/question-hooks.ts

@@ -12,8 +12,19 @@ import { logError } from "./logging"
 import { resolveSessionState } from "./state"
 import { type HookContext, QUESTION_TOOL_ID } from "./types"
 
+const QUESTION_SNAPSHOT_LIMIT = 1_000
+
 const questionSnapshots = new Map<string, QuestionSnapshot>()
 
+function pruneQuestionSnapshots() {
+  while (questionSnapshots.size > QUESTION_SNAPSHOT_LIMIT) {
+    for (const callID of questionSnapshots.keys()) {
+      questionSnapshots.delete(callID)
+      break
+    }
+  }
+}
+
 export function resetQuestionSnapshots() {
   questionSnapshots.clear()
 }
@@ -26,8 +37,8 @@ export function createToolExecuteBeforeHook(ctx: HookContext): NonNullable<Hooks
       const activeState = resolved.state
       if (!activeState) return
 
-      const args = output.args as unknown
-      if (!isQuestionArgs(args)) return
+      if (!isQuestionArgs(output.args)) return
+      const args = output.args
 
       const original = snapshotQuestions(args)
       if (activeState.translate_user_lang !== LLM_LANGUAGE) {
@@ -48,6 +59,7 @@ export function createToolExecuteBeforeHook(ctx: HookContext): NonNullable<Hooks
       }
 
       questionSnapshots.set(input.callID, { original, translated: snapshotQuestions(args) })
+      pruneQuestionSnapshots()
     } catch (error) {
       await logError(ctx.client, error)
     }
@@ -64,24 +76,20 @@ export function createToolExecuteAfterHook(ctx: HookContext): NonNullable<Hooks[
 
       const resolved = await resolveSessionState(ctx.client, ctx.directory, input.sessionID)
       const activeState = resolved.state
-      const translateCustomAnswer =
-        activeState && activeState.translate_user_lang !== LLM_LANGUAGE
-          ? (text: string) =>
-              ctx.translator.translateText({
-                text,
-                sourceLanguage: activeState.translate_user_lang,
-                targetLanguage: LLM_LANGUAGE,
-                direction: "inbound",
-              })
-          : undefined
+      if (!activeState || activeState.translate_user_lang === LLM_LANGUAGE) {
+        await restoreQuestionOutput(output as QuestionToolOutput, snapshot)
+        return
+      }
 
       await restoreQuestionOutput(output as QuestionToolOutput, snapshot, {
-        ...(translateCustomAnswer ? { translateCustomAnswer } : {}),
+        translateCustomAnswer: (text: string) =>
+          ctx.translator.translateText({
+            text,
+            sourceLanguage: activeState.translate_user_lang,
+            targetLanguage: LLM_LANGUAGE,
+            direction: "inbound",
+          }),
         onTranslationError: async (error) => {
-          if (!activeState) {
-            await logError(ctx.client, error)
-            return
-          }
           await logError(
             ctx.client,
             buildInboundTranslationError(activeState.translate_user_lang, normalizeReason(error)),

package/src/auth/index.ts

@@ -18,12 +18,8 @@ import { refreshAnthropic, refreshOpenAI } from "./refresh"
 import { ensureOAuthInfo, normalizeProviderKey, readAuthMap } from "./store"
 import type { AuthDependencies, AuthRuntime, ResolvedCredential } from "./types"
 
-const credentialCache = new Map<string, ResolvedCredential>()
-const oauthRefreshInflight = new Map<string, Promise<OAuthInfo>>()
-
 export function __resetAuthCachesForTest() {
-  credentialCache.clear()
-  oauthRefreshInflight.clear()
+  // Resolver instances own their caches; this remains as a stable test helper.
 }
 
 function isMissingCredentialError(error: unknown): boolean {
@@ -38,6 +34,10 @@ function isMissingCredentialError(error: unknown): boolean {
   )
 }
 
+function hasOAuthRequestAdapter(providerID: string): boolean {
+  return providerID === "anthropic" || providerID === "openai" || providerID === "github-copilot"
+}
+
 async function refreshProviderOAuth(
   providerID: string,
   info: OAuthInfo,
@@ -72,6 +72,8 @@ export function createCredentialResolver(
   options: ResolvedTranslateOptions,
   deps: AuthDependencies = {},
 ) {
+  const credentialCache = new Map<string, ResolvedCredential>()
+  const oauthRefreshInflight = new Map<string, Promise<OAuthInfo>>()
   const runtime: AuthRuntime = {
     fetchImpl: deps.fetchImpl ?? fetch,
     sleep: deps.sleep ?? ((ms: number) => sleep(ms)),
@@ -84,20 +86,30 @@ export function createCredentialResolver(
     if (!info) return undefined
     if (info.expires >= now() + 60_000) return info
 
-    const existing = oauthRefreshInflight.get(providerID)
+    const inflightKey = `${providerID}:${info.refresh}`
+    const existing = oauthRefreshInflight.get(inflightKey)
     if (existing) return existing
 
     const refreshPromise = refreshProviderOAuth(providerID, info, client, runtime).finally(() => {
-      oauthRefreshInflight.delete(providerID)
+      oauthRefreshInflight.delete(inflightKey)
     })
-    oauthRefreshInflight.set(providerID, refreshPromise)
+    oauthRefreshInflight.set(inflightKey, refreshPromise)
     return refreshPromise
   }
 
-  function credentialFromOAuth(providerID: string, provider?: ProviderInfo): ResolvedCredential {
+  async function resolveAuthInfo(providerID: string) {
+    return (await readAuthMap(deps))?.[providerID]
+  }
+
+  function credentialFromOAuth(
+    providerID: string,
+    provider: ProviderInfo | undefined,
+    authInfo: OAuthInfo,
+  ): ResolvedCredential {
     return {
       providerID,
       provider,
+      authInfo,
       apiKey: "",
       fetch: buildOAuthFetch({ ...runtime, providerID, resolveOAuth, packageVersion: deps.packageVersion }),
       mode: "oauth",
@@ -110,35 +122,48 @@ export function createCredentialResolver(
     if (cached) return cached
 
     const provider = await getProvider(client, providerID)
+    const authInfo = await resolveAuthInfo(providerID)
     if (options.apiKey) {
-      const resolved = { providerID, provider, apiKey: options.apiKey, mode: "apiKey" as const }
+      const resolved = { providerID, provider, authInfo, apiKey: options.apiKey, mode: "apiKey" as const }
       credentialCache.set(providerID, resolved)
       return resolved
     }
 
     const providerKey = normalizeProviderKey(provider?.key)
-    if ((provider?.source === "api" || provider?.source === "env") && providerKey) {
-      const resolved = { providerID, provider, apiKey: providerKey, mode: "apiKey" as const }
+    if (providerKey) {
+      const resolved = { providerID, provider, authInfo, apiKey: providerKey, mode: "apiKey" as const }
       credentialCache.set(providerID, resolved)
       return resolved
     }
 
-    if (provider?.source === "custom" || provider?.key === OAUTH_DUMMY_KEY) {
+    if (authInfo?.type === "api" && authInfo.key) {
+      const resolved = { providerID, provider, authInfo, apiKey: authInfo.key, mode: "apiKey" as const }
+      credentialCache.set(providerID, resolved)
+      return resolved
+    }
+
+    if (provider?.source === "custom" || provider?.key === OAUTH_DUMMY_KEY || hasOAuthRequestAdapter(providerID)) {
       const oauthInfo = await resolveOAuth(providerID)
       if (oauthInfo) {
-        const resolved = credentialFromOAuth(providerID, provider)
+        const resolved = credentialFromOAuth(providerID, provider, oauthInfo)
         credentialCache.set(providerID, resolved)
         return resolved
       }
     }
 
+    if (authInfo?.type === "oauth" && authInfo.access && provider?.options?.apiKey === undefined) {
+      const resolved = { providerID, provider, authInfo, apiKey: authInfo.access, mode: "oauth" as const }
+      credentialCache.set(providerID, resolved)
+      return resolved
+    }
+
     if (provider?.key === undefined && (provider?.env.length ?? 0) > 1) {
-      const resolved = { providerID, provider, mode: "default" as const }
+      const resolved = { providerID, provider, authInfo, mode: "default" as const }
       credentialCache.set(providerID, resolved)
       return resolved
     }
 
-    return { providerID, provider, mode: "default" }
+    return { providerID, provider, authInfo, mode: "default" }
   }
 
   return {

package/src/auth/store.ts

@@ -1,17 +1,21 @@
-import { readFile, stat } from "node:fs/promises"
+import { readFile } from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
 import { type AuthInfo, OAUTH_DUMMY_KEY, type OAuthInfo } from "../constants"
 import type { AuthDependencies } from "./types"
 
-// Mirrors opencode's xdg-basedir auth location; see packages/opencode/src/global/index.ts.
-function authFilePath(): string {
+// Mirrors opencode's xdg-basedir data location; see packages/core/src/global.ts.
+function dataHome(): string {
   const xdgDataHome = process.env.XDG_DATA_HOME
-  if (xdgDataHome) return path.join(xdgDataHome, "opencode", "auth.json")
-  if (process.platform === "win32") {
-    return path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local"), "opencode", "auth.json")
-  }
-  return path.join(os.homedir(), ".local", "share", "opencode", "auth.json")
+  if (xdgDataHome) return xdgDataHome
+  if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support")
+  if (process.platform === "win32") return process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local")
+  return path.join(os.homedir(), ".local", "share")
+}
+
+function authFilePaths(): string[] {
+  const root = path.join(dataHome(), "opencode")
+  return [path.join(root, "auth.json"), path.join(root, "auth-v2.json")]
 }
 
 export function normalizeProviderKey(value: string | undefined): string | undefined {
@@ -23,23 +27,74 @@ export function ensureOAuthInfo(value: AuthInfo | undefined): OAuthInfo | undefi
   return value && value.type === "oauth" ? value : undefined
 }
 
+function isAuthInfo(value: unknown): value is AuthInfo {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false
+  const record = value as Record<string, unknown>
+  if (record.type === "api") return typeof record.key === "string"
+  if (record.type === "oauth") {
+    return typeof record.access === "string" && typeof record.refresh === "string" && typeof record.expires === "number"
+  }
+  if (record.type === "wellknown") return typeof record.key === "string" && typeof record.token === "string"
+  return false
+}
+
+function normalizeAuthMap(raw: unknown): Record<string, AuthInfo> | undefined {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined
+  const record = raw as Record<string, unknown>
+
+  if (
+    record.version === 2 &&
+    record.accounts &&
+    typeof record.accounts === "object" &&
+    !Array.isArray(record.accounts)
+  ) {
+    const accounts = record.accounts as Record<string, unknown>
+    const active =
+      record.active && typeof record.active === "object" && !Array.isArray(record.active) ? record.active : {}
+    const result: Record<string, AuthInfo> = {}
+
+    for (const [serviceID, accountID] of Object.entries(active as Record<string, unknown>)) {
+      if (typeof accountID !== "string") continue
+      const account = accounts[accountID]
+      if (!account || typeof account !== "object" || Array.isArray(account)) continue
+      const credential = (account as Record<string, unknown>).credential
+      if (isAuthInfo(credential)) result[serviceID] = credential
+    }
+
+    for (const account of Object.values(accounts)) {
+      if (!account || typeof account !== "object" || Array.isArray(account)) continue
+      const accountRecord = account as Record<string, unknown>
+      const serviceID = accountRecord.serviceID
+      const credential = accountRecord.credential
+      if (typeof serviceID === "string" && result[serviceID] === undefined && isAuthInfo(credential)) {
+        result[serviceID] = credential
+      }
+    }
+
+    return result
+  }
+
+  const result: Record<string, AuthInfo> = {}
+  for (const [providerID, info] of Object.entries(record)) {
+    if (isAuthInfo(info)) result[providerID] = info
+  }
+  return result
+}
+
 export async function readAuthMap(deps: AuthDependencies): Promise<Record<string, AuthInfo> | undefined> {
   if (process.env.OPENCODE_AUTH_CONTENT) {
     try {
-      const parsed = JSON.parse(process.env.OPENCODE_AUTH_CONTENT) as Record<string, AuthInfo>
-      if (parsed && typeof parsed === "object") return parsed
+      return normalizeAuthMap(JSON.parse(process.env.OPENCODE_AUTH_CONTENT))
     } catch {}
     return undefined
   }
 
-  const filePath = authFilePath()
-  try {
-    const fileStat = await (deps.stat ?? stat)(filePath)
-    if ((fileStat.mode & 0o777) !== 0o600) return undefined
-    const raw = await (deps.readFile ?? readFile)(filePath, "utf8")
-    const parsed = JSON.parse(raw) as Record<string, AuthInfo>
-    return parsed && typeof parsed === "object" ? parsed : undefined
-  } catch {
-    return undefined
+  for (const filePath of authFilePaths()) {
+    try {
+      const raw = await (deps.readFile ?? readFile)(filePath, "utf8")
+      const parsed = normalizeAuthMap(JSON.parse(raw))
+      if (parsed) return parsed
+    } catch {}
   }
+  return undefined
 }

package/src/auth/types.ts

@@ -1,8 +1,9 @@
-import type { FetchLike, OAuthInfo, ProviderInfo } from "../constants"
+import type { AuthInfo, FetchLike, OAuthInfo, ProviderInfo } from "../constants"
 
 export interface ResolvedCredential {
   providerID: string
   provider?: ProviderInfo
+  authInfo?: AuthInfo
   apiKey?: string
   fetch?: FetchLike
   mode: "apiKey" | "oauth" | "default"
@@ -13,7 +14,6 @@ export interface AuthDependencies {
   now?: () => number
   sleep?: (ms: number) => Promise<void>
   readFile?: (filePath: string, encoding: BufferEncoding) => Promise<string>
-  stat?: (filePath: string) => Promise<{ mode: number }>
   packageVersion?: string
 }
 

package/src/constants/types.ts

@@ -59,13 +59,27 @@ export interface MessageWithPartsLike {
   parts: TextPartLike[]
 }
 
+export interface ProviderModelInfo {
+  id?: string
+  api?: {
+    id?: string
+    url?: string
+    npm?: string
+  }
+  headers?: Record<string, string>
+  options?: Record<string, unknown>
+  capabilities?: {
+    temperature?: boolean
+  }
+}
+
 export interface ProviderInfo {
   id: string
   source: ProviderSource
   env: string[]
   key?: string
   options?: Record<string, unknown>
-  models?: Record<string, unknown>
+  models?: Record<string, ProviderModelInfo>
 }
 
 interface ProviderListResponseLike {

package/src/question-tool.ts

@@ -76,35 +76,47 @@ export function isQuestionArgs(value: unknown): value is QuestionArgs {
   return true
 }
 
-async function assignTranslation(
-  container: Record<string, string>,
-  key: string,
-  translate: (text: string) => Promise<string>,
-): Promise<void> {
-  const original = container[key]
-  if (!original || original.length === 0) return
-  const translated = await translate(original)
-  container[key] = unwrapEchoedTextEnvelope(translated)
+async function translatedDisplayText(text: string, translate: (text: string) => Promise<string>): Promise<string> {
+  if (text.length === 0) return text
+  return unwrapEchoedTextEnvelope(await translate(text))
 }
 
-// Translate every display-facing string in `args` in parallel. The caller can
-// snapshot the translated form afterward with `snapshotQuestions`.
+// Translate every display-facing string in parallel, then commit the translated
+// clone only after every translation succeeds.
 export async function translateQuestionArgs(
   args: QuestionArgs,
   translate: (text: string) => Promise<string>,
 ): Promise<void> {
+  const translatedQuestions = snapshotQuestions(args)
   const jobs: Promise<void>[] = []
 
-  for (const q of args.questions) {
-    jobs.push(assignTranslation(q as unknown as Record<string, string>, "question", translate))
-    jobs.push(assignTranslation(q as unknown as Record<string, string>, "header", translate))
+  for (const q of translatedQuestions) {
+    jobs.push(
+      (async () => {
+        q.question = await translatedDisplayText(q.question, translate)
+      })(),
+    )
+    jobs.push(
+      (async () => {
+        q.header = await translatedDisplayText(q.header, translate)
+      })(),
+    )
     for (const option of q.options) {
-      jobs.push(assignTranslation(option as unknown as Record<string, string>, "label", translate))
-      jobs.push(assignTranslation(option as unknown as Record<string, string>, "description", translate))
+      jobs.push(
+        (async () => {
+          option.label = await translatedDisplayText(option.label, translate)
+        })(),
+      )
+      jobs.push(
+        (async () => {
+          option.description = await translatedDisplayText(option.description, translate)
+        })(),
+      )
     }
   }
 
   await Promise.all(jobs)
+  args.questions.splice(0, args.questions.length, ...translatedQuestions)
 }
 
 // Given a user-selected label, find the matching translated option and return

package/src/translator/index.ts

@@ -1,5 +1,5 @@
 import { setTimeout as sleep } from "node:timers/promises"
-import { generateText } from "ai"
+import { generateText, type LanguageModel } from "ai"
 import { createCredentialResolver } from "../auth"
 import {
   buildAuthUnavailableError,
@@ -16,6 +16,7 @@ import {
   instantiateModel,
   instantiateProvider,
   loadFactory,
+  resolveModelInfo,
   supportsTemperature,
 } from "./provider"
 import { withRetry } from "./retry"
@@ -71,22 +72,24 @@ export function createTranslator(
     const startedAt = now()
     const { providerID, modelID } = parseTranslatorModel(options.translatorModel)
     const credentials = await credentialResolver.resolve(options.translatorModel)
-    const factory = await loadFactory(providerID)
-    const provider = instantiateProvider(factory, providerID, credentials)
-    const model = instantiateModel(provider, modelID)
+    const modelInfo = resolveModelInfo(credentials.provider, modelID)
+    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
 
     const rawTranslated = await withRetry(async () => {
       try {
-        const result = (await withTimeout(
+        const result = await withTimeout(
           generateTextImpl({
-            model: model as never,
+            model,
             system: buildSystemPrompt(input),
-            ...(supportsTemperature(providerID, modelID) ? { temperature: 0 } : {}),
+            ...(supportsTemperature(providerID, modelID, modelInfo) ? { temperature: 0 } : {}),
             prompt: buildUserPrompt(input),
-          }) as Promise<{ text: string }>,
+          }),
           timeoutMs,
           "Translator generateText",
-        )) as { text: string }
+        )
         return result.text
       } catch (error) {
         if (isAuthMessage(error)) throw error

package/src/translator/provider.ts

@@ -1,80 +1,356 @@
-import type { FetchLike } from "../constants"
+import type { AuthInfo, FetchLike, ProviderInfo, ProviderModelInfo } from "../constants"
 
 const providerFactoryCache = new Map<string, unknown>()
 
+const PROVIDER_PACKAGE_FALLBACK: Record<string, string> = {
+  anthropic: "@ai-sdk/anthropic",
+  openai: "@ai-sdk/openai",
+  google: "@ai-sdk/google",
+  "google-vertex": "@ai-sdk/google-vertex",
+  "amazon-bedrock": "@ai-sdk/amazon-bedrock",
+  "github-copilot": "@ai-sdk/openai-compatible",
+}
+
+const CREATE_EXPORT_FALLBACK: Record<string, string[]> = {
+  "@ai-sdk/amazon-bedrock": ["createAmazonBedrock", "bedrock"],
+  "@ai-sdk/anthropic": ["createAnthropic", "anthropic"],
+  "@ai-sdk/azure": ["createAzure", "azure"],
+  "@ai-sdk/gateway": ["createGateway", "gateway"],
+  "@ai-sdk/google": ["createGoogleGenerativeAI", "google"],
+  "@ai-sdk/google-vertex": ["createVertex", "vertex"],
+  "@ai-sdk/openai": ["createOpenAI", "openai"],
+  "@ai-sdk/openai-compatible": ["createOpenAICompatible"],
+  "@openrouter/ai-sdk-provider": ["createOpenRouter", "openrouter"],
+}
+
+interface ProviderCredentials {
+  provider?: ProviderInfo
+  authInfo?: AuthInfo
+  apiKey?: string
+  fetch?: FetchLike
+}
+
 export function __resetProviderFactoryCacheForTest() {
   providerFactoryCache.clear()
 }
 
-export async function loadFactory(providerID: string): Promise<unknown> {
-  const cached = providerFactoryCache.get(providerID)
+function providerPackage(providerID: string, model?: ProviderModelInfo): string {
+  const packageName = model?.api?.npm || PROVIDER_PACKAGE_FALLBACK[providerID]
+  if (!packageName) throw new Error(`Unsupported translator provider "${providerID}"`)
+  return packageName
+}
+
+function pickFactory(mod: Record<string, unknown>, packageName: string): unknown {
+  for (const key of CREATE_EXPORT_FALLBACK[packageName] ?? []) {
+    if (typeof mod[key] === "function") return mod[key]
+  }
+  const createKey = Object.keys(mod).find((key) => key.startsWith("create") && typeof mod[key] === "function")
+  return createKey ? mod[createKey] : undefined
+}
+
+export async function loadFactory(providerID: string, model?: ProviderModelInfo): Promise<unknown> {
+  const packageName = providerPackage(providerID, model)
+  const cached = providerFactoryCache.get(packageName)
   if (cached) return cached
 
-  let factory: unknown
-  if (providerID === "anthropic") {
-    const mod = await import("@ai-sdk/anthropic")
-    factory = mod.createAnthropic ?? mod.anthropic
-  } else if (providerID === "openai") {
-    const mod = await import("@ai-sdk/openai")
-    factory = mod.createOpenAI ?? mod.openai
-  } else if (providerID === "google") {
-    const mod = await import("@ai-sdk/google")
-    factory = mod.createGoogleGenerativeAI ?? mod.google
-  } else if (providerID === "google-vertex") {
-    const mod = await import("@ai-sdk/google-vertex")
-    factory = mod.createVertex ?? mod.vertex
-  } else if (providerID === "amazon-bedrock") {
-    const mod = await import("@ai-sdk/amazon-bedrock")
-    factory = mod.createAmazonBedrock ?? mod.bedrock
-  } else if (providerID === "github-copilot") {
-    const mod = await import("@ai-sdk/openai-compatible")
-    factory = mod.createOpenAICompatible
-  } else {
-    throw new Error(`Unsupported translator provider "${providerID}"`)
+  let mod: Record<string, unknown>
+  try {
+    mod = (await import(packageName)) as Record<string, unknown>
+  } catch (error) {
+    throw new Error(`Unable to load provider package "${packageName}" for "${providerID}": ${String(error)}`)
   }
+  const factory = pickFactory(mod, packageName)
 
   if (typeof factory !== "function") {
-    throw new Error(`Unable to load provider factory for "${providerID}"`)
+    throw new Error(`Unable to load provider factory from "${packageName}" for "${providerID}"`)
   }
 
-  providerFactoryCache.set(providerID, factory)
+  providerFactoryCache.set(packageName, factory)
   return factory
 }
 
+export function resolveModelInfo(provider: ProviderInfo | undefined, modelID: string): ProviderModelInfo {
+  return provider?.models?.[modelID] ?? { id: modelID, api: { id: modelID } }
+}
+
+function headerRecord(value: unknown): Record<string, string> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {}
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>).filter((entry): entry is [string, string] => {
+      return typeof entry[1] === "string"
+    }),
+  )
+}
+
+function substitutionVars(options: Record<string, unknown>, authInfo?: AuthInfo): Record<string, string | undefined> {
+  const metadata = authInfo?.type === "api" ? authInfo.metadata : undefined
+  const location =
+    stringOption(options.location) ?? process.env.GOOGLE_VERTEX_LOCATION ?? process.env.GOOGLE_CLOUD_LOCATION
+  const vertexEndpoint =
+    location === "global" ? "aiplatform.googleapis.com" : location ? `${location}-aiplatform.googleapis.com` : undefined
+  return {
+    ...process.env,
+    AZURE_RESOURCE_NAME:
+      stringOption(options.resourceName) ?? metadata?.resourceName ?? process.env.AZURE_RESOURCE_NAME,
+    GOOGLE_VERTEX_PROJECT:
+      stringOption(options.project) ??
+      process.env.GOOGLE_VERTEX_PROJECT ??
+      process.env.GOOGLE_CLOUD_PROJECT ??
+      process.env.GCP_PROJECT ??
+      process.env.GCLOUD_PROJECT,
+    GOOGLE_VERTEX_LOCATION: location,
+    GOOGLE_VERTEX_ENDPOINT: vertexEndpoint ?? process.env.GOOGLE_VERTEX_ENDPOINT,
+    CLOUDFLARE_ACCOUNT_ID: metadata?.accountId ?? process.env.CLOUDFLARE_ACCOUNT_ID,
+    CLOUDFLARE_GATEWAY_ID: metadata?.gatewayId ?? process.env.CLOUDFLARE_GATEWAY_ID,
+  }
+}
+
+function stringOption(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined
+}
+
+function resolveBaseURL(baseURL: unknown, apiURL: unknown, options: Record<string, unknown>, authInfo?: AuthInfo) {
+  let url = stringOption(baseURL) ?? stringOption(apiURL)
+  if (!url) return undefined
+  const vars = substitutionVars(options, authInfo)
+  url = url.replace(/\$\{([^}]+)\}/g, (match, key) => vars[String(key)] ?? match)
+  return url
+}
+
+function wrapSSE(response: Response, ms: number, controller: AbortController) {
+  if (typeof ms !== "number" || ms <= 0) return response
+  if (!response.body) return response
+  if (!response.headers.get("content-type")?.includes("text/event-stream")) return response
+
+  const reader = response.body.getReader()
+  const body = new ReadableStream<Uint8Array>({
+    async pull(ctrl) {
+      const part = await new Promise<Awaited<ReturnType<typeof reader.read>>>((resolve, reject) => {
+        const id = setTimeout(() => {
+          const error = new Error("SSE read timed out")
+          controller.abort(error)
+          void reader.cancel(error)
+          reject(error)
+        }, ms)
+
+        reader.read().then(
+          (value) => {
+            clearTimeout(id)
+            resolve(value)
+          },
+          (error) => {
+            clearTimeout(id)
+            reject(error)
+          },
+        )
+      })
+
+      if (part.done) {
+        ctrl.close()
+        return
+      }
+
+      ctrl.enqueue(part.value)
+    },
+    async cancel(reason) {
+      controller.abort(reason)
+      await reader.cancel(reason)
+    },
+  })
+
+  return new Response(body, {
+    headers: new Headers(response.headers),
+    status: response.status,
+    statusText: response.statusText,
+  })
+}
+
+function anySignal(signals: AbortSignal[]): AbortSignal | undefined {
+  if (signals.length === 0) return undefined
+  if (signals.length === 1) return signals[0]
+  const signalAny = (AbortSignal as typeof AbortSignal & { any?: (signals: AbortSignal[]) => AbortSignal }).any
+  return signalAny ? signalAny(signals) : signals[0]
+}
+
+function stripOpenAIItemIDs(packageName: string, init: RequestInit) {
+  if (packageName !== "@ai-sdk/openai" && packageName !== "@ai-sdk/azure") return
+  if (!init.body || init.method !== "POST" || typeof init.body !== "string") return
+  try {
+    const body = JSON.parse(init.body) as Record<string, unknown>
+    if (body.store === true || !Array.isArray(body.input)) return
+    for (const item of body.input) {
+      if (item && typeof item === "object" && !Array.isArray(item)) delete (item as Record<string, unknown>).id
+    }
+    init.body = JSON.stringify(body)
+  } catch {}
+}
+
+function withOpenCodeFetch(config: Record<string, unknown>, packageName: string) {
+  const configuredFetch = typeof config.fetch === "function" ? (config.fetch as FetchLike) : undefined
+  const chunkTimeout = typeof config.chunkTimeout === "number" ? config.chunkTimeout : undefined
+  delete config.chunkTimeout
+
+  config.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+    const requestInit = { ...(init ?? {}) }
+    const signals: AbortSignal[] = []
+    const chunkController = chunkTimeout && chunkTimeout > 0 ? new AbortController() : undefined
+    if (requestInit.signal) signals.push(requestInit.signal)
+    if (chunkController) signals.push(chunkController.signal)
+    if (typeof config.timeout === "number" && config.timeout > 0) signals.push(AbortSignal.timeout(config.timeout))
+    const signal = anySignal(signals)
+    if (signal) requestInit.signal = signal
+    stripOpenAIItemIDs(packageName, requestInit)
+
+    const response = await (configuredFetch ?? fetch)(input, { ...requestInit, timeout: false } as RequestInit)
+    return chunkController && chunkTimeout ? wrapSSE(response, chunkTimeout, chunkController) : response
+  }
+}
+
+function providerConfig(
+  providerID: string,
+  credentials: ProviderCredentials,
+  model?: ProviderModelInfo,
+): Record<string, unknown> {
+  const provider = credentials.provider
+  const packageName = providerPackage(providerID, model)
+  const config: Record<string, unknown> = { ...(provider?.options ?? {}) }
+
+  if (providerID === "google-vertex" && !packageName.includes("@ai-sdk/openai-compatible")) delete config.fetch
+  if (packageName.includes("@ai-sdk/openai-compatible") && config.includeUsage !== false) config.includeUsage = true
+
+  const baseURL = resolveBaseURL(config.baseURL, model?.api?.url, config, credentials.authInfo)
+  if (baseURL !== undefined) config.baseURL = baseURL
+  if (credentials.apiKey !== undefined) config.apiKey = credentials.apiKey
+  if (credentials.fetch) config.fetch = credentials.fetch
+  if (model?.headers) config.headers = { ...headerRecord(config.headers), ...model.headers }
+  if (providerID === "github-copilot" && config.baseURL === undefined) config.baseURL = "https://api.githubcopilot.com"
+  if (
+    providerID === "amazon-bedrock" &&
+    credentials.authInfo?.type === "api" &&
+    !process.env.AWS_BEARER_TOKEN_BEDROCK
+  ) {
+    process.env.AWS_BEARER_TOKEN_BEDROCK = credentials.authInfo.key
+  }
+
+  withOpenCodeFetch(config, packageName)
+  return { name: providerID, ...config }
+}
+
 export function instantiateProvider(
   factory: unknown,
   providerID: string,
-  credentials: { apiKey?: string; fetch?: FetchLike },
+  credentials: ProviderCredentials,
+  model?: ProviderModelInfo,
 ): unknown {
   if (typeof factory !== "function") throw new Error(`Invalid provider factory for "${providerID}"`)
+  return (factory as (config: Record<string, unknown>) => unknown)(providerConfig(providerID, credentials, model))
+}
 
-  const config = {
-    ...(credentials.apiKey !== undefined ? { apiKey: credentials.apiKey } : {}),
-    ...(credentials.fetch ? { fetch: credentials.fetch } : {}),
-  }
+function shouldUseCopilotResponsesApi(modelID: string): boolean {
+  const match = /^gpt-(\d+)/.exec(modelID)
+  if (!match) return false
+  return Number(match[1]) >= 5 && !modelID.startsWith("gpt-5-mini")
+}
 
-  if (providerID === "github-copilot") {
-    return (factory as (config: Record<string, unknown>) => unknown)({
-      ...config,
-      name: "github-copilot",
-      baseURL: "https://api.githubcopilot.com",
-    })
-  }
+function selectAzureLanguageModel(record: Record<string, unknown>, modelID: string, useChat: boolean): unknown {
+  if (useChat && typeof record.chat === "function") return (record.chat as (id: string) => unknown)(modelID)
+  if (typeof record.responses === "function") return (record.responses as (id: string) => unknown)(modelID)
+  if (typeof record.messages === "function") return (record.messages as (id: string) => unknown)(modelID)
+  if (typeof record.chat === "function") return (record.chat as (id: string) => unknown)(modelID)
+  if (typeof record.languageModel === "function") return (record.languageModel as (id: string) => unknown)(modelID)
+}
+
+function bedrockModelID(modelID: string, region: unknown): string {
+  const crossRegionPrefixes = ["global.", "us.", "eu.", "jp.", "apac.", "au."]
+  if (crossRegionPrefixes.some((prefix) => modelID.startsWith(prefix))) return modelID
+  if (typeof region !== "string") return modelID
 
-  return (factory as (config: Record<string, unknown>) => unknown)(config)
+  let regionPrefix = region.split("-")[0]
+  if (regionPrefix === "us") {
+    const modelRequiresPrefix = [
+      "nova-micro",
+      "nova-lite",
+      "nova-pro",
+      "nova-premier",
+      "nova-2",
+      "claude",
+      "deepseek",
+    ].some((value) => modelID.includes(value))
+    if (modelRequiresPrefix && !region.startsWith("us-gov")) return `${regionPrefix}.${modelID}`
+  }
+  if (regionPrefix === "eu") {
+    const regionRequiresPrefix = [
+      "eu-west-1",
+      "eu-west-2",
+      "eu-west-3",
+      "eu-north-1",
+      "eu-central-1",
+      "eu-south-1",
+      "eu-south-2",
+    ].some((value) => region.includes(value))
+    const modelRequiresPrefix = ["claude", "nova-lite", "nova-micro", "llama3", "pixtral"].some((value) =>
+      modelID.includes(value),
+    )
+    if (regionRequiresPrefix && modelRequiresPrefix) return `${regionPrefix}.${modelID}`
+  }
+  if (regionPrefix === "ap") {
+    const isAustraliaRegion = ["ap-southeast-2", "ap-southeast-4"].includes(region)
+    const isTokyoRegion = region === "ap-northeast-1"
+    if (
+      isAustraliaRegion &&
+      ["anthropic.claude-sonnet-4-5", "anthropic.claude-haiku"].some((value) => modelID.includes(value))
+    ) {
+      regionPrefix = "au"
+      return `${regionPrefix}.${modelID}`
+    }
+    const modelRequiresPrefix = ["claude", "nova-lite", "nova-micro", "nova-pro"].some((value) =>
+      modelID.includes(value),
+    )
+    if (modelRequiresPrefix) return `${isTokyoRegion ? "jp" : "apac"}.${modelID}`
+  }
+  return modelID
 }
 
-export function instantiateModel(provider: unknown, modelID: string): unknown {
+export function instantiateModel(
+  provider: unknown,
+  modelID: string,
+  providerID?: string,
+  model?: ProviderModelInfo,
+  providerOptions?: Record<string, unknown>,
+): unknown {
+  const apiID = model?.api?.id || model?.id || modelID
   if (typeof provider === "function") return provider(modelID)
   if (provider && typeof provider === "object") {
     const record = provider as Record<string, unknown>
+    if ((providerID === "openai" || providerID === "xai") && typeof record.responses === "function") {
+      return (record.responses as (id: string) => unknown)(apiID)
+    }
+    if (
+      providerID === "github-copilot" &&
+      typeof record.responses === "function" &&
+      typeof record.chat === "function"
+    ) {
+      return shouldUseCopilotResponsesApi(apiID)
+        ? (record.responses as (id: string) => unknown)(apiID)
+        : (record.chat as (id: string) => unknown)(apiID)
+    }
+    if (providerID === "azure" || providerID === "azure-cognitive-services") {
+      const selected = selectAzureLanguageModel(record, apiID, providerOptions?.useCompletionUrls === true)
+      if (selected) return selected
+    }
+    if (providerID === "amazon-bedrock" && typeof record.languageModel === "function") {
+      return (record.languageModel as (id: string) => unknown)(bedrockModelID(apiID, providerOptions?.region))
+    }
     if (typeof record.chatModel === "function") return (record.chatModel as (id: string) => unknown)(modelID)
-    if (typeof record.languageModel === "function") return (record.languageModel as (id: string) => unknown)(modelID)
+    if (typeof record.languageModel === "function") return (record.languageModel as (id: string) => unknown)(apiID)
+    if (typeof record.chat === "function") return (record.chat as (id: string) => unknown)(apiID)
+    if (typeof record.responses === "function") return (record.responses as (id: string) => unknown)(apiID)
   }
   throw new Error(`Unable to instantiate model "${modelID}"`)
 }
 
-export function supportsTemperature(providerID: string, modelID: string): boolean {
+export function supportsTemperature(providerID: string, modelID: string, model?: ProviderModelInfo): boolean {
+  if (typeof model?.capabilities?.temperature === "boolean") return model.capabilities.temperature
   if (providerID !== "openai") return true
   if (modelID.startsWith("o1") || modelID.startsWith("o3") || modelID.startsWith("o4-mini")) return false
   return !(modelID.startsWith("gpt-5") && !modelID.startsWith("gpt-5-chat"))