fix(routing): retain refresh interval and localize pricing

Co-authored-by: Brendonovich <Brendonovich@users.noreply.github.com>

packages/ai/src/protocols/open-responses.ts

@@ -1,4 +1,4 @@
-import { Effect, Option, Schema } from "effect"
+import { Effect, Option, Schema, SchemaGetter } from "effect"
 import type { Content } from "@opencode/schema/tool"
 import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
@@ -86,6 +86,7 @@ export const OpenResponsesReasoningItem = Schema.Struct({
   id: Schema.optionalKey(Schema.String),
   summary: Schema.Array(OpenResponsesReasoningSummaryText),
   encrypted_content: optionalNull(Schema.String),
+  provider_metadata: Schema.optional(JsonObject),
 })
 
 const OpenResponsesWebSearchCall = Schema.StructWithRest(
@@ -182,6 +183,7 @@ export const InputItem = Schema.Union([
     content: Schema.Array(OpenResponsesOutputText),
     phase: Schema.optionalKey(MessagePhase),
     status: Schema.optional(Schema.String),
+    provider_metadata: Schema.optional(JsonObject),
   }),
   OpenResponsesReasoningItem,
   Schema.Struct({
@@ -191,6 +193,7 @@ export const InputItem = Schema.Union([
     name: Schema.String,
     namespace: Schema.optional(Schema.String),
     arguments: Schema.String,
+    provider_metadata: Schema.optional(JsonObject),
   }),
   Schema.Struct({
     type: Schema.tag("function_call_output"),
@@ -223,6 +226,7 @@ type OpenResponsesReasoningInput = {
   id?: string
   summary: Array<{ type: "summary_text"; text: string }>
   encrypted_content?: string | null
+  provider_metadata?: Record<string, unknown>
 }
 export const Tool = Schema.Struct({
   type: Schema.tag("function"),
@@ -325,9 +329,8 @@ export const StreamItem = Schema.StructWithRest(
 export type StreamItem = Schema.Schema.Type<typeof StreamItem>
 export type OutputItem = StreamItem & { readonly id: string }
 
-// The Responses schema puts streaming error details at the top level and
-// response failures under `response.error`. WebSocket failures use an
-// event-level `error` envelope, so accept all three shapes here.
+// Responses-compatible providers put streaming error details at the top level or
+// under `error`, and response failures under `response.error`. Accept all three shapes.
 // https://www.openresponses.org/specification
 const OpenResponsesErrorPayload = Schema.Struct({
   type: optionalNull(Schema.String),
@@ -401,6 +404,17 @@ export const Event = Schema.StructWithRest(
     headers: Schema.optional(Schema.Unknown),
   }),
   [Schema.Record(Schema.String, Schema.Unknown)],
+).pipe(
+  Schema.decode({
+    decode: SchemaGetter.transform((event) => {
+      if (event.type !== "error" || event.error != null) return event
+      const { code, message, param, ...rest } = event
+      if (code === undefined && message === undefined && param === undefined) return event
+      // Flat errors (for example, Meta's) can also arrive through generic Responses endpoints.
+      return { ...rest, error: { code, message, param } }
+    }),
+    encode: SchemaGetter.passthrough(),
+  }),
 )
 export type Event = Schema.Schema.Type<typeof Event>
 export type NormalizedEvent = Event & { readonly item?: OutputItem | null }
@@ -426,6 +440,8 @@ export const decodeChannelEvent = (frame: string) =>
 export interface ProviderAdapter {
   readonly id: string
   readonly name: string
+  /** Replay opaque gateway continuation state only for adapters that own this extension. */
+  readonly preserveProviderMetadata?: boolean
   readonly nativeTool?: (
     native: NonNullable<ToolDefinition["native"]>,
   ) => Effect.Effect<{ readonly type: string }, AIError>
@@ -445,6 +461,7 @@ export interface ParserState {
   readonly id: string
   readonly name: string
   readonly providerMetadataKey: string
+  readonly preserveProviderMetadata: boolean
   readonly tools: ToolStream.State<string>
   readonly hasFunctionCall: boolean
   readonly lifecycle: Lifecycle.State
@@ -504,7 +521,16 @@ const itemID = (providerMetadata: ProviderMetadata | undefined, providerMetadata
   return separator > 0 && separator < metadata.itemId.length - 1 ? metadata.itemId : undefined
 }
 
-const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenResponsesInputItem => {
+const replayProviderMetadata = (metadata: ProviderMetadata | undefined, key: string, adapter: ProviderAdapter) => {
+  const value = metadata?.[key]?.providerMetadata
+  return adapter.preserveProviderMetadata && ProviderShared.isRecord(value) ? { provider_metadata: value } : {}
+}
+
+const lowerToolCall = (
+  part: ToolCallPart,
+  providerMetadataKey: string,
+  adapter: ProviderAdapter,
+): OpenResponsesInputItem => {
   const id = itemID(part.providerMetadata, providerMetadataKey)
   return {
     type: "function_call",
@@ -513,10 +539,15 @@ const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenRes
     name: part.name,
     namespace: part.namespace,
     arguments: ProviderShared.encodeJson(part.input),
+    ...replayProviderMetadata(part.providerMetadata, providerMetadataKey, adapter),
   }
 }
 
-const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenResponsesReasoningInput | undefined => {
+const lowerReasoning = (
+  part: ReasoningPart,
+  providerMetadataKey: string,
+  adapter: ProviderAdapter,
+): OpenResponsesReasoningInput | undefined => {
   const metadata = part.providerMetadata?.[providerMetadataKey]
   if (!ProviderShared.isRecord(metadata)) return undefined
   const id = itemID(part.providerMetadata, providerMetadataKey)
@@ -529,6 +560,7 @@ const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenR
     ...(id === undefined ? {} : { id }),
     summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
     encrypted_content: encryptedContent,
+    ...replayProviderMetadata(part.providerMetadata, providerMetadataKey, adapter),
   }
 }
 
@@ -677,6 +709,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
             status: "completed",
             content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
             ...(group.phase === undefined ? {} : { phase: group.phase }),
+            ...replayProviderMetadata(group.parts.at(-1)?.providerMetadata, providerMetadataKey, adapter),
           })),
         )
         content.splice(0, content.length)
@@ -697,13 +730,14 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
         }
         if (part.type === "reasoning") {
           flushText()
-          const reasoning = lowerReasoning(part, providerMetadataKey)
+          const reasoning = lowerReasoning(part, providerMetadataKey, adapter)
           if (!reasoning) continue
           const existing = reasoning.id === undefined ? undefined : reasoningItems[reasoning.id]
           if (existing) {
             existing.summary.push(...reasoning.summary)
             if (typeof reasoning.encrypted_content === "string")
               existing.encrypted_content = reasoning.encrypted_content
+            if (reasoning.provider_metadata !== undefined) existing.provider_metadata = reasoning.provider_metadata
             continue
           }
           if (reasoning.id !== undefined) reasoningItems[reasoning.id] = reasoning
@@ -713,7 +747,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
         if (part.type === "tool-call") {
           flushText()
           if (part.providerExecuted === true) continue
-          input.push(lowerToolCall(part, providerMetadataKey))
+          input.push(lowerToolCall(part, providerMetadataKey, adapter))
           continue
         }
         if (part.type === "tool-result" && part.providerExecuted === true) {
@@ -1052,8 +1086,17 @@ export const onReasoningDone = (state: ParserState, event: Event, itemID: string
   return onReasoningDelta(state, { ...event, delta: event.text }, itemID)
 }
 
+const outputMetadata = (state: ParserState, item: OutputItem, extra?: Record<string, unknown>) =>
+  providerMetadata(state, {
+    itemId: item.id,
+    ...extra,
+    ...(state.preserveProviderMetadata && ProviderShared.isRecord(item.provider_metadata)
+      ? { providerMetadata: item.provider_metadata }
+      : {}),
+  })
+
 const reasoningMetadata = (state: ParserState, item: OutputItem) =>
-  providerMetadata(state, { itemId: item.id, reasoningEncryptedContent: item.encrypted_content ?? null })
+  outputMetadata(state, item, { reasoningEncryptedContent: item.encrypted_content ?? null })
 
 // Responses APIs normally stream reasoning items in this order:
 //   `output_item.added` (reasoning) →
@@ -1116,7 +1159,7 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
   }
   if (item.type !== "function_call" || !item.call_id) return [state, NO_EVENTS]
   if (state.tools[item.id] !== undefined) return [state, NO_EVENTS]
-  const metadata = providerMetadata(state, { itemId: item.id })
+  const metadata = outputMetadata(state, item)
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
   return [
@@ -1239,7 +1282,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
       content.push(decoded.type === "output_text" ? decoded.text : decoded.refusal)
     }
     const text = content.length > 0 ? content.join("") : undefined
-    const metadata = providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) })
+    const metadata = outputMetadata(state, item, phase === undefined ? undefined : { phase })
     const events: LLMEvent[] = []
     const lifecycle = text ? Lifecycle.textStart(state.lifecycle, events, item.id, metadata) : state.lifecycle
     return [
@@ -1254,10 +1297,11 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
 
   if (item.type === "function_call") {
     if (!item.call_id || !item.name) return [state, NO_EVENTS] satisfies StepResult
-    const metadata = providerMetadata(state, { itemId: item.id })
-    const registered = state.tools[item.id] !== undefined
-    const tools = registered
-      ? state.tools
+    const metadata = outputMetadata(state, item)
+    const pending = state.tools[item.id]
+    const registered = pending !== undefined
+    const tools = pending
+      ? ToolStream.start(state.tools, item.id, { ...pending, providerMetadata: metadata })
       : ToolStream.start(state.tools, item.id, {
           id: item.call_id,
           name: item.name,
@@ -1511,6 +1555,7 @@ export const initial = (request: LLMRequest, adapter: ProviderAdapter = BASE_ADA
   id: adapter.id,
   name: adapter.name,
   providerMetadataKey: metadataKey(request.model),
+  preserveProviderMetadata: adapter.preserveProviderMetadata ?? false,
   hasFunctionCall: false,
   tools: ToolStream.empty<string>(),
   lifecycle: Lifecycle.initial(),

packages/ai/src/protocols/organization-routes.ts

@@ -0,0 +1,72 @@
+import { Effect, Schema } from "effect"
+import { Route } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { Protocol } from "../route/protocol.js"
+import { HttpTransport } from "../route/transport/index.js"
+import type { LLMRequest } from "../schema/index.js"
+import { OpenResponses } from "./open-responses.js"
+import { ProviderShared } from "./shared.js"
+
+const ADAPTER = "organization-routes"
+
+const adapter = {
+  id: ADAPTER,
+  name: "Organization routes",
+  preserveProviderMetadata: true,
+} satisfies OpenResponses.ProviderAdapter
+
+const Body = Schema.Struct({
+  ...OpenResponses.coreFields,
+  store: Schema.Literal(false),
+  provider_options: Schema.Struct({
+    "openai-responses": Schema.Struct({ include: Schema.Array(Schema.String) }),
+  }),
+  stream: Schema.Literal(true),
+})
+
+const fromRequest = Effect.fn("OrganizationRoutes.fromRequest")(function* (request: LLMRequest) {
+  const body = yield* OpenResponses.fromRequestWithAdapter(request, adapter)
+  // A route can select another provider on each call. Keep full history and only
+  // portable options; native caching and stored IDs would exclude translated
+  // targets. Scope encrypted reasoning to native Responses targets so their
+  // stateless continuations remain replayable without blocking other protocols.
+  return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))({
+    model: body.model,
+    input: body.input,
+    instructions: body.instructions,
+    tools: body.tools,
+    tool_choice: body.tool_choice,
+    stream: true as const,
+    store: false as const,
+    provider_options: { "openai-responses": { include: ["reasoning.encrypted_content"] } },
+    max_output_tokens:
+      body.max_output_tokens !== undefined && body.max_output_tokens > 0 ? body.max_output_tokens : undefined,
+    temperature: body.temperature,
+    top_p: body.top_p,
+    parallel_tool_calls: body.parallel_tool_calls,
+    metadata: body.metadata,
+    reasoning: body.reasoning?.effort === undefined ? undefined : { effort: body.reasoning.effort },
+    text: body.text,
+  })
+})
+
+export const protocol = Protocol.make({
+  ...OpenResponses.protocol,
+  id: ADAPTER,
+  body: { schema: Body, from: fromRequest },
+  stream: {
+    ...OpenResponses.protocol.stream,
+    initial: (request: LLMRequest) => OpenResponses.initial(request, adapter),
+  },
+})
+
+export const route = Route.make({
+  id: ADAPTER,
+  providerMetadataKey: ADAPTER,
+  protocol,
+  endpoint: Endpoint.path(OpenResponses.PATH),
+  transport: HttpTransport.sseJson.with<typeof Body.Type>(),
+  defaults: { providerOptions: { store: false, include: [] } },
+})
+
+export * as OrganizationRoutes from "./organization-routes.js"

packages/ai/src/providers/alibaba.ts

@@ -6,7 +6,7 @@ import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
-import { ProviderID, ToolDefinition, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, ToolDefinition, type ModelID } from "../schema/index.js"
 
 export const id = ProviderID.make("alibaba")
 
@@ -82,8 +82,13 @@ export const configure = (input: Config) => {
         ? hosts.get(region)
         : `${workspaceID}.${region}.maas.aliyuncs.com`
   if (baseURL === undefined) {
-    if (region === undefined) throw new Error("Alibaba requires region or baseURL")
-    if (host === undefined) throw new Error(`Alibaba region ${region} requires workspaceID or baseURL`)
+    if (region === undefined)
+      throw new ProviderConfigurationError({ provider: id, message: "Alibaba requires region or baseURL" })
+    if (host === undefined)
+      throw new ProviderConfigurationError({
+        provider: id,
+        message: `Alibaba region ${region} requires workspaceID or baseURL`,
+      })
   }
   const opts = { ...rest, auth: AuthOptions.bearer(input, ["DASHSCOPE_API_KEY", "ALIBABA_API_KEY"]) }
   const common = { ...opts, endpoint: { baseURL: baseURL ?? `https://${host}/compatible-mode/v1` } }

packages/ai/src/providers/amazon-bedrock-mantle.ts

@@ -4,7 +4,7 @@ import type { ProviderPackage } from "../provider-package.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
 import { OpenResponses } from "../protocols/open-responses.js"
 import { BedrockAuth, type Credentials } from "../protocols/utils/bedrock-auth.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("amazon-bedrock")
@@ -79,9 +79,12 @@ const defaults = (input: Config) => {
 
 export const configure = (input: Config = {}) => {
   if (input.auth === "bearer" && input.apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-    throw new Error("Amazon Bedrock Mantle bearer auth requires apiKey")
+    throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock Mantle bearer auth requires apiKey" })
   if (input.auth === "sigv4" && input.apiKey !== undefined)
-    throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Amazon Bedrock Mantle SigV4 auth does not accept apiKey",
+    })
   const configuredResponsesRoute = configuredRoute(responsesRoute, input)
   const configuredChatRoute = configuredRoute(chatRoute, input)
   const modelDefaults = defaults(input)

packages/ai/src/providers/amazon-bedrock.ts

@@ -1,6 +1,6 @@
 import type { RouteDefaultsInput } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import * as BedrockConverse from "../protocols/bedrock-converse.js"
 import type { BedrockCredentials } from "../protocols/bedrock-converse.js"
 import { BedrockAuth } from "../protocols/utils/bedrock-auth.js"
@@ -39,8 +39,9 @@ const bedrockBaseURL = (region: string) => `https://bedrock-runtime.${region}.am
 const configuredRoute = (input: Config) => {
   const { apiKey, auth, credentials, profile, region, baseURL, ...rest } = input
   if (auth === "bearer" && apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-    throw new Error("Amazon Bedrock bearer auth requires apiKey")
-  if (auth === "sigv4" && apiKey !== undefined) throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey")
+    throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock bearer auth requires apiKey" })
+  if (auth === "sigv4" && apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock SigV4 auth does not accept apiKey" })
   const resolvedRegion = BedrockAuth.resolveRegion(input)
   return BedrockConverse.route.with({
     ...rest,

packages/ai/src/providers/anthropic-compatible.ts

@@ -3,7 +3,7 @@ import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
 import type { RouteDefaultsInput } from "../route/client.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 
 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
 export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput
@@ -36,8 +36,12 @@ const auth = (input: ProviderAuthOption<"optional">) => {
 }
 
 export const configure = (input: Config) => {
-  if (!input.baseURL) throw new Error("Anthropic-compatible providers require a baseURL")
   const provider = input.provider ?? "anthropic-compatible"
+  if (!input.baseURL)
+    throw new ProviderConfigurationError({
+      provider: ProviderID.make(provider),
+      message: "Anthropic-compatible providers require a baseURL",
+    })
   const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
   const route = AnthropicMessages.route.with({
     ...rest,
@@ -61,8 +65,13 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
   modelID,
   settings,
 ) => {
+  // Read before the exclusivity check narrows a conflicting settings object to `never`.
+  const provider = ProviderID.make(settings.provider ?? id)
   if (settings.apiKey !== undefined && settings.authToken !== undefined)
-    throw new Error("Anthropic-compatible apiKey cannot be combined with authToken")
+    throw new ProviderConfigurationError({
+      provider,
+      message: "Anthropic-compatible apiKey cannot be combined with authToken",
+    })
   return configure({
     ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
     baseURL: settings.baseURL,

packages/ai/src/providers/anthropic.ts

@@ -2,7 +2,7 @@ import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { AnthropicCompatible } from "./anthropic-compatible.js"
 
@@ -57,7 +57,10 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
   settings,
 ) => {
   if (settings.apiKey !== undefined && settings.authToken !== undefined)
-    throw new Error("Anthropic apiKey cannot be combined with authToken")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Anthropic apiKey cannot be combined with authToken",
+    })
   return configure({
     ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
     baseURL: settings.baseURL,

packages/ai/src/providers/azure.ts

@@ -3,7 +3,7 @@ import { Auth } from "../route/auth.js"
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
 import type { Route, RouteDefaultsInput, CompactionOperations } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
 import * as OpenAIResponses from "../protocols/openai-responses.js"
 import { ProviderShared } from "../protocols/shared.js"
@@ -163,7 +163,7 @@ const config = (settings: Settings): Config => {
   }
   if (settings.baseURL !== undefined) return { ...common, baseURL: settings.baseURL }
   if (settings.resourceName !== undefined) return { ...common, resourceName: settings.resourceName }
-  throw new Error("Azure requires resourceName or baseURL")
+  throw new ProviderConfigurationError({ provider: id, message: "Azure requires resourceName or baseURL" })
 }
 
 export const responsesModel: ProviderPackage.Definition<

packages/ai/src/providers/cloudflare-ai-gateway.ts

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js"
 import type { AtLeastOne, ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("cloudflare-ai-gateway")
@@ -35,7 +35,11 @@ export type Settings = ProviderPackage.Settings &
 
 export const baseURL = (input: GatewayURL) => {
   if (input.baseURL) return input.baseURL
-  if (!input.accountId) throw new Error("CloudflareAIGateway.configure requires accountId unless baseURL is supplied")
+  if (!input.accountId)
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "CloudflareAIGateway.configure requires accountId unless baseURL is supplied",
+    })
   return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(input.accountId)}/${encodeURIComponent(input.gatewayId?.trim() || "default")}/compat`
 }
 

packages/ai/src/providers/cloudflare-workers-ai.ts

@@ -3,7 +3,7 @@ import { OpenAIChat } from "../protocols/openai-chat.js"
 import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
 export const id = ProviderID.make("cloudflare-workers-ai")
@@ -28,7 +28,11 @@ export type Settings = ProviderPackage.Settings &
 
 export const baseURL = (input: WorkersAIURL) => {
   if (input.baseURL) return input.baseURL
-  if (!input.accountId) throw new Error("CloudflareWorkersAI.configure requires accountId unless baseURL is supplied")
+  if (!input.accountId)
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "CloudflareWorkersAI.configure requires accountId unless baseURL is supplied",
+    })
   return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(input.accountId)}/ai/v1`
 }
 

packages/ai/src/providers/google-vertex-chat.ts

@@ -2,7 +2,7 @@ import type { ProviderPackage } from "../provider-package.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
@@ -37,7 +37,8 @@ const route = Route.make({
 export const routes = [route]
 
 const configuredRoute = (input: Config) => {
-  if ("apiKey" in input && input.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
+  if ("apiKey" in input && input.apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Chat does not support API keys" })
   const {
     accessToken: _accessToken,
     auth: _auth,
@@ -74,7 +75,8 @@ export const provider = {
 }
 
 export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
+  if (settings.apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Chat does not support API keys" })
   return configure({
     accessToken: settings.accessToken,
     baseURL: settings.baseURL,

packages/ai/src/providers/google-vertex-messages.ts

@@ -5,7 +5,7 @@ import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 
 export type AnthropicOptionsInput = AnthropicMessages.OptionsInput
@@ -67,7 +67,7 @@ export const routes = [route]
 
 const configuredRoute = (input: Config) => {
   if ("apiKey" in input && input.apiKey !== undefined)
-    throw new Error("Google Vertex Messages does not support API keys")
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Messages does not support API keys" })
   const {
     accessToken: _accessToken,
     auth: _auth,
@@ -107,7 +107,8 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
   modelID,
   settings,
 ) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Messages does not support API keys")
+  if (settings.apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Messages does not support API keys" })
   return configure({
     accessToken: settings.accessToken,
     baseURL: settings.baseURL,

packages/ai/src/providers/google-vertex-responses.ts

@@ -2,7 +2,7 @@ import type { ProviderPackage } from "../provider-package.js"
 import { OpenResponses } from "../protocols/open-responses.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { ProviderID, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
 
@@ -39,7 +39,7 @@ export const routes = [route]
 
 const configuredRoute = (input: Config) => {
   if ("apiKey" in input && input.apiKey !== undefined)
-    throw new Error("Google Vertex Responses does not support API keys")
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Responses does not support API keys" })
   const {
     accessToken: _accessToken,
     auth: _auth,
@@ -79,7 +79,8 @@ export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOp
   modelID,
   settings,
 ) => {
-  if (settings.apiKey !== undefined) throw new Error("Google Vertex Responses does not support API keys")
+  if (settings.apiKey !== undefined)
+    throw new ProviderConfigurationError({ provider: id, message: "Google Vertex Responses does not support API keys" })
   return configure({
     accessToken: settings.accessToken,
     baseURL: settings.baseURL,

packages/ai/src/providers/google-vertex-shared.ts

@@ -1,8 +1,10 @@
 import type { AnyAuthClient } from "google-auth-library"
 import { Effect, Redacted } from "effect"
 import { Auth, MissingCredentialError } from "../route/auth.js"
+import { ProviderConfigurationError, ProviderID } from "../schema/index.js"
 
 const SCOPE = "https://www.googleapis.com/auth/cloud-platform"
+const id = ProviderID.make("google-vertex")
 
 export type OAuthOptions =
   | { readonly accessToken?: string; readonly auth?: never }
@@ -35,12 +37,18 @@ export const host = (location: string) => {
 
 export const requireProject = (value: string | undefined) => {
   if (value) return value
-  throw new Error("Google Vertex requires a project when baseURL is not configured")
+  throw new ProviderConfigurationError({
+    provider: id,
+    message: "Google Vertex requires a project when baseURL is not configured",
+  })
 }
 
 export const apiKey = (input: ApiKeyOptions) => {
   if (input.apiKey !== undefined && (input.accessToken !== undefined || input.auth !== undefined))
-    throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Google Vertex apiKey cannot be combined with accessToken or auth",
+    })
   if (input.accessToken !== undefined || input.auth !== undefined) return undefined
   return input.apiKey ?? process.env.GOOGLE_VERTEX_API_KEY
 }
@@ -68,7 +76,10 @@ const adc = (project?: string) => {
 
 export const oauth = (input: OAuthOptions, project?: string) => {
   if (input.accessToken !== undefined && input.auth !== undefined)
-    throw new Error("Google Vertex accessToken cannot be combined with auth")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Google Vertex accessToken cannot be combined with auth",
+    })
   if (input.auth) return input.auth
   if (input.accessToken !== undefined) return Auth.bearer(input.accessToken)
   return adc(project)

packages/ai/src/providers/google-vertex.ts

@@ -6,7 +6,7 @@ import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
-import { ProviderID, type LLMRequest, type ModelID } from "../schema/index.js"
+import { ProviderConfigurationError, ProviderID, type LLMRequest, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
 
 export interface GeminiOptionsInput extends Gemini.OptionsInput {
@@ -93,7 +93,10 @@ const configuredRoute = (input: Config, modelID: string | ModelID) => {
   const apiKey = GoogleVertexShared.apiKey(input)
   const endpointModel = String(modelID).startsWith("endpoints/")
   if (apiKey !== undefined && endpointModel)
-    throw new Error("Google Vertex tuned models do not support Express Mode API keys")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Google Vertex tuned models do not support Express Mode API keys",
+    })
   const location = GoogleVertexShared.location(inputLocation, "us-central1")
   const project = GoogleVertexShared.project(inputProject)
   const endpoint =
@@ -123,7 +126,10 @@ export const provider = {
 }
 export const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsInput>["model"] = (modelID, settings) => {
   if (settings.apiKey !== undefined && settings.accessToken !== undefined)
-    throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth")
+    throw new ProviderConfigurationError({
+      provider: id,
+      message: "Google Vertex apiKey cannot be combined with accessToken or auth",
+    })
   return configure({
     ...(settings.apiKey === undefined ? { accessToken: settings.accessToken } : { apiKey: settings.apiKey }),
     baseURL: settings.baseURL,

packages/ai/src/providers/organization-routes.ts

@@ -0,0 +1,57 @@
+import type { ProviderPackage } from "../provider-package.js"
+import { OrganizationRoutes } from "../protocols/organization-routes.js"
+import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
+import type { RouteDefaultsInput } from "../route/client.js"
+import { ProviderID, type ModelID } from "../schema/index.js"
+import type { OpenResponsesProviderOptionsInput } from "./open-responses-options.js"
+
+export type Options = Pick<
+  OpenResponsesProviderOptionsInput,
+  "reasoningEffort" | "textVerbosity" | "parallelToolCalls" | "metadata" | "allowedTools"
+>
+
+export const id = ProviderID.make("organization-routes")
+
+export type Config = RouteDefaultsInput &
+  ProviderAuthOption<"optional"> & {
+    readonly provider?: string
+    readonly baseURL: string
+    readonly providerOptions?: Options
+  }
+
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL: string
+  readonly provider?: string
+  readonly providerOptions?: Options
+}
+
+export const routes = [OrganizationRoutes.route]
+
+export const configure = (input: Config) => {
+  const provider = input.provider ?? "organization-routes"
+  const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input
+  const route = OrganizationRoutes.route.with({
+    ...rest,
+    provider,
+    endpoint: { baseURL },
+    auth: AuthOptions.bearer(input, []),
+  })
+  return {
+    id: ProviderID.make(provider),
+    model: (modelID: string | ModelID) => route.model<Options>({ id: modelID }),
+    configure,
+  }
+}
+
+export const provider = { id, configure }
+
+export const model: ProviderPackage.Definition<Settings, Options>["model"] = (modelID, settings) =>
+  configure({
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    provider: settings.provider,
+    providerOptions: settings.providerOptions,
+  }).model(modelID)

packages/ai/src/route/client.ts

@@ -23,6 +23,7 @@ import {
   LanguageModel,
   LLMEvent,
   InvalidProviderOutputError,
+  ProviderConfigurationError,
   ProviderID,
   mergeGenerationOptions,
   mergeHttpOptions,
@@ -128,7 +129,10 @@ const makeRouteLanguageModel = <Options extends ProviderOptions, Compact extends
   const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined)
   if (!provider) throw new Error(`Route.model(${route.id}) requires a provider`)
   if (!endpointBaseURL(route.endpoint))
-    throw new Error(`Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`)
+    throw new ProviderConfigurationError({
+      provider: ProviderID.make(provider),
+      message: `Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`,
+    })
   return LanguageModel.make<Options, Compact>({
     ...mapped,
     provider,

packages/ai/src/schema/errors.ts

@@ -50,6 +50,19 @@ export class UnsupportedOperationError extends Schema.TaggedError<UnsupportedOpe
   route: Schema.optional(RouteID),
 }) {}
 
+/**
+ * Provider settings that are missing, conflicting, or unsupported, such as
+ * Azure without `resourceName` or `baseURL`. Thrown synchronously while a
+ * provider facade or package entrypoint configures a model, before any
+ * request exists, so it is not an `AIError` reason.
+ */
+export class ProviderConfigurationError extends Schema.TaggedError<ProviderConfigurationError>(
+  "AI.Error.ProviderConfiguration",
+)("ProviderConfiguration", {
+  provider: ProviderID,
+  message: Schema.String,
+}) {}
+
 export class NoRouteError extends Schema.TaggedError<NoRouteError>("AI.Error.NoRoute")("NoRoute", {
   ...ReasonFields,
   route: RouteID,

packages/ai/test/provider-package.test.ts

@@ -3,6 +3,9 @@ import { model } from "@opencode/ai/providers/openai"
 import { LLM } from "../src/index.js"
 import { Endpoint } from "../src/route/endpoint.js"
 
+const configuration = (provider: string, message: string) =>
+  expect.objectContaining({ _tag: "ProviderConfiguration", provider, message })
+
 describe("provider package entrypoints", () => {
   test("semantic API aliases expose the same contract", async () => {
     const modules = await Promise.all([
@@ -322,7 +325,7 @@ describe("provider package entrypoints", () => {
     const AnthropicCompatible = await import("@opencode/ai/providers/anthropic-compatible")
     expect(() =>
       Reflect.apply(AnthropicCompatible.model, undefined, ["compatible-model", { apiKey: "fixture" }]),
-    ).toThrow("Anthropic-compatible providers require a baseURL")
+    ).toThrow(configuration("anthropic-compatible", "Anthropic-compatible providers require a baseURL"))
   })
 
   test("rejects conflicting Anthropic-compatible auth settings at runtime", async () => {
@@ -337,10 +340,10 @@ describe("provider package entrypoints", () => {
           baseURL: "https://messages.example.test/v1",
         },
       ]),
-    ).toThrow("Anthropic-compatible apiKey cannot be combined with authToken")
+    ).toThrow(configuration("anthropic-compatible", "Anthropic-compatible apiKey cannot be combined with authToken"))
     expect(() =>
       Reflect.apply(Anthropic.model, undefined, ["claude-sonnet-4-6", { apiKey: "fixture", authToken: "token" }]),
-    ).toThrow("Anthropic apiKey cannot be combined with authToken")
+    ).toThrow(configuration("anthropic", "Anthropic apiKey cannot be combined with authToken"))
   })
 
   test("maps legacy OpenAI organization and project settings to headers", () => {
@@ -490,43 +493,45 @@ describe("provider package entrypoints", () => {
         "gemini-3.5-flash",
         { accessToken: "token", apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow("Google Vertex apiKey cannot be combined with accessToken or auth")
+    ).toThrow(configuration("google-vertex", "Google Vertex apiKey cannot be combined with accessToken or auth"))
     const configured = Reflect.apply(GoogleVertex.configure, undefined, [
       { accessToken: "token", auth: {}, project: "vertex-project" },
     ])
-    expect(() => configured.model("gemini-3.5-flash")).toThrow("Google Vertex accessToken cannot be combined with auth")
+    expect(() => configured.model("gemini-3.5-flash")).toThrow(
+      configuration("google-vertex", "Google Vertex accessToken cannot be combined with auth"),
+    )
     expect(() =>
       Reflect.apply(GoogleVertexMessages.model, undefined, [
         "claude-sonnet-4-6",
         { apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow("Google Vertex Messages does not support API keys")
+    ).toThrow(configuration("google-vertex", "Google Vertex Messages does not support API keys"))
     expect(() =>
       Reflect.apply(Providers.GoogleVertexMessages.configure, undefined, [
         { apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow("Google Vertex Messages does not support API keys")
+    ).toThrow(configuration("google-vertex", "Google Vertex Messages does not support API keys"))
     expect(() =>
       Reflect.apply(GoogleVertexChat.model, undefined, [
         "deepseek-ai/deepseek-v3.2-maas",
         { apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow("Google Vertex Chat does not support API keys")
+    ).toThrow(configuration("google-vertex", "Google Vertex Chat does not support API keys"))
     expect(() =>
       Reflect.apply(Providers.GoogleVertexChat.configure, undefined, [
         { apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow("Google Vertex Chat does not support API keys")
+    ).toThrow(configuration("google-vertex", "Google Vertex Chat does not support API keys"))
     expect(() =>
       Reflect.apply(GoogleVertexResponses.model, undefined, [
         "xai/grok-4.20-reasoning",
         { apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow("Google Vertex Responses does not support API keys")
+    ).toThrow(configuration("google-vertex", "Google Vertex Responses does not support API keys"))
     expect(() =>
       Reflect.apply(Providers.GoogleVertexResponses.configure, undefined, [
         { apiKey: "fixture", project: "vertex-project" },
       ]),
-    ).toThrow("Google Vertex Responses does not support API keys")
+    ).toThrow(configuration("google-vertex", "Google Vertex Responses does not support API keys"))
   })
 })

packages/ai/test/provider/alibaba.test.ts

@@ -76,7 +76,13 @@ it.effect("Alibaba owns regional shared and workspace-specific endpoints", () =>
 
 test("Alibaba requires explicit placement and supports complete base URL overrides", () => {
   for (const region of ["eu-central-1", "ap-northeast-1", "future-region"])
-    expect(() => Alibaba.configure({ region })).toThrow("requires workspaceID or baseURL")
+    expect(() => Alibaba.configure({ region })).toThrow(
+      expect.objectContaining({
+        _tag: "ProviderConfiguration",
+        provider: "alibaba",
+        message: `Alibaba region ${region} requires workspaceID or baseURL`,
+      }),
+    )
   for (const config of [
     { baseURL: "https://gateway.example/prefix" },
     { region: "future-region", workspaceID: "ignored", baseURL: "https://gateway.example/prefix" },

packages/ai/test/provider/bedrock-converse.test.ts

@@ -1458,7 +1458,13 @@ describe("Bedrock Converse route", () => {
         expect(headers.get("authorization")).toContain("Credential=AKIACHAINEXAMPLE/")
         expect(headers.get("authorization")).toContain("/ap-southeast-2/bedrock/aws4_request")
       }
-      expect(() => AmazonBedrock.configure({ auth: "sigv4", apiKey: "k" })).toThrow("does not accept apiKey")
+      expect(() => AmazonBedrock.configure({ auth: "sigv4", apiKey: "k" })).toThrow(
+        expect.objectContaining({
+          _tag: "ProviderConfiguration",
+          provider: "amazon-bedrock",
+          message: "Amazon Bedrock SigV4 auth does not accept apiKey",
+        }),
+      )
     }).pipe(
       withProcessEnv({
         ...noAmbientAWS,

packages/ai/test/provider/google-vertex.test.ts

@@ -378,7 +378,11 @@ describe("Google Vertex providers", () => {
 
   test("rejects tuned Gemini models in express mode", () => {
     expect(() => GoogleVertex.configure({ apiKey: "fixture" }).model("endpoints/1234567890")).toThrow(
-      "Google Vertex tuned models do not support Express Mode API keys",
+      expect.objectContaining({
+        _tag: "ProviderConfiguration",
+        provider: "google-vertex",
+        message: "Google Vertex tuned models do not support Express Mode API keys",
+      }),
     )
   })
 })

packages/ai/test/provider/open-responses-errors.test.ts

@@ -0,0 +1,78 @@
+import { expect } from "bun:test"
+import { Effect, Schema } from "effect"
+import { LLM, LLMClient } from "../../src/index.js"
+import { OpenResponses } from "../../src/protocols/open-responses.js"
+import { Meta } from "../../src/providers/index.js"
+import { configure } from "../../src/providers/openai-compatible-responses.js"
+import { it } from "../lib/effect.js"
+import { fixedResponse } from "../lib/http.js"
+import { sseEvents } from "../lib/sse.js"
+
+const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event)
+
+it.effect("normalizes flat errors in shared SSE and WebSocket decoding", () =>
+  Effect.gen(function* () {
+    const frame = {
+      type: "error",
+      sequence_number: 4,
+      code: "server_shutting_down",
+      message: "Server is shutting down. Please retry your request.",
+      param: null,
+    }
+    for (const decode of [decodeEvent, OpenResponses.decodeChannelEvent]) {
+      const event = yield* decode(JSON.stringify(frame))
+      expect(event).toEqual({
+        type: "error",
+        sequence_number: 4,
+        error: { code: frame.code, message: frame.message, param: null },
+      })
+
+      for (const unchanged of [
+        event,
+        { type: "error" },
+        {
+          type: "response.failed",
+          response: { id: "resp_failed", error: { code: "server_error", message: "Internal server error" } },
+        },
+        { type: "response.output_text.delta", item_id: "msg_text", delta: "Hello" },
+      ]) {
+        expect(yield* decode(JSON.stringify(unchanged))).toEqual(unchanged)
+      }
+    }
+  }),
+)
+
+it.effect("continues to normalize untyped xAI WebSocket errors", () =>
+  Effect.gen(function* () {
+    const frame = { error: { type: "api_error", message: "gRPC error: Response with id=resp_missing not found" } }
+    expect(yield* OpenResponses.decodeChannelEvent(JSON.stringify(frame))).toEqual({ ...frame, type: "error" })
+  }),
+)
+
+it.effect("retains classification and original error bodies through Meta and generic Responses routes", () =>
+  Effect.gen(function* () {
+    const raw = `{
+  "type": "error",
+  "sequence_number": 4,
+  "code": "server_shutting_down",
+  "message": "Server is shutting down. Please retry your request.",
+  "param": null,
+  "diagnostic": "retain-original-frame"
+}`
+    for (const model of [
+      Meta.configure({ apiKey: "fixture" }).responses("muse-spark-1.3"),
+      configure({ apiKey: "fixture", provider: "gateway", baseURL: "https://responses.example.test/v1" }).model(
+        "example-model",
+      ),
+    ]) {
+      const error = yield* LLMClient.generate(LLM.request({ model, prompt: "Hello" })).pipe(
+        Effect.provide(fixedResponse(sseEvents(raw.replaceAll("\n", "\ndata: ")))),
+        Effect.flip,
+      )
+      expect(error.reason._tag).toBe("ProviderInternal")
+      expect(error.message).toBe("server_shutting_down: Server is shutting down. Please retry your request.")
+      expect(error.reason.body).toBe(raw)
+      expect(error.reason.http?.status).toBe(200)
+    }
+  }),
+)

packages/ai/test/provider/organization-routes.test.ts

@@ -0,0 +1,361 @@
+import { describe, expect } from "bun:test"
+import { Effect, Schema } from "effect"
+import { LLM, LLMEvent, Message } from "../../src/index.js"
+import { configure } from "../../src/providers/organization-routes.js"
+import { provider } from "../../src/providers/openai-compatible-responses.js"
+import { LLMClient } from "../../src/route.js"
+import { compileRequest } from "../../src/route/client.js"
+import { it } from "../lib/effect.js"
+import { dynamicResponse, fixedResponse } from "../lib/http.js"
+import { sseEvents } from "../lib/sse.js"
+
+const model = configure({
+  apiKey: "session-test",
+  baseURL: "https://console.example.test/inference/route/openai/v1",
+  provider: "opencode-routes-org_test",
+  headers: { "x-opencode-org-id": "org_test" },
+}).model("route/coding")
+
+const fixtures = [
+  {
+    protocol: "openai-responses",
+    content: [
+      {
+        type: "reasoning",
+        id: "rs_native",
+        summary: [{ type: "summary_text", text: "Need a lookup" }],
+        encrypted_content: "opaque-openai-reasoning",
+      },
+      { type: "message", id: "msg_native", role: "assistant", content: [{ type: "output_text", text: "Checking." }] },
+      {
+        type: "function_call",
+        id: "fc_native_lookup",
+        call_id: "call_lookup",
+        name: "lookup",
+        arguments: '{"query":"weather"}',
+      },
+      { type: "function_call", id: "fc_native_clock", call_id: "call_clock", name: "clock", arguments: "{}" },
+    ],
+  },
+  {
+    protocol: "google",
+    content: [
+      { text: "Need a lookup", thought: true },
+      { text: "Checking." },
+      { functionCall: { name: "lookup", args: { query: "weather" } }, thoughtSignature: "opaque-google-signature" },
+      { functionCall: { name: "clock", args: {} } },
+    ],
+  },
+  {
+    protocol: "anthropic-messages",
+    content: [
+      { type: "thinking", thinking: "Need a lookup", signature: "opaque-anthropic-signature" },
+      { type: "text", text: "Checking." },
+      { type: "tool_use", id: "call_lookup", name: "lookup", input: { query: "weather" } },
+      { type: "tool_use", id: "call_clock", name: "clock", input: {} },
+    ],
+  },
+  {
+    protocol: "openai-chat",
+    content: [
+      {
+        role: "assistant",
+        reasoning_content: "Need a lookup",
+        content: "Checking.",
+        tool_calls: [
+          { id: "call_lookup", type: "function", function: { name: "lookup", arguments: '{"query":"weather"}' } },
+          { id: "call_clock", type: "function", function: { name: "clock", arguments: "{}" } },
+        ],
+      },
+    ],
+  },
+]
+
+const finalText = sseEvents(
+  {
+    type: "response.output_item.done",
+    item: { type: "message", id: "msg_final", content: [{ type: "output_text", text: "Sunny." }] },
+  },
+  { type: "response.completed", response: { id: "resp_final" } },
+)
+
+describe("organization routes", () => {
+  it.effect("uses the Responses route endpoint with stateless portable options", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(
+        LLM.request({
+          model,
+          system: "Help with code.",
+          prompt: "Hello",
+          promptCacheKey: "session-cache",
+          providerOptions: {
+            store: true,
+            include: ["reasoning.encrypted_content"],
+            previousResponseId: "resp_old",
+            reasoningEffort: "low",
+            reasoningSummary: "auto",
+            serviceTier: "priority",
+          },
+        }),
+      ).pipe(
+        Effect.provide(
+          dynamicResponse((input) =>
+            Effect.gen(function* () {
+              expect(input.request.url).toBe("https://console.example.test/inference/route/openai/v1/responses")
+              expect(input.request.headers.authorization).toBe("Bearer session-test")
+              expect(input.request.headers["x-opencode-org-id"]).toBe("org_test")
+              expect(yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(input.text)).toEqual({
+                model: "route/coding",
+                input: [{ role: "user", content: [{ type: "input_text", text: "Hello" }] }],
+                instructions: "Help with code.",
+                stream: true,
+                store: false,
+                provider_options: { "openai-responses": { include: ["reasoning.encrypted_content"] } },
+                reasoning: { effort: "low" },
+              })
+              return input.respond(finalText, { headers: { "content-type": "text/event-stream" } })
+            }),
+          ),
+        ),
+      )
+      expect(response.text).toBe("Sunny.")
+    }),
+  )
+
+  it.effect("omits an unknown output limit", () =>
+    Effect.gen(function* () {
+      const prepared = yield* compileRequest(LLM.request({ model, prompt: "Hello", generation: { maxTokens: 0 } }))
+      expect(prepared.body.max_output_tokens).toBeUndefined()
+    }),
+  )
+
+  for (const fixture of fixtures) {
+    it.effect(`preserves ${fixture.protocol} continuation metadata through a streamed parallel tool loop`, () =>
+      Effect.gen(function* () {
+        const metadata = {
+          protocol: fixture.protocol,
+          model: "native-model",
+          connection_id: "conn_native",
+          endpoint_id: "endpoint_native",
+          content: fixture.content,
+          group_id: "resp_tools",
+        }
+        const marker = { group_id: "resp_tools" }
+        const items = [
+          {
+            type: "reasoning",
+            id: "rs_1",
+            summary: [{ type: "summary_text", text: "Need a lookup" }],
+            provider_metadata: metadata,
+          },
+          {
+            type: "message",
+            id: "msg_1",
+            role: "assistant",
+            content: [{ type: "output_text", text: "Checking." }],
+            provider_metadata: marker,
+          },
+          {
+            type: "function_call",
+            id: "fc_lookup",
+            call_id: "call_lookup",
+            name: "lookup",
+            arguments: '{"query":"weather"}',
+            provider_metadata: marker,
+          },
+          {
+            type: "function_call",
+            id: "fc_clock",
+            call_id: "call_clock",
+            name: "clock",
+            arguments: "{}",
+            provider_metadata: marker,
+          },
+        ]
+        const first = yield* LLMClient.generate(LLM.request({ model, prompt: "Check weather and time." })).pipe(
+          Effect.provide(
+            fixedResponse(
+              sseEvents(
+                {
+                  type: "response.output_item.added",
+                  output_index: 0,
+                  item: { type: "reasoning", id: "rs_1", summary: [] },
+                },
+                {
+                  type: "response.reasoning_summary_text.delta",
+                  item_id: "rs_1",
+                  summary_index: 0,
+                  delta: "Need a lookup",
+                },
+                {
+                  type: "response.output_item.added",
+                  output_index: 1,
+                  item: { type: "message", id: "msg_1", role: "assistant", content: [] },
+                },
+                { type: "response.output_text.delta", item_id: "msg_1", delta: "Checking." },
+                {
+                  type: "response.output_item.added",
+                  output_index: 2,
+                  item: {
+                    type: "function_call",
+                    id: "fc_lookup",
+                    call_id: "call_lookup",
+                    name: "lookup",
+                    arguments: "",
+                  },
+                },
+                { type: "response.function_call_arguments.delta", item_id: "fc_lookup", delta: '{"query":"weather"}' },
+                {
+                  type: "response.output_item.added",
+                  output_index: 3,
+                  item: { type: "function_call", id: "fc_clock", call_id: "call_clock", name: "clock", arguments: "" },
+                },
+                { type: "response.function_call_arguments.delta", item_id: "fc_clock", delta: "{}" },
+                ...items.map((item, output_index) => ({ type: "response.output_item.done", output_index, item })),
+                { type: "response.completed", response: { id: "resp_tools", output: items } },
+              ),
+            ),
+          ),
+        )
+        expect(first.toolCalls).toHaveLength(2)
+        expect(first.events.filter(LLMEvent.is.toolCall)).toHaveLength(2)
+        expect(
+          first.message.content.map((part) => part.providerMetadata?.["opencode-routes-org_test"]?.providerMetadata),
+        ).toEqual([metadata, marker, marker, marker])
+
+        const second = yield* LLMClient.generate(
+          LLM.request({
+            model,
+            providerOptions: { previousResponseId: "resp_tools" },
+            messages: [
+              Message.user("Check weather and time."),
+              first.message,
+              Message.tool({ id: "call_lookup", name: "lookup", result: { weather: "sunny" } }),
+              Message.tool({ id: "call_clock", name: "clock", result: { time: "noon" } }),
+            ],
+          }),
+        ).pipe(
+          Effect.provide(
+            dynamicResponse((input) =>
+              Effect.gen(function* () {
+                const body = yield* Schema.decodeUnknownEffect(
+                  Schema.fromJsonString(
+                    Schema.Struct({
+                      input: Schema.Array(Schema.Record(Schema.String, Schema.Unknown)),
+                      store: Schema.Boolean,
+                      include: Schema.optional(Schema.Array(Schema.String)),
+                      previous_response_id: Schema.optional(Schema.String),
+                    }),
+                  ),
+                )(input.text)
+                expect(body.store).toBe(false)
+                expect(body.include).toBeUndefined()
+                expect(body.previous_response_id).toBeUndefined()
+                expect(body.input.map((item) => item.type ?? item.role)).toEqual([
+                  "user",
+                  "reasoning",
+                  "message",
+                  "function_call",
+                  "function_call",
+                  "function_call_output",
+                  "function_call_output",
+                ])
+                expect(body.input.slice(1, 5).map((item) => item.provider_metadata)).toEqual([
+                  metadata,
+                  marker,
+                  marker,
+                  marker,
+                ])
+                expect(body.input.slice(3, 5).map((item) => item.call_id)).toEqual(["call_lookup", "call_clock"])
+                return input.respond(finalText, { headers: { "content-type": "text/event-stream" } })
+              }),
+            ),
+          ),
+        )
+        expect(second.text).toBe("Sunny.")
+      }),
+    )
+  }
+
+  it.effect("preserves opaque state on an empty reasoning item", () =>
+    Effect.gen(function* () {
+      const metadata = {
+        protocol: "anthropic-messages",
+        content: [{ type: "redacted_thinking", data: "opaque" }],
+        group_id: "resp_empty",
+      }
+      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Think." })).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              {
+                type: "response.output_item.done",
+                item: { type: "reasoning", id: "rs_empty", summary: [], provider_metadata: metadata },
+              },
+              { type: "response.completed", response: { id: "resp_empty" } },
+            ),
+          ),
+        ),
+      )
+      const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
+      expect(replay.body.input).toEqual([
+        { type: "reasoning", id: "rs_empty", summary: [], encrypted_content: null, provider_metadata: metadata },
+      ])
+    }),
+  )
+
+  it.effect("keeps opaque route metadata out of other Responses providers", () =>
+    Effect.gen(function* () {
+      const other = provider
+        .configure({
+          apiKey: "test-key",
+          baseURL: "https://other.example.test/v1",
+          provider: "opencode-routes-org_test",
+        })
+        .model("other")
+      const response = yield* LLMClient.generate(LLM.request({ model: other, prompt: "Hello" })).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              {
+                type: "response.output_item.done",
+                item: {
+                  type: "message",
+                  id: "msg_1",
+                  content: [{ type: "output_text", text: "Hi" }],
+                  provider_metadata: { group_id: "resp_1", secret: "opaque" },
+                },
+              },
+              { type: "response.completed", response: { id: "resp_1" } },
+            ),
+          ),
+        ),
+      )
+      expect(response.message.content[0]?.providerMetadata).toEqual({ "opencode-routes-org_test": { itemId: "msg_1" } })
+      const replay = yield* compileRequest(
+        LLM.request({
+          model: other,
+          messages: [
+            Message.assistant({
+              type: "text",
+              text: "Hi",
+              providerMetadata: {
+                "opencode-routes-org_test": { itemId: "msg_1", providerMetadata: { secret: "opaque" } },
+              },
+            }),
+          ],
+        }),
+      )
+      expect(replay.body.input).toEqual([
+        {
+          type: "message",
+          id: "msg_1",
+          role: "assistant",
+          status: "completed",
+          content: [{ type: "output_text", text: "Hi" }],
+        },
+      ])
+      expect(replay.body.include).toEqual(["reasoning.encrypted_content"])
+    }),
+  )
+})

packages/app/component-tests/ssh-reconnect.spec.ts

@@ -19,11 +19,13 @@ story("cancelling a version mismatch permits reconnecting again", async ({ mount
   const component = await mount("app-dialog-ssh--incompatible-session")
   await component.getByRole("button", { name: "Reconnect", exact: true }).click()
   const dialog = page.getByRole("dialog")
-  await expect(dialog.getByRole("alert")).toBeVisible()
+  await expect(dialog.getByRole("status")).toContainText("Server update required")
+  await expect(dialog.getByRole("textbox")).toHaveCount(0)
   await dialog.getByRole("button", { name: "Cancel", exact: true }).click()
   await expect(dialog).toHaveCount(0)
   await component.getByRole("button", { name: "Reconnect", exact: true }).click()
-  await expect(dialog.getByRole("alert")).toBeVisible()
+  await expect(dialog.getByRole("status")).toContainText("Server update required")
+  await expect(dialog.getByRole("textbox")).toHaveCount(0)
   await dialog.getByRole("button", { name: "Cancel", exact: true }).click()
   await expect(dialog).toHaveCount(0)
 })
@@ -43,6 +45,17 @@ story("adding a server keeps all SSH challenges in the original connection dialo
   await expect(dialog).toHaveCount(0)
 })
 
+story("adding an incompatible server advances to a dedicated update step", async ({ mount, page }) => {
+  await mount("app-dialog-ssh--incompatible-host")
+  const dialog = page.getByRole("dialog")
+  await dialog.getByRole("textbox", { name: "Host or SSH command" }).fill("ssh devbox")
+  await dialog.getByRole("button", { name: "Add server", exact: true }).click()
+  await expect(dialog.getByRole("status")).toContainText("Server update required")
+  await expect(dialog.getByRole("textbox")).toHaveCount(0)
+  await expect(dialog.getByRole("alert")).toHaveCount(0)
+  await expect(dialog.getByRole("button", { name: "Update and reconnect", exact: true })).toBeVisible()
+})
+
 story("updating an incompatible connection continues authentication in the same dialog", async ({ mount, page }) => {
   const component = await mount("app-dialog-ssh--incompatible-session")
   await component.getByRole("button", { name: "Reconnect", exact: true }).click()

packages/app/e2e/regression/session-timeline-reducer-projection.spec.ts

@@ -115,7 +115,7 @@ test("combines follow-up patches into one three-file stack inside Used", async (
   })
   const group = page.locator('[data-component="collapsed-tool-group"]')
   await group.getByRole("button", { name: "Used 2 Shell, Patch", exact: true }).click()
-  await expect(group.getByText("2 files", { exact: true })).toBeVisible()
+  await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["a.ts", "b.ts"])
   await timeline.send(
     partUpdated(
       toolPart(
@@ -134,7 +134,6 @@ test("combines follow-up patches into one three-file stack inside Used", async (
     "true",
   )
   await expect(group.locator('[data-component="apply-patch-tool"]')).toHaveCount(1)
-  await expect(group.getByText("3 files", { exact: true })).toBeVisible()
   await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["a.ts", "b.ts", "c.ts"])
 })
 

packages/app/src/providers/models/models.tsx

@@ -1,5 +1,6 @@
 import { type Accessor, createMemo } from "solid-js"
 import { DateTime } from "luxon"
+import { isOrganizationRouteProvider } from "@opencode/util/organization-routes"
 import { filter, firstBy, flat, groupBy, mapValues, pipe, uniqueBy, values } from "remeda"
 import { createSimpleContext } from "@opencode/ui/context"
 import { useProviders } from "@/providers/catalog/providers"
@@ -79,8 +80,8 @@ const createModelsController = (directory: Accessor<string | undefined>) => {
   const list = createMemo(() =>
     available().map((m) => ({
       ...m,
-      name: m.name.replace("(latest)", "").trim(),
-      latest: m.name.includes("(latest)"),
+      name: isOrganizationRouteProvider(m.provider.id) ? m.name : m.name.replace("(latest)", "").trim(),
+      latest: !isOrganizationRouteProvider(m.provider.id) && m.name.includes("(latest)"),
     })),
   )
 
@@ -100,6 +101,7 @@ const createModelsController = (directory: Accessor<string | undefined>) => {
     const state = visibility().get(key)
     if (state === "hide") return false
     if (state === "show") return true
+    if (isOrganizationRouteProvider(model.providerID)) return true
     if (latestSet().has(key)) return true
     const date = release().get(key)
     if (!date?.isValid) return true

packages/app/src/providers/models/select-dialog.tsx

@@ -1,4 +1,5 @@
 import { Popover } from "@kobalte/core/popover"
+import { isOrganizationRouteProvider } from "@opencode/util/organization-routes"
 import { Component, ComponentProps, createEffect, createMemo, For, JSX, Show } from "solid-js"
 import { createStore } from "solid-js/store"
 import { useLocal, type ModelSelection } from "@/providers/models/selection"
@@ -197,6 +198,9 @@ const ModelList: Component<{
                                   >
                                     <span class="min-w-0 truncate">{item.name}</span>
                                   </Tooltip>
+                                  <Show when={isOrganizationRouteProvider(item.provider.id)}>
+                                    <Badge class="shrink-0">{language.t("model.tag.variable")}</Badge>
+                                  </Show>
                                   <Show when={isFree(item.provider.id, item.cost)}>
                                     <Badge class="shrink-0">{language.t("model.tag.free")}</Badge>
                                   </Show>
@@ -489,6 +493,9 @@ function ModelSelectorPopoverView(props: {
                                 onSelect={() => selectModel(item)}
                               >
                                 <span class="min-w-0 truncate leading-5">{item.name}</span>
+                                <Show when={isOrganizationRouteProvider(item.provider.id)}>
+                                  <Badge class="shrink-0">{language.t("model.tag.variable")}</Badge>
+                                </Show>
                                 <Show when={isFree(item.provider.id, item.cost)}>
                                   <Badge class="shrink-0">{language.t("model.tag.free")}</Badge>
                                 </Show>

packages/app/src/providers/models/tooltip.tsx

@@ -1,4 +1,5 @@
 import { Show, type Component, type JSX } from "solid-js"
+import { isOrganizationRouteProvider } from "@opencode/util/organization-routes"
 import { useLanguage } from "@/runtime/i18n/language"
 
 type InputKey = "text" | "image" | "audio" | "video" | "pdf"
@@ -8,6 +9,7 @@ type ModelInfo = {
   id: string
   name: string
   provider: {
+    id?: string
     name: string
   }
   capabilities?: {
@@ -36,7 +38,9 @@ export const ModelTooltip: Component<{ model: ModelInfo; latest?: boolean; free?
   props,
 ) => {
   const language = useLanguage()
+  const route = () => isOrganizationRouteProvider(props.model.provider.id ?? "")
   const sourceName = (model: ModelInfo) => {
+    if (route()) return model.provider.name
     const value = `${model.id} ${model.name}`.toLowerCase()
 
     if (/claude|anthropic/.test(value)) return language.t("model.provider.anthropic")
@@ -58,14 +62,16 @@ export const ModelTooltip: Component<{ model: ModelInfo; latest?: boolean; free?
   const title = () => {
     const tags: Array<string> = []
     if (props.latest) tags.push(language.t("model.tag.latest"))
-    if (props.free) tags.push(language.t("model.tag.free"))
+    if (route()) tags.push(language.t("model.tag.variable"))
+    if (!route() && props.free) tags.push(language.t("model.tag.free"))
     const suffix = tags.length ? ` (${tags.join(", ")})` : ""
     return `${sourceName(props.model)} ${props.model.name}${suffix}`
   }
   const name = () => {
     const tags: Array<string> = []
     if (props.latest) tags.push(language.t("model.tag.latest"))
-    if (props.free) tags.push(language.t("model.tag.free"))
+    if (route()) tags.push(language.t("model.tag.variable"))
+    if (!route() && props.free) tags.push(language.t("model.tag.free"))
     const suffix = tags.length ? ` (${tags.join(", ")})` : ""
     return `${props.model.name}${suffix}`
   }
@@ -98,11 +104,13 @@ export const ModelTooltip: Component<{ model: ModelInfo; latest?: boolean; free?
       <div class="flex w-[180px] flex-col gap-2">
         <ModelTooltipRow name={language.t("model.tooltip.model")} value={name()} />
         <ModelTooltipRow name={language.t("model.tooltip.provider")} value={props.model.provider.name} />
-        <Show when={inputs()}>
-          {(value) => <ModelTooltipRow name={language.t("model.tooltip.inputs")} value={value()} />}
+        <Show when={!route()}>
+          <Show when={inputs()}>
+            {(value) => <ModelTooltipRow name={language.t("model.tooltip.inputs")} value={value()} />}
+          </Show>
+          <ModelTooltipRow name={language.t("model.tooltip.reasoning")} value={reasoning()} />
+          <ModelTooltipRow name={language.t("model.tooltip.context.label")} value={contextLimit()} />
         </Show>
-        <ModelTooltipRow name={language.t("model.tooltip.reasoning")} value={reasoning()} />
-        <ModelTooltipRow name={language.t("model.tooltip.context.label")} value={contextLimit()} />
       </div>
     )
   }
@@ -110,15 +118,17 @@ export const ModelTooltip: Component<{ model: ModelInfo; latest?: boolean; free?
   return (
     <div class="flex flex-col gap-1 py-1">
       <div class="text-13-medium">{title()}</div>
-      <Show when={inputs()}>
-        {(value) => (
-          <div class="text-12-regular text-text-invert-base">
-            {language.t("model.tooltip.allows", { inputs: value() })}
-          </div>
-        )}
+      <Show when={!route()}>
+        <Show when={inputs()}>
+          {(value) => (
+            <div class="text-12-regular text-text-invert-base">
+              {language.t("model.tooltip.allows", { inputs: value() })}
+            </div>
+          )}
+        </Show>
+        <div class="text-12-regular text-text-invert-base">{reasoning()}</div>
+        <div class="text-12-regular text-text-invert-base">{context()}</div>
       </Show>
-      <div class="text-12-regular text-text-invert-base">{reasoning()}</div>
-      <div class="text-12-regular text-text-invert-base">{context()}</div>
     </div>
   )
 }

packages/app/src/runtime/i18n/am.ts

@@ -280,6 +280,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} ተቋርጧል",
   "provider.disconnect.toast.disconnected.description": "{{provider}} ሞዴሎች ከአሁን በኋላ አይገኙም።",
   "model.tag.free": "ነጻ",
+  "model.tag.variable": "ተለዋዋጭ",
   "model.tag.latest": "የቅርብ",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/ar.ts

@@ -290,6 +290,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "تم فصل {{provider}}",
   "provider.disconnect.toast.disconnected.description": "لم تعد نماذج {{provider}} متاحة.",
   "model.tag.free": "مجاني",
+  "model.tag.variable": "متغير",
   "model.tag.latest": "الأحدث",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/az.ts

@@ -287,6 +287,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} ayrıldı",
   "provider.disconnect.toast.disconnected.description": "{{provider}} modelləri artıq mövcud deyil.",
   "model.tag.free": "Pulsuz",
+  "model.tag.variable": "Dəyişkən",
   "model.tag.latest": "Ən son",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/bg.ts

@@ -287,6 +287,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} прекъснат",
   "provider.disconnect.toast.disconnected.description": "{{provider}} модели вече не са налични.",
   "model.tag.free": "безплатно",
+  "model.tag.variable": "Променлива",
   "model.tag.latest": "Последни",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/bn.ts

@@ -284,6 +284,7 @@ export const dict: Record<string, string> = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} সংযোগ বিচ্ছিন্ন",
   "provider.disconnect.toast.disconnected.description": "{{provider}} মডেল আর উপলব্ধ নেই৷",
   "model.tag.free": "বিনামূল্যে",
+  "model.tag.variable": "পরিবর্তনশীল",
   "model.tag.latest": "সর্বশেষ",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/br.ts

@@ -292,6 +292,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} desconectado",
   "provider.disconnect.toast.disconnected.description": "Os modelos de {{provider}} não estão mais disponíveis.",
   "model.tag.free": "Grátis",
+  "model.tag.variable": "Variável",
   "model.tag.latest": "Mais recente",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/bs.ts

@@ -308,6 +308,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.description": "{{provider}} modeli više nisu dostupni.",
 
   "model.tag.free": "Besplatno",
+  "model.tag.variable": "Promjenjiva",
   "model.tag.latest": "Najnovije",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/ca.ts

@@ -286,6 +286,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} desconnectat",
   "provider.disconnect.toast.disconnected.description": "{{provider}} models ja no estan disponibles.",
   "model.tag.free": "Gratuït",
+  "model.tag.variable": "Variable",
   "model.tag.latest": "Última",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/cs.ts

@@ -284,6 +284,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} odpojeno",
   "provider.disconnect.toast.disconnected.description": "{{provider}} modely již nejsou k dispozici.",
   "model.tag.free": "Zdarma",
+  "model.tag.variable": "Proměnlivá",
   "model.tag.latest": "Nejnovější",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/da.ts

@@ -205,6 +205,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} frakoblet",
   "provider.disconnect.toast.disconnected.description": "Modeller fra {{provider}} er ikke længere tilgængelige.",
   "model.tag.free": "Gratis",
+  "model.tag.variable": "Variabel",
   "model.tag.latest": "Nyeste",
 
   "model.provider.anthropic": "Anthropic",

packages/app/src/runtime/i18n/de.ts

@@ -196,6 +196,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} getrennt",
   "provider.disconnect.toast.disconnected.description": "Die {{provider}}-Modelle sind nicht mehr verfügbar.",
   "model.tag.free": "Kostenlos",
+  "model.tag.variable": "Variabel",
   "model.tag.latest": "Neueste",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/dv.ts

@@ -289,6 +289,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} ކަނެކްޓް ވެއްޖެއެވެ",
   "provider.disconnect.toast.disconnected.description": "{{provider}} މޮޑެލްތައް މިހާރު ލިބެން ނެތެވެ.",
   "model.tag.free": "ހިލޭ",
+  "model.tag.variable": "ބަދަލުވާ",
   "model.tag.latest": "އެންމެފަހުގެ",
   "model.provider.anthropic": "Anthropic އެވެ",
   "model.provider.openai": "OpenAI އެވެ",

packages/app/src/runtime/i18n/dz.ts

@@ -288,6 +288,7 @@ export const dict: Record<string, string> = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} མཐུད་ལམ་ཆད་ཡོདཔ།",
   "provider.disconnect.toast.disconnected.description": "{{provider}} དཔེ་ཚད་ཚུ་ད་ལས་ཕར་འཐོབ་མི་ཚུགས།",
   "model.tag.free": "རིན་མེད་སྟོང་པ",
+  "model.tag.variable": "འགྱུར་བཅོས་ཅན་",
   "model.tag.latest": "ད༌རེས༌ནངས༌པ",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/el.ts

@@ -285,6 +285,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} αποσυνδέθηκε",
   "provider.disconnect.toast.disconnected.description": "{{provider}} μοντέλα δεν είναι πλέον διαθέσιμα.",
   "model.tag.free": "Δωρεάν",
+  "model.tag.variable": "Μεταβλητή",
   "model.tag.latest": "Τελευταία",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/en.ts

@@ -267,6 +267,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.description": "{{provider}} models are no longer available.",
 
   "model.tag.free": "Free",
+  "model.tag.variable": "Variable",
   "model.tag.latest": "Latest",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/es.ts

@@ -308,6 +308,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.description": "Los modelos de {{provider}} ya no están disponibles.",
 
   "model.tag.free": "Gratis",
+  "model.tag.variable": "Variable",
   "model.tag.latest": "Más reciente",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/et.ts

@@ -283,6 +283,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} on katkestatud",
   "provider.disconnect.toast.disconnected.description": "{{provider}} mudelit pole enam saadaval.",
   "model.tag.free": "Tasuta",
+  "model.tag.variable": "Muutuv",
   "model.tag.latest": "Viimased",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/fa.ts

@@ -284,6 +284,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} قطع شد",
   "provider.disconnect.toast.disconnected.description": "مدل های {{provider}} دیگر در دسترس نیستند.",
   "model.tag.free": "رایگان",
+  "model.tag.variable": "متغیر",
   "model.tag.latest": "آخرین",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/fi.ts

@@ -191,6 +191,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "Yhteys palveluntarjoajaan {{provider}} katkaistu",
   "provider.disconnect.toast.disconnected.description": "{{provider}}-mallit eivät ole enää saatavilla.",
   "model.tag.free": "Ilmainen",
+  "model.tag.variable": "Muuttuva",
   "model.tag.latest": "Uusin",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/fo.ts

@@ -283,6 +283,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} slitið",
   "provider.disconnect.toast.disconnected.description": "{{provider}} modellir eru ikki tøkir longur.",
   "model.tag.free": "Ókeypis",
+  "model.tag.variable": "Skiftandi",
   "model.tag.latest": "Nýggjasta",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/fr.ts

@@ -295,6 +295,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} déconnecté",
   "provider.disconnect.toast.disconnected.description": "Les modèles {{provider}} ne sont plus disponibles.",
   "model.tag.free": "Gratuit",
+  "model.tag.variable": "Variable",
   "model.tag.latest": "Le plus récent",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/he.ts

@@ -282,6 +282,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} מנותק",
   "provider.disconnect.toast.disconnected.description": "המודלים של {{provider}} אינם זמינים עוד.",
   "model.tag.free": "חינם",
+  "model.tag.variable": "משתנה",
   "model.tag.latest": "העדכני ביותר",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/hi.ts

@@ -291,6 +291,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} डिस्कनेक्ट हो गया",
   "provider.disconnect.toast.disconnected.description": "{{provider}} मॉडल अब उपलब्ध नहीं हैं।",
   "model.tag.free": "निःशुल्क",
+  "model.tag.variable": "परिवर्तनशील",
   "model.tag.latest": "नवीनतम",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/hr.ts

@@ -288,6 +288,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} isključen",
   "provider.disconnect.toast.disconnected.description": "{{provider}} modeli više nisu dostupni.",
   "model.tag.free": "Besplatno",
+  "model.tag.variable": "Promjenjiva",
   "model.tag.latest": "Najnoviji",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/hu.ts

@@ -288,6 +288,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} leválasztva",
   "provider.disconnect.toast.disconnected.description": "A {{provider}} modellek már nem kaphatók.",
   "model.tag.free": "Ingyenes",
+  "model.tag.variable": "Változó",
   "model.tag.latest": "Legújabb",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/hy.ts

@@ -286,6 +286,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} անջատված է",
   "provider.disconnect.toast.disconnected.description": "{{provider}} մոդելներն այլևս հասանելի չեն:",
   "model.tag.free": "Անվճար",
+  "model.tag.variable": "Փոփոխական",
   "model.tag.latest": "Վերջին",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/id.ts

@@ -307,6 +307,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.description": "Model {{provider}} tidak lagi tersedia.",
 
   "model.tag.free": "Gratis",
+  "model.tag.variable": "Bervariasi",
   "model.tag.latest": "Terbaru",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/is.ts

@@ -288,6 +288,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} aftengdur",
   "provider.disconnect.toast.disconnected.description": "{{provider}} gerðir eru ekki lengur fáanlegar.",
   "model.tag.free": "Ókeypis",
+  "model.tag.variable": "Breytilegt",
   "model.tag.latest": "Nýjasta",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/it.ts

@@ -193,6 +193,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} disconnesso",
   "provider.disconnect.toast.disconnected.description": "I modelli {{provider}} non sono più disponibili.",
   "model.tag.free": "Gratuito",
+  "model.tag.variable": "Variabile",
   "model.tag.latest": "Più recente",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/ja.ts

@@ -289,6 +289,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}}が切断されました",
   "provider.disconnect.toast.disconnected.description": "{{provider}}のモデルは利用できなくなりました。",
   "model.tag.free": "無料",
+  "model.tag.variable": "変動",
   "model.tag.latest": "最新",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/ka.ts

@@ -284,6 +284,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} გათიშულია",
   "provider.disconnect.toast.disconnected.description": "{{provider}} მოდელები აღარ არის ხელმისაწვდომი.",
   "model.tag.free": "უფასო",
+  "model.tag.variable": "ცვალებადი",
   "model.tag.latest": "უახლესი",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/km.ts

@@ -283,6 +283,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} ត្រូវបានផ្តាច់",
   "provider.disconnect.toast.disconnected.description": "ម៉ូដែល {{provider}} លែងមានទៀតហើយ។",
   "model.tag.free": "ឥតគិតថ្លៃ",
+  "model.tag.variable": "ប្រែប្រួល",
   "model.tag.latest": "ចុងក្រោយ",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/ko.ts

@@ -186,6 +186,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} 연결 해제됨",
   "provider.disconnect.toast.disconnected.description": "{{provider}} 모델을 더 이상 사용할 수 없습니다.",
   "model.tag.free": "무료",
+  "model.tag.variable": "변동",
   "model.tag.latest": "최신",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/lo.ts

@@ -283,6 +283,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} ຕັດການເຊື່ອມຕໍ່ແລ້ວ",
   "provider.disconnect.toast.disconnected.description": "ໂມເດວ {{provider}} ບໍ່ມີແລ້ວ.",
   "model.tag.free": "ຟຣີ",
+  "model.tag.variable": "ປ່ຽນແປງໄດ້",
   "model.tag.latest": "ຫຼ້າສຸດ",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/lt.ts

@@ -289,6 +289,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} atjungtas",
   "provider.disconnect.toast.disconnected.description": "{{provider}} modeliai nebepasiekiami.",
   "model.tag.free": "Nemokama",
+  "model.tag.variable": "Kintama",
   "model.tag.latest": "Naujausias",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/lv.ts

@@ -284,6 +284,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} atvienots",
   "provider.disconnect.toast.disconnected.description": "{{provider}} modeļi vairs nav pieejami.",
   "model.tag.free": "Bezmaksas",
+  "model.tag.variable": "Mainīga",
   "model.tag.latest": "Jaunākais",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/mk.ts

@@ -285,6 +285,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} исклучен",
   "provider.disconnect.toast.disconnected.description": "{{provider}} моделите веќе не се достапни.",
   "model.tag.free": "Бесплатно",
+  "model.tag.variable": "Променлива цена",
   "model.tag.latest": "Најнови",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/mn.ts

@@ -287,6 +287,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} салгагдсан",
   "provider.disconnect.toast.disconnected.description": "{{provider}} загварууд байхгүй болсон.",
   "model.tag.free": "Үнэгүй",
+  "model.tag.variable": "Хувьсах үнэ",
   "model.tag.latest": "Хамгийн сүүлийн үеийн",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/ms.ts

@@ -284,6 +284,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} telah diputuskan",
   "provider.disconnect.toast.disconnected.description": "Model {{provider}} tidak lagi tersedia.",
   "model.tag.free": "Percuma",
+  "model.tag.variable": "Berubah-ubah",
   "model.tag.latest": "Terkini",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/my.ts

@@ -287,6 +287,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} ချိတ်ဆက်မှု ပြတ်တောက်သွားသည်။",
   "provider.disconnect.toast.disconnected.description": "{{provider}} မော်ဒယ်များကို မရနိုင်တော့ပါ။",
   "model.tag.free": "အခမဲ့",
+  "model.tag.variable": "ပြောင်းလဲနိုင်သော",
   "model.tag.latest": "နောက်ဆုံးထွက်",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/ne.ts

@@ -285,6 +285,7 @@ export const dict: Record<string, string> = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} जडान विच्छेद भयो",
   "provider.disconnect.toast.disconnected.description": "{{provider}} मोडेलहरू अब उपलब्ध छैनन्।",
   "model.tag.free": "नि:शुल्क",
+  "model.tag.variable": "परिवर्तनशील मूल्य",
   "model.tag.latest": "पछिल्लो",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/nl.ts

@@ -284,6 +284,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "Verbinding met {{provider}} verbroken",
   "provider.disconnect.toast.disconnected.description": "{{provider}}-modellen zijn niet langer beschikbaar.",
   "model.tag.free": "Gratis",
+  "model.tag.variable": "Variabel",
   "model.tag.latest": "Nieuwste",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/no.ts

@@ -306,6 +306,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.description": "Modeller fra {{provider}} er ikke lenger tilgjengelige.",
 
   "model.tag.free": "Gratis",
+  "model.tag.variable": "Variabel",
   "model.tag.latest": "Nyeste",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/pa.ts

@@ -290,6 +290,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} منقطع",
   "provider.disconnect.toast.disconnected.description": "{{provider}} ماڈل ہن دستیاب نئیں ہن۔",
   "model.tag.free": "مفت",
+  "model.tag.variable": "بدلدی قیمت",
   "model.tag.latest": "تازہ ترین",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/pl.ts

@@ -292,6 +292,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "Rozłączono {{provider}}",
   "provider.disconnect.toast.disconnected.description": "Modele {{provider}} nie są już dostępne.",
   "model.tag.free": "Darmowy",
+  "model.tag.variable": "Zmienna cena",
   "model.tag.latest": "Najnowszy",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/ro.ts

@@ -283,6 +283,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} deconectat",
   "provider.disconnect.toast.disconnected.description": "Modelele {{provider}} nu mai sunt disponibile.",
   "model.tag.free": "Gratuit",
+  "model.tag.variable": "Preț variabil",
   "model.tag.latest": "Ultimul",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/ru.ts

@@ -306,6 +306,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} отключён",
   "provider.disconnect.toast.disconnected.description": "Модели {{provider}} больше недоступны.",
   "model.tag.free": "Бесплатно",
+  "model.tag.variable": "Цена меняется",
   "model.tag.latest": "Последняя",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/si.ts

@@ -283,6 +283,7 @@ export const dict: Record<string, string> = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} විසන්ධි විය",
   "provider.disconnect.toast.disconnected.description": "{{provider}} මාදිලි තවදුරටත් නොමැත.",
   "model.tag.free": "නොමිලේ",
+  "model.tag.variable": "විචල්‍ය",
   "model.tag.latest": "නවතම",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/sk.ts

@@ -283,6 +283,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} odpojený",
   "provider.disconnect.toast.disconnected.description": "Modely {{provider}} už nie sú dostupné.",
   "model.tag.free": "Bezplatné",
+  "model.tag.variable": "Premenlivá cena",
   "model.tag.latest": "Najnovšie",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/sl.ts

@@ -283,6 +283,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} prekinjen",
   "provider.disconnect.toast.disconnected.description": "Modeli {{provider}} niso več na voljo.",
   "model.tag.free": "Brezplačno",
+  "model.tag.variable": "Spremenljiva cena",
   "model.tag.latest": "Zadnje",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/sq.ts

@@ -284,6 +284,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} u shkëput",
   "provider.disconnect.toast.disconnected.description": "Modelet {{provider}} nuk janë më të disponueshme.",
   "model.tag.free": "Falas",
+  "model.tag.variable": "Çmim i ndryshueshëm",
   "model.tag.latest": "E fundit",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/sr.ts

@@ -284,6 +284,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} прекинут",
   "provider.disconnect.toast.disconnected.description": "{{provider}} модели више нису доступни.",
   "model.tag.free": "Бесплатно",
+  "model.tag.variable": "Променљива цена",
   "model.tag.latest": "Најновије",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/sv.ts

@@ -285,6 +285,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} frånkopplad",
   "provider.disconnect.toast.disconnected.description": "{{provider}}-modeller är inte längre tillgängliga.",
   "model.tag.free": "Gratis",
+  "model.tag.variable": "Varierande",
   "model.tag.latest": "Senaste",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/tg.ts

@@ -285,6 +285,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} ҷудо карда шудааст",
   "provider.disconnect.toast.disconnected.description": "{{provider}} моделҳо дигар дастрас нестанд.",
   "model.tag.free": "Озод",
+  "model.tag.variable": "Тағйирёбанда",
   "model.tag.latest": "Охирин",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/th.ts

@@ -305,6 +305,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.description": "โมเดล {{provider}} ไม่พร้อมใช้งานอีกต่อไป",
 
   "model.tag.free": "ฟรี",
+  "model.tag.variable": "ผันแปร",
   "model.tag.latest": "ล่าสุด",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/tk.ts

@@ -284,6 +284,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} kesildi",
   "provider.disconnect.toast.disconnected.description": "{{provider}} modelleri indi ýok.",
   "model.tag.free": "Mugt",
+  "model.tag.variable": "Üýtgeýän",
   "model.tag.latest": "Iň soňky",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/tr.ts

@@ -312,6 +312,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.description": "{{provider}} modelleri artık kullanılamıyor.",
 
   "model.tag.free": "Ücretsiz",
+  "model.tag.variable": "Değişken",
   "model.tag.latest": "En yeni",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/uk.ts

@@ -308,6 +308,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.description": "Моделі {{provider}} більше недоступні.",
 
   "model.tag.free": "Безкоштовно",
+  "model.tag.variable": "Змінна ціна",
   "model.tag.latest": "Остання",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/ur.ts

@@ -293,6 +293,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} منقطع ہو گیا۔",
   "provider.disconnect.toast.disconnected.description": "{{provider}} ماڈلز اب دستیاب نہیں ہیں۔",
   "model.tag.free": "مفت",
+  "model.tag.variable": "متغیر قیمت",
   "model.tag.latest": "تازہ ترین",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/uz.ts

@@ -286,6 +286,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} uzildi",
   "provider.disconnect.toast.disconnected.description": "{{provider}} modellari endi mavjud emas.",
   "model.tag.free": "Bepul",
+  "model.tag.variable": "O‘zgaruvchan",
   "model.tag.latest": "Oxirgi",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/vi.ts

@@ -291,6 +291,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} bị ngắt kết nối",
   "provider.disconnect.toast.disconnected.description": "Các mô hình {{provider}} không còn khả dụng.",
   "model.tag.free": "Miễn phí",
+  "model.tag.variable": "Giá thay đổi",
   "model.tag.latest": "Mới nhất",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/zh.ts

@@ -327,6 +327,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.description": "{{provider}} 模型已不再可用。",
 
   "model.tag.free": "免费",
+  "model.tag.variable": "浮动价格",
   "model.tag.latest": "最新",
   "model.provider.anthropic": "Anthropic",
   "model.provider.openai": "OpenAI",

packages/app/src/runtime/i18n/zht.ts

@@ -305,6 +305,7 @@ export const dict = {
   "provider.disconnect.toast.disconnected.title": "{{provider}} 已中斷連線",
   "provider.disconnect.toast.disconnected.description": "{{provider}} 模型已不再可用。",
   "model.tag.free": "免費",
+  "model.tag.variable": "浮動價格",
   "model.tag.latest": "最新",
 
   "model.provider.anthropic": "Anthropic",

packages/app/src/runtime/platform/web.ts

@@ -54,8 +54,12 @@ export function createWebPlatform(version: string) {
 
 function getCurrentServerUrl() {
   if (import.meta.env.VITE_OPENCODE_SERVER_MODE === "none") return undefined
-  if (import.meta.env.DEV)
-    return `http://${import.meta.env.VITE_OPENCODE_SERVER_HOST ?? "localhost"}:${import.meta.env.VITE_OPENCODE_SERVER_PORT ?? "4096"}`
+  if (import.meta.env.DEV) {
+    const loopback =
+      location.hostname === "localhost" || location.hostname === "[::1]" || location.hostname.startsWith("127.")
+    const host = import.meta.env.VITE_OPENCODE_SERVER_HOST ?? (loopback ? location.hostname : "localhost")
+    return `http://${host}:${import.meta.env.VITE_OPENCODE_SERVER_PORT ?? "4096"}`
+  }
   return location.origin
 }
 

packages/app/src/runtime/server/runtime.tsx

@@ -10,6 +10,7 @@ import { createData } from "@opencode/client/solid"
 import type { ServerScope } from "@/runtime/server/scope"
 import { createPermissionAutoApprover } from "@/session/requests/auto-approve"
 import { createServerNotificationState } from "@/shell/notifications/notification"
+import { createNotificationCoordinator } from "@/shell/notifications/coordinator"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import { createDesktopData } from "./data"
 import { ModelState } from "./persistence"
@@ -33,6 +34,7 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
       },
     })
     const models = createGlobalModels()
+    const notificationCoordinator = createNotificationCoordinator()
 
     const settingsServer = createMemo(() => {
       const list = server.list
@@ -57,7 +59,7 @@ export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext(
       if (existing) return existing
       const serverCtx = createRoot((dispose) => {
         serverCtxDisposers.set(key, dispose)
-        return createServerController(conn, server.scope(key), server.projects.forServer(key))
+        return createServerController(conn, server.scope(key), server.projects.forServer(key), notificationCoordinator)
       }, owner)
       serverCtxs.set(key, serverCtx)
       return serverCtx
@@ -131,6 +133,7 @@ function createServerController(
   conn: ServerConnection.Any,
   scope: ServerScope,
   projects: ReturnType<typeof createServerProjects>,
+  notificationCoordinator: ReturnType<typeof createNotificationCoordinator>,
 ) {
   const language = useLanguage()
   const settings = useSettings()
@@ -159,7 +162,7 @@ function createServerController(
   })
   const sync = createServerSyncContext(sdk, data)
   createPermissionAutoApprover({ sdk, data })
-  const notification = createServerNotificationState({ sdk, data, key: connKey })
+  const notification = createServerNotificationState({ sdk, data, key: connKey, coordinator: notificationCoordinator })
 
   function enrich(project: { worktree: string; expanded: boolean }) {
     const [childStore] = sync.child(project.worktree, { bootstrap: false })

packages/app/src/servers/ssh/dialog.stories.tsx

@@ -278,6 +278,7 @@ function Open(props: { initial?: string }) {
 export default { title: "App/Dialogs/SSH", id: "app-dialog-ssh" }
 export const AuthenticationRequired = { render: () => <Fixture initial="required" /> }
 export const SettingsReconnect = { render: () => <Fixture initial="required" settings connectionDelay={200} /> }
+export const IncompatibleHost = { render: () => <Fixture incompatible /> }
 export const IncompatibleSession = { render: () => <Fixture initial="required" session incompatible /> }
 export const InactiveSession = { render: () => <Fixture initial="required" session connectionDelay={3000} /> }
 export const KeyReconnect = { render: () => <Fixture initial="required" session keyOnly connectionDelay={3000} /> }

packages/app/src/servers/ssh/dialog.tsx

@@ -120,7 +120,13 @@ export function DialogSsh(props: {
       <Divider />
       <DialogBody class="flex w-full min-w-0 flex-1 flex-col px-4 pt-4 pb-2">
         <div class="flex w-full min-w-0 flex-col gap-6">
-          <Show when={!props.promptOnly && (!state.prompted || (!!error() && !prompt()))}>
+          <Show
+            when={
+              !props.promptOnly &&
+              item()?.stage !== "incompatible" &&
+              (!state.prompted || (!!error() && !prompt()))
+            }
+          >
             <div class="flex w-full min-w-0 flex-col gap-2">
               <label class="settings-server-dialog-label" for="ssh-target">
                 {language.t("ssh.target")}
@@ -160,6 +166,12 @@ export function DialogSsh(props: {
               />
             </div>
           </Show>
+          <Show when={item()?.stage === "incompatible"}>
+            <div class="flex w-full min-w-0 flex-col gap-2" role="status" aria-live="polite">
+              <span class="text-14-medium text-v2-text-text-base">{language.t("ssh.stage.incompatible")}</span>
+              <span class="text-13-regular text-v2-text-text-muted">{language.t("ssh.error.version")}</span>
+            </div>
+          </Show>
           <Show when={prompt()} keyed>
             {(prompt) => (
               <div class="flex w-full min-w-0 flex-col gap-2">
@@ -195,7 +207,7 @@ export function DialogSsh(props: {
               </div>
             )}
           </Show>
-          <Show when={error()}>
+          <Show when={item()?.stage !== "incompatible" && error()}>
             {(error) => (
               <span class="settings-server-dialog-error !leading-[var(--line-height-compact)]" role="alert">
                 {error()}

packages/app/src/session/files/session-file-browser-tab.tsx

@@ -1,6 +1,6 @@
 import { createMemo, createUniqueId, Show } from "solid-js"
 import { createStore } from "solid-js/store"
-import { createQuery } from "@tanstack/solid-query"
+import { createQuery, keepPreviousData } from "@tanstack/solid-query"
 import { Icon } from "@opencode/ui/icon"
 import { SessionFilePanelV2, SessionFilePanelV2Empty } from "@opencode/session-ui/v2/session-file-panel-v2"
 import { SessionReviewV2Sidebar } from "@opencode/session-ui/v2/session-review-v2"
@@ -56,6 +56,7 @@ export function SessionFileBrowserTab(props: {
       queryKey: [serverSDK.scope, "session-open-file", workspaceKey(), value] as const,
       enabled: serverSDK.connection.status() === "connected" && value.length > 0,
       queryFn: ({ signal }) => file.searchFiles(value, { limit: 200, signal }),
+      placeholderData: keepPreviousData,
     }
   })
   const files = createMemo(() => {

packages/app/src/shell/notifications/coordinator.ts

@@ -0,0 +1,93 @@
+import { onCleanup } from "solid-js"
+
+const FOCUS_LOCK = "opencode:notification-focus"
+const MAX_CLAIMED = 500
+
+export function createNotificationCoordinator() {
+  const locks = typeof navigator === "undefined" ? undefined : navigator.locks
+  const claimed = new Set<string>()
+  const focus = { pending: false, release: undefined as (() => void) | undefined }
+
+  const updateFocus = () => {
+    if (typeof document === "undefined" || !document.hasFocus()) {
+      focus.release?.()
+      return
+    }
+    if (!locks || focus.pending || focus.release) return
+
+    focus.pending = true
+    void locks
+      .request(FOCUS_LOCK, { mode: "shared" }, async () => {
+        focus.pending = false
+        if (!document.hasFocus()) return
+        await new Promise<void>((resolve) => {
+          focus.release = resolve
+        })
+        focus.release = undefined
+      })
+      .catch(() => {
+        focus.pending = false
+      })
+  }
+
+  if (typeof window !== "undefined") {
+    window.addEventListener("focus", updateFocus)
+    window.addEventListener("blur", updateFocus)
+    document.addEventListener("visibilitychange", updateFocus)
+    updateFocus()
+    onCleanup(() => {
+      window.removeEventListener("focus", updateFocus)
+      window.removeEventListener("blur", updateFocus)
+      document.removeEventListener("visibilitychange", updateFocus)
+      focus.release?.()
+    })
+  }
+
+  const once = async (kind: "sound" | "system", eventID: string, run: () => Promise<unknown> | void) => {
+    const key = `${kind}:${eventID}`
+    const execute = async () => {
+      if (!claim(kind, key, claimed)) return
+      await run()
+    }
+    if (!locks) return execute()
+    await locks.request(`opencode:notification:${key}`, execute)
+  }
+
+  return {
+    sound(eventID: string, run: () => Promise<unknown> | void) {
+      return once("sound", eventID, run)
+    },
+    system(eventID: string, run: () => Promise<unknown> | void) {
+      return once("system", eventID, async () => {
+        if (typeof document !== "undefined" && document.hasFocus()) return
+        if (!locks) return run()
+        await locks.request(FOCUS_LOCK, { mode: "exclusive", ifAvailable: true }, async (lock) => {
+          if (!lock) return
+          await run()
+        })
+      })
+    },
+  }
+}
+
+function claim(kind: "sound" | "system", eventID: string, claimed: Set<string>) {
+  if (claimed.has(eventID)) return false
+
+  if (typeof localStorage !== "undefined") {
+    try {
+      const storageKey = `opencode:notification-${kind}`
+      const value: unknown = JSON.parse(localStorage.getItem(storageKey) ?? "[]")
+      const events = Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
+      if (events.includes(eventID)) {
+        claimed.add(eventID)
+        return false
+      }
+      localStorage.setItem(storageKey, JSON.stringify([...events, eventID].slice(-MAX_CLAIMED)))
+    } catch {
+      // The in-memory claim still prevents duplicates in this renderer when storage is unavailable.
+    }
+  }
+
+  claimed.add(eventID)
+  return true
+}

packages/app/src/shell/notifications/notification.tsx

@@ -11,7 +11,8 @@ import { useSettings } from "@/settings/model"
 import { decode64 } from "@/runtime/persistence/base64"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import { Persistence } from "@/runtime/persistence/schema"
-import { playSoundByIdOnce } from "@/shell/notifications/sound"
+import { playSoundById } from "@/shell/notifications/sound"
+import type { createNotificationCoordinator } from "@/shell/notifications/coordinator"
 import { useGlobal } from "@/runtime/server/runtime"
 import { ServerConnection, useServers } from "@/runtime/server/registry"
 import { sessionIDHasOpenTab, useTabs } from "@/shell/tabs/tabs"
@@ -114,7 +115,12 @@ function buildNotificationIndex(list: Notification[]) {
   return index
 }
 
-export function createServerNotificationState(input: { sdk: ServerSDK; data: Data; key: ServerConnection.Key }) {
+export function createServerNotificationState(input: {
+  sdk: ServerSDK
+  data: Data
+  key: ServerConnection.Key
+  coordinator: ReturnType<typeof createNotificationCoordinator>
+}) {
   const platform = usePlatform()
   const settings = useSettings()
   const language = useLanguage()
@@ -223,7 +229,7 @@ export function createServerNotificationState(input: { sdk: ServerSDK; data: Dat
       if (session.parentID) return
 
       if (sessionIDHasOpenTab(tabs.store, input.key, sessionID) && settings.sounds.agentEnabled()) {
-        void playSoundByIdOnce(settings.sounds.agent(), `${input.key}\0${eventID}`)
+        void input.coordinator.sound(`${input.key}\0${eventID}`, () => playSoundById(settings.sounds.agent()))
       }
 
       append({
@@ -235,8 +241,10 @@ export function createServerNotificationState(input: { sdk: ServerSDK; data: Dat
       })
 
       if (settings.notifications.agent()) {
-        void platform.notify(language.t("notification.session.responseReady.title"), session.title ?? sessionID, () =>
-          openNotificationSession(tabs, input.key, sessionID),
+        void input.coordinator.system(`${input.key}\0${eventID}`, () =>
+          platform.notify(language.t("notification.session.responseReady.title"), session.title ?? sessionID, () =>
+            openNotificationSession(tabs, input.key, sessionID),
+          ),
         )
       }
     })
@@ -248,7 +256,7 @@ export function createServerNotificationState(input: { sdk: ServerSDK; data: Dat
       if (session?.parentID) return
 
       if (sessionIDHasOpenTab(tabs.store, input.key, sessionID) && settings.sounds.errorsEnabled()) {
-        void playSoundByIdOnce(settings.sounds.errors(), `${input.key}\0${eventID}`)
+        void input.coordinator.sound(`${input.key}\0${eventID}`, () => playSoundById(settings.sounds.errors()))
       }
 
       append({
@@ -263,8 +271,10 @@ export function createServerNotificationState(input: { sdk: ServerSDK; data: Dat
         session?.title ??
         (typeof error === "string" ? error : language.t("notification.session.error.fallbackDescription"))
       if (settings.notifications.errors()) {
-        void platform.notify(language.t("notification.session.error.title"), description, () =>
-          openNotificationSession(tabs, input.key, sessionID),
+        void input.coordinator.system(`${input.key}\0${eventID}`, () =>
+          platform.notify(language.t("notification.session.error.title"), description, () =>
+            openNotificationSession(tabs, input.key, sessionID),
+          ),
         )
       }
     })

packages/app/src/shell/notifications/sound.ts

@@ -74,9 +74,6 @@ function getLoads() {
 }
 
 const cache = new Map<SoundID, Promise<string | undefined>>()
-const claimed = new Set<string>()
-const CLAIMED_STORAGE_KEY = "opencode:notification-sounds"
-const MAX_CLAIMED = 500
 
 export function soundSrc(id: string | undefined) {
   const loads = getLoads()
@@ -103,34 +100,3 @@ export function playSound(src: string | undefined) {
 export function playSoundById(id: string | undefined) {
   return soundSrc(id).then((src) => playSound(src))
 }
-
-export async function playSoundByIdOnce(id: string | undefined, eventID: string) {
-  const play = async () => {
-    if (!claim(eventID)) return
-    await playSoundById(id)
-  }
-
-  if (typeof navigator === "undefined" || !navigator.locks) return play()
-  await navigator.locks.request(`${CLAIMED_STORAGE_KEY}:${eventID}`, play)
-}
-
-function claim(eventID: string) {
-  if (claimed.has(eventID)) return false
-
-  if (typeof localStorage !== "undefined") {
-    try {
-      const value: unknown = JSON.parse(localStorage.getItem(CLAIMED_STORAGE_KEY) ?? "[]")
-      const events = Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : []
-      if (events.includes(eventID)) {
-        claimed.add(eventID)
-        return false
-      }
-      localStorage.setItem(CLAIMED_STORAGE_KEY, JSON.stringify([...events, eventID].slice(-MAX_CLAIMED)))
-    } catch {
-      // The in-memory claim still prevents duplicates in this renderer when storage is unavailable.
-    }
-  }
-
-  claimed.add(eventID)
-  return true
-}