opencode-translate 1.0.5 → 1.0.7

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)}`
-}

package/src/translator/provider.ts

@@ -1,411 +0,0 @@
-import { type AuthInfo, type FetchLike, PLUGIN_NAME, type ProviderInfo, type 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"],
-}
-
-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
-  apiKey?: string
-  fetch?: FetchLike
-}
-
-export function __resetProviderFactoryCacheForTest() {
-  providerFactoryCache.clear()
-}
-
-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 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 from "${packageName}" for "${providerID}"`)
-  }
-
-  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 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(
-    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: 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))
-}
-
-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")
-}
-
-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
-
-  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,
-  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)(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, 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"))
-}

package/src/translator/retry.ts

@@ -1,62 +0,0 @@
-import { normalizeReason } from "../constants"
-
-function getStatus(error: unknown): number | undefined {
-  if (!error || typeof error !== "object") return undefined
-  const record = error as Record<string, unknown>
-  if (typeof record.status === "number") return record.status
-  if (typeof record.statusCode === "number") return record.statusCode
-  const response = record.response
-  if (response && typeof response === "object") {
-    const status = (response as Record<string, unknown>).status
-    if (typeof status === "number") return status
-  }
-  return undefined
-}
-
-function getRetryAfterMs(error: unknown): number {
-  if (!error || typeof error !== "object") return 2000
-  const response = (error as Record<string, unknown>).response
-  if (!response || typeof response !== "object") return 2000
-  const headers = (response as { headers?: Headers }).headers
-  if (!(headers instanceof Headers)) return 2000
-  const retryAfter = headers.get("retry-after")
-  if (!retryAfter) return 2000
-  const seconds = Number(retryAfter)
-  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000)
-  const date = Date.parse(retryAfter)
-  return Number.isFinite(date) ? Math.max(0, date - Date.now()) : 2000
-}
-
-function isRetryable(error: unknown): boolean {
-  const status = getStatus(error)
-  if (status === 429) return true
-  if (status !== undefined) return status >= 500
-  const message = normalizeReason(error).toLowerCase()
-  return (
-    message.includes("network") ||
-    message.includes("fetch") ||
-    message.includes("timeout") ||
-    message.includes("socket") ||
-    message.includes("econn")
-  )
-}
-
-export async function withRetry<T>(task: () => Promise<T>, sleepImpl: (ms: number) => Promise<void>): Promise<T> {
-  let lastError: unknown
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    try {
-      return await task()
-    } catch (error) {
-      lastError = error
-      if (!isRetryable(error)) throw error
-      if (getStatus(error) === 429) {
-        if (attempt >= 1) throw error
-        await sleepImpl(getRetryAfterMs(error))
-        continue
-      }
-      if (attempt >= 2) throw error
-      await sleepImpl(attempt === 0 ? 500 : 1500)
-    }
-  }
-  throw lastError
-}