fix(core): await initial Copilot model sync

2026-07-24 03:36:10 +00:00 · 2026-07-22 00:47:24 +00:00
323 changed files with 4301 additions and 9655 deletions
@@ -97,11 +97,6 @@ jobs:
        working-directory: packages/client
        run: bun run check:generated

-      - name: Check generated documentation
-        if: runner.os == 'Linux'
-        working-directory: packages/docs
-        run: bun run check:generated
-
  e2e:
    name: e2e (${{ matrix.settings.name }})
    if: github.ref_name != 'v2' && github.head_ref != 'v2'
@@ -124,7 +124,7 @@
        "opencode2": "./bin/opencode2.cjs",
      },
      "dependencies": {
-        "@agentclientprotocol/sdk": "1.2.1",
+        "@agentclientprotocol/sdk": "0.21.0",
        "@effect/platform-node": "catalog:",
        "@opencode-ai/client": "workspace:*",
        "@opencode-ai/plugin": "workspace:*",
@@ -1173,7 +1173,7 @@

    "@adobe/css-tools": ["@adobe/css-tools@4.5.0", "", {}, "sha512-6OzddxPio9UiWTCemp4N8cYLV2ZN1ncRnV1cVGtve7dhPOtRkleRyx32GQCYSwDYgaHU3USMm84tNsvKzRCa1Q=="],

-    "@agentclientprotocol/sdk": ["@agentclientprotocol/sdk@1.2.1", "", { "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" } }, "sha512-jwYUdOQR7tc+Zfch53VL4JJyUNK/46q03uUTYb+PjECsmnNl94XFXOfYLJ8RBpMNidXd1rpOAVgb0vqD98xImA=="],
+    "@agentclientprotocol/sdk": ["@agentclientprotocol/sdk@0.21.0", "", { "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" } }, "sha512-ONj+Q8qOdNQp5XbH5jnMwzT9IKZJsSN0p0lkceS4GtUtNOPVLpNzSS8gqQdGMKfBvA0ESbkL8BTaSN1Rc9miEw=="],

    "@ai-sdk/alibaba": ["@ai-sdk/alibaba@1.0.17", "", { "dependencies": { "@ai-sdk/openai-compatible": "2.0.41", "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.23" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-ZbE+U5bWz2JBc5DERLowx5+TKbjGBE93LqKZAWvuEn7HOSQMraxFMZuc0ST335QZJAyfBOzh7m1mPQ+y7EaaoA=="],

@@ -27,7 +27,6 @@ import { ToolSchemaProjection } from "./utils/tool-schema"
 import { ToolStream } from "./utils/tool-stream"

 const ADAPTER = "anthropic-messages"
-const MEDIA_MIMES = new Set<string>([...ProviderShared.IMAGE_MIMES, ...ProviderShared.PDF_MIMES])
 export const DEFAULT_BASE_URL = "https://api.anthropic.com/v1"
 export const PATH = "/messages"

@@ -57,17 +56,6 @@ const AnthropicImageBlock = Schema.Struct({
 })
 type AnthropicImageBlock = Schema.Schema.Type<typeof AnthropicImageBlock>

-const AnthropicDocumentBlock = Schema.Struct({
-  type: Schema.tag("document"),
-  source: Schema.Struct({
-    type: Schema.tag("base64"),
-    media_type: Schema.Literal("application/pdf"),
-    data: Schema.String,
-  }),
-  cache_control: Schema.optional(AnthropicCacheControl),
-})
-type AnthropicDocumentBlock = Schema.Schema.Type<typeof AnthropicDocumentBlock>
-
 const AnthropicThinkingBlock = Schema.Struct({
  type: Schema.tag("thinking"),
  thinking: Schema.String,
@@ -113,10 +101,13 @@ const AnthropicServerToolResultBlock = Schema.Struct({
 })
 type AnthropicServerToolResultBlock = Schema.Schema.Type<typeof AnthropicServerToolResultBlock>

-// Anthropic accepts either a plain string or an ordered array of text, image, and
-// document blocks inside `tool_result.content`. The array form keeps media as native
-// model input instead of JSON-stringifying base64 into prompt text.
-const AnthropicToolResultContent = Schema.Union([AnthropicTextBlock, AnthropicImageBlock, AnthropicDocumentBlock])
+// Anthropic accepts either a plain string or an ordered array of text/image
+// blocks inside `tool_result.content`. The array form is required when a tool
+// returns image bytes (screenshot, image search, etc.) so they can be passed
+// to the model as proper image inputs instead of being JSON-stringified into
+// the prompt — which silently inflates context by megabytes and can push the
+// conversation over the model's token limit.
+const AnthropicToolResultContent = Schema.Union([AnthropicTextBlock, AnthropicImageBlock])

 const AnthropicToolResultBlock = Schema.Struct({
  type: Schema.tag("tool_result"),
@@ -126,12 +117,7 @@ const AnthropicToolResultBlock = Schema.Struct({
  cache_control: Schema.optional(AnthropicCacheControl),
 })

-const AnthropicUserBlock = Schema.Union([
-  AnthropicTextBlock,
-  AnthropicImageBlock,
-  AnthropicDocumentBlock,
-  AnthropicToolResultBlock,
-])
+const AnthropicUserBlock = Schema.Union([AnthropicTextBlock, AnthropicImageBlock, AnthropicToolResultBlock])
 type AnthropicUserBlock = Schema.Schema.Type<typeof AnthropicUserBlock>
 const AnthropicAssistantBlock = Schema.Union([
  AnthropicTextBlock,
@@ -333,17 +319,12 @@ const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult
  return { type: wireType, tool_use_id: part.id, content: part.result.value } satisfies AnthropicServerToolResultBlock
 })

-const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part: MediaPart) {
-  const media = yield* ProviderShared.validateMedia("Anthropic Messages", part, MEDIA_MIMES)
-  if (media.mime === "application/pdf")
-    return {
-      type: "document" as const,
-      source: {
-        type: "base64" as const,
-        media_type: "application/pdf" as const,
-        data: media.base64,
-      },
-    } satisfies AnthropicDocumentBlock
+const lowerImage = Effect.fn("AnthropicMessages.lowerImage")(function* (part: MediaPart) {
+  const media = yield* ProviderShared.validateMedia(
+    "Anthropic Messages",
+    part,
+    new Set<string>(ProviderShared.IMAGE_MIMES),
+  )
  return {
    type: "image" as const,
    source: {
@@ -354,13 +335,25 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part: Me
  } satisfies AnthropicImageBlock
 })

-// Tool results may carry structured text, images, and documents. Keep media as provider-native
+// Tool results may carry structured text/images. Keep media as provider-native
 // content instead of JSON-stringifying base64 into a prompt string.
 const lowerToolResultContentItem = Effect.fn("AnthropicMessages.lowerToolResultContentItem")(function* (
  item: ToolContent,
 ) {
  if (item.type === "text") return { type: "text" as const, text: item.text } satisfies AnthropicTextBlock
-  return yield* lowerMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name })
+  const media = yield* ProviderShared.validateToolFile(
+    "Anthropic Messages",
+    item,
+    new Set<string>(ProviderShared.IMAGE_MIMES),
+  )
+  return {
+    type: "image" as const,
+    source: {
+      type: "base64" as const,
+      media_type: media.mime,
+      data: media.base64,
+    },
+  } satisfies AnthropicImageBlock
 })

 const lowerToolResultContent = Effect.fn("AnthropicMessages.lowerToolResultContent")(function* (part: ToolResultPart) {
@@ -452,7 +445,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
          continue
        }
        if (part.type === "media") {
-          content.push(yield* lowerMedia(part))
+          content.push(yield* lowerImage(part))
          continue
        }
        return yield* ProviderShared.unsupportedContent("Anthropic Messages", "user", ["text", "media"])
@@ -52,7 +52,6 @@ const BedrockToolResultContentItem = Schema.Union([
  Schema.Struct({ text: Schema.String }),
  Schema.Struct({ json: Schema.Unknown }),
  BedrockMedia.ImageBlock,
-  BedrockMedia.DocumentBlock,
 ])

 const BedrockToolResultBlock = Schema.Struct({
@@ -284,6 +283,8 @@ const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent
      data: item.uri,
      filename: item.name,
    })
+    if (!("image" in media))
+      return yield* ProviderShared.invalidRequest("Bedrock Converse only supports image media in tool results")
    content.push(media)
  }
  return content
@@ -436,22 +437,21 @@ const mapFinishReason = (reason: string): FinishReason => {
  return "unknown"
 }

-// AWS reports inputTokens separately from cache reads and writes.
-// Bedrock does not break reasoning out of outputTokens for current models.
+// AWS Bedrock Converse reports `inputTokens` (inclusive total) with
+// `cacheReadInputTokens` and `cacheWriteInputTokens` as subsets. Pass
+// the total through and derive the non-cached breakdown. Bedrock does
+// not break reasoning out of `outputTokens` for any current model.
 const mapUsage = (usage: BedrockUsageSchema | undefined): Usage | undefined => {
  if (!usage) return undefined
-  const inputTokens = ProviderShared.sumTokens(
-    usage.inputTokens,
-    usage.cacheReadInputTokens,
-    usage.cacheWriteInputTokens,
-  )
+  const cacheTotal = (usage.cacheReadInputTokens ?? 0) + (usage.cacheWriteInputTokens ?? 0)
+  const nonCached = ProviderShared.subtractTokens(usage.inputTokens, cacheTotal)
  return new Usage({
-    inputTokens,
+    inputTokens: usage.inputTokens,
    outputTokens: usage.outputTokens,
-    nonCachedInputTokens: usage.inputTokens,
+    nonCachedInputTokens: nonCached,
    cacheReadInputTokens: usage.cacheReadInputTokens,
    cacheWriteInputTokens: usage.cacheWriteInputTokens,
-    totalTokens: ProviderShared.totalTokens(inputTokens, usage.outputTokens, usage.totalTokens),
+    totalTokens: ProviderShared.totalTokens(usage.inputTokens, usage.outputTokens, usage.totalTokens),
    providerMetadata: { bedrock: usage },
  })
 }
@@ -41,11 +41,9 @@ const GeminiInlineDataPart = Schema.Struct({
    data: Schema.String,
  }),
 })
-type GeminiInlineDataPart = Schema.Schema.Type<typeof GeminiInlineDataPart>

 const GeminiFunctionCallPart = Schema.Struct({
  functionCall: Schema.Struct({
-    id: Schema.optional(Schema.String),
    name: Schema.String,
    args: Schema.Unknown,
  }),
@@ -54,10 +52,8 @@ const GeminiFunctionCallPart = Schema.Struct({

 const GeminiFunctionResponsePart = Schema.Struct({
  functionResponse: Schema.Struct({
-    id: Schema.optional(Schema.String),
    name: Schema.String,
    response: Schema.Unknown,
-    parts: Schema.optional(Schema.Array(GeminiInlineDataPart)),
  }),
 })

@@ -201,13 +197,8 @@ const thoughtSignature = (providerMetadata: ProviderMetadata | undefined) => {
    : undefined
 }

-const functionCallId = (providerMetadata: ProviderMetadata | undefined) => {
-  const google = providerMetadata?.google
-  return ProviderShared.isRecord(google) && typeof google.functionCallId === "string" ? google.functionCallId : undefined
-}
-
 const lowerToolCall = (part: ToolCallPart) => ({
-  functionCall: { id: functionCallId(part.providerMetadata), name: part.name, args: part.input },
+  functionCall: { name: part.name, args: part.input },
  thoughtSignature: thoughtSignature(part.providerMetadata),
 })

@@ -264,7 +255,6 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
      if (part.result.type !== "content") {
        parts.push({
          functionResponse: {
-            id: functionCallId(part.providerMetadata),
            name: part.name,
            response: {
              name: part.name,
@@ -276,23 +266,20 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
      }
      const content: ReadonlyArray<ToolContent> = part.result.value
      const text = content.filter((item) => item.type === "text").map((item) => item.text)
-      const media: GeminiInlineDataPart[] = []
-      for (const item of content) {
-        if (item.type === "text") continue
-        const value = yield* ProviderShared.validateToolFile("Gemini", item, MEDIA_MIMES)
-        media.push({ inlineData: { mimeType: value.mime, data: value.base64 } })
-      }
      parts.push({
        functionResponse: {
-          id: functionCallId(part.providerMetadata),
          name: part.name,
          response: {
            name: part.name,
            content: text.join("\n"),
          },
-          parts: media.length > 0 ? media : undefined,
        },
      })
+      for (const item of content) {
+        if (item.type === "text") continue
+        const media = yield* ProviderShared.validateToolFile("Gemini", item, MEDIA_MIMES)
+        parts.push({ inlineData: { mimeType: media.mime, data: media.base64 } })
+      }
    }
    contents.push({ role: "user", parts })
  }
@@ -454,10 +441,6 @@ const step = (state: ParserState, event: GeminiEvent) => {
    if ("functionCall" in part) {
      const input = part.functionCall.args
      const id = `tool_${nextToolCallId++}`
-      const metadata = {
-        ...(part.functionCall.id === undefined ? {} : { functionCallId: part.functionCall.id }),
-        ...(part.thoughtSignature === undefined ? {} : { thoughtSignature: part.thoughtSignature }),
-      }
      lifecycle = Lifecycle.reasoningEnd(
        lifecycle,
        events,
@@ -470,7 +453,9 @@ const step = (state: ParserState, event: GeminiEvent) => {
          id,
          name: part.functionCall.name,
          input,
-          providerMetadata: Object.keys(metadata).length > 0 ? googleMetadata(metadata) : undefined,
+          providerMetadata: part.thoughtSignature
+            ? googleMetadata({ thoughtSignature: part.thoughtSignature })
+            : undefined,
        }),
      )
      hasToolCalls = true
@@ -25,7 +25,6 @@ import { ToolStream } from "./utils/tool-stream"

 const ADAPTER = "openai-chat"
 const IMAGE_MIMES = new Set<string>(ProviderShared.IMAGE_MIMES)
-const RESERVED_REASONING_FIELDS = new Set(["role", "content", "tool_calls"])
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = "/chat/completions"

@@ -71,18 +70,15 @@ const OpenAIChatMessage = Schema.Union([
    role: Schema.Literal("user"),
    content: Schema.Union([Schema.String, Schema.Array(OpenAIChatUserContent)]),
  }),
-  Schema.StructWithRest(
-    Schema.Struct({
-      role: Schema.Literal("assistant"),
-      content: Schema.NullOr(Schema.String),
-      tool_calls: optionalArray(OpenAIChatAssistantToolCall),
-      reasoning_content: Schema.optional(Schema.String),
-      reasoning: Schema.optional(Schema.String),
-      reasoning_text: Schema.optional(Schema.String),
-      reasoning_details: Schema.optional(Schema.Unknown),
-    }),
-    [Schema.Record(Schema.String, Schema.Unknown)],
-  ),
+  Schema.Struct({
+    role: Schema.Literal("assistant"),
+    content: Schema.NullOr(Schema.String),
+    tool_calls: optionalArray(OpenAIChatAssistantToolCall),
+    reasoning_content: Schema.optional(Schema.String),
+    reasoning: Schema.optional(Schema.String),
+    reasoning_text: Schema.optional(Schema.String),
+    reasoning_details: optionalArray(Schema.Unknown),
+  }),
  Schema.Struct({ role: Schema.Literal("tool"), tool_call_id: Schema.String, content: Schema.String }),
 ]).pipe(Schema.toTaggedUnion("role"))
 type OpenAIChatMessage = Schema.Schema.Type<typeof OpenAIChatMessage>
@@ -149,17 +145,14 @@ const OpenAIChatToolCallDelta = Schema.Struct({
 })
 type OpenAIChatToolCallDelta = Schema.Schema.Type<typeof OpenAIChatToolCallDelta>

-const OpenAIChatDelta = Schema.StructWithRest(
-  Schema.Struct({
-    content: optionalNull(Schema.String),
-    reasoning_content: optionalNull(Schema.String),
-    reasoning: optionalNull(Schema.String),
-    reasoning_text: optionalNull(Schema.String),
-    reasoning_details: optionalNull(Schema.Unknown),
-    tool_calls: optionalNull(Schema.Array(OpenAIChatToolCallDelta)),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
+const OpenAIChatDelta = Schema.Struct({
+  content: optionalNull(Schema.String),
+  reasoning_content: optionalNull(Schema.String),
+  reasoning: optionalNull(Schema.String),
+  reasoning_text: optionalNull(Schema.String),
+  reasoning_details: optionalNull(Schema.Array(Schema.Unknown)),
+  tool_calls: optionalNull(Schema.Array(OpenAIChatToolCallDelta)),
+})

 const OpenAIChatChoice = Schema.Struct({
  delta: optionalNull(OpenAIChatDelta),
@@ -186,7 +179,7 @@ export interface ParserState {
  readonly usage?: Usage
  readonly finishReason?: FinishReason
  readonly lifecycle: Lifecycle.State
-  readonly reasoningField?: string
+  readonly reasoningField?: "reasoning" | "reasoning_content" | "reasoning_text"
  readonly reasoningDetails: Array<unknown>
  readonly reasoningDetailsObserved: boolean
  readonly reasoningEmitted: boolean
@@ -234,7 +227,7 @@ const openAICompatibleReasoningContent = (native: unknown) =>

 const reasoningField = (part: ReasoningPart) => {
  const field = part.providerMetadata?.openai?.reasoningField
-  return typeof field === "string" ? field : undefined
+  if (field === "reasoning" || field === "reasoning_content" || field === "reasoning_text") return field
 }

 const reasoningDetails = (parts: ReadonlyArray<ReasoningPart>, native: unknown) => {
@@ -266,7 +259,6 @@ const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (mes

 const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(function* (
  message: OpenAIChatRequestMessage,
-  configuredField?: string,
 ) {
  const content: TextPart[] = []
  const reasoning: ReasoningPart[] = []
@@ -293,25 +285,24 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
  const nativeReasoning = openAICompatibleReasoningContent(message.native?.openaiCompatible)
  const fullyStructured = reasoning.every((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails))
  const field = (() => {
-    if (configuredField !== undefined) return configuredField
-    if (reasoning.length === 0) return undefined
+    if (reasoning.length === 0) return
    if (observedField !== undefined) return observedField
    if (nativeReasoning !== undefined) return "reasoning_content"
    if (!fullyStructured) return "reasoning_content"
  })()
-  const reasoningText = (() => {
-    if (configuredField !== undefined) return reasoning.length === 0 ? (nativeReasoning ?? "") : text
+  const reasoningContent = (() => {
    if (reasoning.length === 0) return nativeReasoning
-    return text
+    if (field === "reasoning_content") return text
  })()
-  const result = {
+  return {
    role: "assistant" as const,
    content: content.length === 0 ? null : ProviderShared.joinText(content),
    tool_calls: toolCalls.length === 0 ? undefined : toolCalls,
+    reasoning_content: reasoningContent,
+    reasoning: reasoning.length > 0 && field === "reasoning" ? text : undefined,
+    reasoning_text: reasoning.length > 0 && field === "reasoning_text" ? text : undefined,
    reasoning_details: details,
  }
-  if (field === undefined || reasoningText === undefined) return result
-  return { ...result, [field]: reasoningText }
 })

 const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (message: OpenAIChatRequestMessage) {
@@ -337,12 +328,9 @@ const lowerToolMessages = Effect.fn("OpenAIChat.lowerToolMessages")(function* (m
  return { messages, images }
 })

-const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (
-  message: OpenAIChatRequestMessage,
-  reasoningField?: string,
-) {
+const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (message: OpenAIChatRequestMessage) {
  if (message.role === "user") return [yield* lowerUserMessage(message)]
-  if (message.role === "assistant") return [yield* lowerAssistantMessage(message, reasoningField)]
+  if (message.role === "assistant") return [yield* lowerAssistantMessage(message)]
  return (yield* lowerToolMessages(message)).messages
 })

@@ -380,7 +368,7 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
      continue
    }
    flushImages()
-    messages.push(...(yield* lowerMessage(message, request.model.compatibility?.reasoningField)))
+    messages.push(...(yield* lowerMessage(message)))
  }
  flushImages()
  return messages
@@ -398,11 +386,6 @@ const lowerOptions = Effect.fn("OpenAIChat.lowerOptions")(function* (request: LL
 const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (request: LLMRequest) {
  // `fromRequest` returns the provider body only. Endpoint, auth, framing,
  // validation, and HTTP execution are composed by `Route.make`.
-  const reasoningField = request.model.compatibility?.reasoningField
-  if (reasoningField && RESERVED_REASONING_FIELDS.has(reasoningField))
-    return yield* ProviderShared.invalidRequest(
-      `OpenAI Chat reasoning field conflicts with reserved field ${reasoningField}`,
-    )
  const generation = request.generation
  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
  return {
@@ -463,18 +446,10 @@ const mapUsage = (usage: OpenAIChatEvent["usage"]): Usage | undefined => {
  })
 }

-const reasoningDelta = (
-  delta: Schema.Schema.Type<typeof OpenAIChatDelta> | null | undefined,
-  configuredField?: string,
-) => {
-  if (!delta) return undefined
-  const fields = new Set([configuredField, "reasoning_content", "reasoning", "reasoning_text"])
-  for (const field of fields) {
-    if (field === undefined) continue
-    const text = delta[field]
-    if (typeof text === "string" && text.length > 0) return { field, text }
-  }
-  return undefined
+const reasoningDelta = (delta: Schema.Schema.Type<typeof OpenAIChatDelta> | null | undefined) => {
+  if (delta?.reasoning_content) return { field: "reasoning_content", text: delta.reasoning_content } as const
+  if (delta?.reasoning) return { field: "reasoning", text: delta.reasoning } as const
+  if (delta?.reasoning_text) return { field: "reasoning_text", text: delta.reasoning_text } as const
 }

 const detailText = (details: ReadonlyArray<unknown>) => {
@@ -543,7 +518,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>

    let lifecycle = state.lifecycle

-    const reasoning = reasoningDelta(delta, state.reasoningField)
+    const reasoning = reasoningDelta(delta)
    const reasoningField = state.reasoningField ?? (!state.lifecycle.text.has("text-0") ? reasoning?.field : undefined)
    const detailDelta = Array.isArray(delta?.reasoning_details) ? delta.reasoning_details : undefined
    if (detailDelta !== undefined) appendReasoningDetails(state.reasoningDetails, detailDelta)
@@ -660,12 +635,12 @@ export const protocol = Protocol.make({
  },
  stream: {
    event: Protocol.jsonEvent(OpenAIChatEvent),
-    initial: (request) => ({
+    initial: () => ({
      tools: ToolStream.empty<number>(),
      pendingTools: {},
      toolCallEvents: [],
      lifecycle: Lifecycle.initial(),
-      reasoningField: request.model.compatibility?.reasoningField,
+      reasoningField: undefined,
      reasoningDetails: [],
      reasoningDetailsObserved: false,
      reasoningEmitted: false,
@@ -11,7 +11,6 @@ import {
  type FinishReason,
  type JsonSchema,
  type LLMRequest,
-  type MediaPart,
  type ProviderMetadata,
  type ReasoningPart,
  type TextPart,
@@ -29,7 +28,6 @@ import { ToolStream } from "./utils/tool-stream"
 import { OpenAIImage } from "./utils/openai-image"

 const ADAPTER = "openai-responses"
-const MEDIA_MIMES = new Set<string>([...ProviderShared.IMAGE_MIMES, ...ProviderShared.PDF_MIMES])
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = "/responses"

@@ -44,17 +42,7 @@ const OpenAIResponsesInputImage = Schema.Struct({
  type: Schema.tag("input_image"),
  image_url: Schema.String,
 })
-const OpenAIResponsesInputFile = Schema.Struct({
-  type: Schema.tag("input_file"),
-  filename: Schema.String,
-  file_data: Schema.String,
-  mime_type: Schema.optional(Schema.String),
-})
-const OpenAIResponsesInputContent = Schema.Union([
-  OpenAIResponsesInputText,
-  OpenAIResponsesInputImage,
-  OpenAIResponsesInputFile,
-])
+const OpenAIResponsesInputContent = Schema.Union([OpenAIResponsesInputText, OpenAIResponsesInputImage])
 type OpenAIResponsesInputContent = Schema.Schema.Type<typeof OpenAIResponsesInputContent>

 const OpenAIResponsesOutputText = Schema.Struct({
@@ -80,13 +68,9 @@ const OpenAIResponsesItemReference = Schema.Struct({
 })

 // `function_call_output.output` accepts either a plain string or an ordered
-// array of content items so tools can return images and files in addition to text.
+// array of content items so tools can return images in addition to text.
 // https://platform.openai.com/docs/api-reference/responses/object
-const OpenAIResponsesFunctionCallOutputContent = Schema.Union([
-  OpenAIResponsesInputText,
-  OpenAIResponsesInputImage,
-  OpenAIResponsesInputFile,
-])
+const OpenAIResponsesFunctionCallOutputContent = Schema.Union([OpenAIResponsesInputText, OpenAIResponsesInputImage])

 const OpenAIResponsesFunctionCallOutput = Schema.Union([
  Schema.String,
@@ -253,7 +237,7 @@ const OpenAIResponsesEvent = Schema.Struct({
      Schema.Struct({
        id: Schema.optional(Schema.String),
        service_tier: optionalNull(Schema.String),
-        incomplete_details: optionalNull(Schema.Struct({ reason: Schema.optional(Schema.String) })),
+        incomplete_details: optionalNull(Schema.Struct({ reason: Schema.String })),
        usage: optionalNull(OpenAIResponsesUsage),
        error: optionalNull(OpenAIResponsesErrorPayload),
      }),
@@ -359,58 +343,42 @@ const hostedToolItemID = (part: ToolResultPart) => {
    : undefined
 }

-const lowerMedia = Effect.fn("OpenAIResponses.lowerMedia")(function* (part: MediaPart, provider: string) {
-  const media = yield* ProviderShared.validateMedia("OpenAI Responses", part, MEDIA_MIMES)
-  if (media.mime === "application/pdf") {
-    // xAI models inline bytes and MIME separately; OpenAI uses a data URL in file_data.
-    if (provider === "xai")
-      return {
-        type: "input_file" as const,
-        filename: part.filename ?? "document.pdf",
-        file_data: media.base64,
-        mime_type: media.mime,
-      }
-    return {
-      type: "input_file" as const,
-      filename: part.filename ?? "document.pdf",
-      file_data: media.dataUrl,
-    }
-  }
-  return { type: "input_image" as const, image_url: media.dataUrl }
-})
-
 const lowerUserContent = Effect.fn("OpenAIResponses.lowerUserContent")(function* (
  part: LLMRequest["messages"][number]["content"][number],
-  provider: string,
 ) {
  if (part.type === "text") return { type: "input_text" as const, text: part.text }
-  if (part.type === "media") return yield* lowerMedia(part, provider)
+  if (part.type === "media") {
+    const media = yield* ProviderShared.validateMedia(
+      "OpenAI Responses",
+      part,
+      new Set<string>(ProviderShared.IMAGE_MIMES),
+    )
+    return { type: "input_image" as const, image_url: media.dataUrl }
+  }
  return yield* ProviderShared.unsupportedContent("OpenAI Responses", "user", ["text", "media"])
 })

-// Tool results may carry structured text, images, and files. Keep media as provider-native
+// Tool results may carry structured text/images. Keep media as provider-native
 // content instead of JSON-stringifying base64 into a prompt string.
 const lowerToolResultContentItem = Effect.fn("OpenAIResponses.lowerToolResultContentItem")(function* (
  item: ToolContent,
-  provider: string,
 ) {
  if (item.type === "text") return { type: "input_text" as const, text: item.text }
-  return yield* lowerMedia(
-    { type: "media", mediaType: item.mime, data: item.uri, filename: item.name },
-    provider,
+  const media = yield* ProviderShared.validateToolFile(
+    "OpenAI Responses",
+    item,
+    new Set<string>(ProviderShared.IMAGE_MIMES),
  )
+  return { type: "input_image" as const, image_url: media.dataUrl }
 })

-const lowerToolResultOutput = Effect.fn("OpenAIResponses.lowerToolResultOutput")(function* (
-  part: ToolResultPart,
-  provider: string,
-) {
+const lowerToolResultOutput = Effect.fn("OpenAIResponses.lowerToolResultOutput")(function* (part: ToolResultPart) {
  // Text/json/error results are encoded as a plain string for backward
  // compatibility with existing cassettes and provider expectations.
  if (part.result.type !== "content") return ProviderShared.toolResultText(part)
  // Preserve the narrowed array element type when compiled through a consumer package.
  const content: ReadonlyArray<ToolContent> = part.result.value
-  return yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, provider))
+  return yield* Effect.forEach(content, lowerToolResultContentItem)
 })

 const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (request: LLMRequest) {
@@ -433,10 +401,7 @@ const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (requ
    }

    if (message.role === "user") {
-      input.push({
-        role: "user",
-        content: yield* Effect.forEach(message.content, (part) => lowerUserContent(part, request.model.provider)),
-      })
+      input.push({ role: "user", content: yield* Effect.forEach(message.content, lowerUserContent) })
      continue
    }

@@ -495,9 +460,7 @@ const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (requ
            const content: ReadonlyArray<ToolContent> = part.result.value
            input.push({
              role: "user",
-              content: yield* Effect.forEach(content, (item) =>
-                lowerToolResultContentItem(item, request.model.provider),
-              ),
+              content: yield* Effect.forEach(content, lowerToolResultContentItem),
            })
          }
          if (itemID) hostedToolReferences.add(itemID)
@@ -520,7 +483,7 @@ const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (requ
      input.push({
        type: "function_call_output",
        call_id: part.id,
-        output: yield* lowerToolResultOutput(part, request.model.provider),
+        output: yield* lowerToolResultOutput(part),
      })
    }
  }
@@ -602,8 +565,7 @@ const mapUsage = (usage: OpenAIResponsesUsage | null | undefined) => {

 const mapFinishReason = (event: OpenAIResponsesEvent, hasFunctionCall: boolean): FinishReason => {
  const reason = event.response?.incomplete_details?.reason
-  if (reason === undefined || reason === null)
-    return hasFunctionCall ? "tool-calls" : event.type === "response.incomplete" ? "unknown" : "stop"
+  if (reason === undefined || reason === null) return hasFunctionCall ? "tool-calls" : "stop"
  if (reason === "max_output_tokens") return "length"
  if (reason === "content_filter") return "content-filter"
  return hasFunctionCall ? "tool-calls" : "unknown"
@@ -158,8 +158,7 @@ export const parseToolInput = (route: string, name: string, raw: string) =>
 export const IMAGE_MIMES = ["image/png", "image/jpeg", "image/gif", "image/webp"] as const
 export const VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"] as const
 export const AUDIO_MIMES = ["audio/wav", "audio/mp3", "audio/aiff", "audio/aac", "audio/ogg", "audio/flac"] as const
-export const PDF_MIMES = ["application/pdf"] as const
-export const MEDIA_MIMES = [...IMAGE_MIMES, ...VIDEO_MIMES, ...AUDIO_MIMES, ...PDF_MIMES] as const
+export const MEDIA_MIMES = [...IMAGE_MIMES, ...VIDEO_MIMES, ...AUDIO_MIMES] as const
 export const MAX_MEDIA_ENCODED_BYTES = 28 * 1024 * 1024
 export const MAX_MEDIA_DECODED_BYTES = 20 * 1024 * 1024

@@ -49,10 +49,10 @@ const DOCUMENT_FORMATS = {
  "text/markdown": "md",
 } as const satisfies Record<string, DocumentFormat>

-const documentBlock = (name: string, format: DocumentFormat, bytes: string): DocumentBlock => ({
+const documentBlock = (part: MediaPart, format: DocumentFormat, bytes: string): DocumentBlock => ({
  document: {
    format,
-    name,
+    name: part.filename ?? `document.${format}`,
    source: { bytes },
  },
 })
@@ -77,14 +77,12 @@ export const lower = Effect.fn("BedrockMedia.lower")(function* (part: MediaPart)
    return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support image media type ${part.mediaType}`)
  const documentFormat = DOCUMENT_FORMATS[mime as keyof typeof DOCUMENT_FORMATS]
  if (documentFormat) {
-    if (!part.filename)
-      return yield* ProviderShared.invalidRequest("Bedrock Converse document media requires a filename")
    const media = yield* ProviderShared.validateMedia(
      "Bedrock Converse",
      part,
      new Set<string>(Object.keys(DOCUMENT_FORMATS)),
    )
-    return documentBlock(part.filename, documentFormat, media.base64)
+    return documentBlock(part, documentFormat, media.base64)
  }
  return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support media type ${part.mediaType}`)
 })
@@ -34,12 +34,11 @@ import { ProviderFailureClassification } from "./errors"
 *
 * **Semantics by provider**:
 *
- * - OpenAI Chat / Responses / Gemini: provider reports inclusive
+ * - OpenAI Chat / Responses / Gemini / Bedrock: provider reports inclusive
 *   `inputTokens` and an inclusive `outputTokens`; mapper subtracts to
 *   derive the breakdown.
- * - Anthropic and Bedrock report the input breakdown natively: Anthropic's
- *   `input_tokens` and Bedrock's `inputTokens` are non-cached only. Their
- *   mappers sum the breakdown to derive the inclusive `inputTokens`.
+ * - Anthropic: provider reports the breakdown natively (`input_tokens` is
+ *   non-cached only); mapper sums to derive the inclusive `inputTokens`.
 *   Anthropic does *not* break extended-thinking out of `output_tokens`, so
 *   `reasoningTokens` is `undefined` and `outputTokens` carries the
 *   combined total — a documented limitation of the Anthropic API.
@@ -168,7 +168,6 @@ export type ModelToolSchemaCompatibility = Schema.Schema.Type<typeof ModelToolSc

 export class ModelCompatibility extends Schema.Class<ModelCompatibility>("LLM.ModelCompatibility")({
  toolSchema: Schema.optional(ModelToolSchemaCompatibility),
-  reasoningField: Schema.optional(Schema.String),
 }) {}

 export namespace ModelCompatibility {
@@ -68,29 +68,10 @@ const result = (call: ToolCallPart, value: ToolResultValueType | ToolSettlement,
    events:
      settlement.result.type === "error"
        ? [
-            LLMEvent.toolError({
-              id: call.id,
-              name: call.name,
-              message: String(settlement.result.value),
-              error,
-              providerMetadata: call.providerMetadata,
-            }),
-            LLMEvent.toolResult({
-              id: call.id,
-              name: call.name,
-              result: settlement.result,
-              providerMetadata: call.providerMetadata,
-            }),
+            LLMEvent.toolError({ id: call.id, name: call.name, message: String(settlement.result.value), error }),
+            LLMEvent.toolResult({ id: call.id, name: call.name, result: settlement.result }),
          ]
-        : [
-            LLMEvent.toolResult({
-              id: call.id,
-              name: call.name,
-              result: settlement.result,
-              output: settlement.output,
-              providerMetadata: call.providerMetadata,
-            }),
-          ],
+        : [LLMEvent.toolResult({ id: call.id, name: call.name, result: settlement.result, output: settlement.output })],
  }
 }

@@ -1,35 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:anthropic",
-      "protocol:anthropic-messages",
-      "tool",
-      "tool-result"
-    ],
-    "name": "pdf/anthropic-tool-result",
-    "recordedAt": "2026-07-22T18:15:39.002Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"claude-haiku-4-5-20251001\",\"system\":[{\"type\":\"text\",\"text\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"role\":\"assistant\",\"content\":[{\"type\":\"tool_use\",\"id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"input\":{}}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"call_pdf_1\",\"content\":[{\"type\":\"text\",\"text\":\"PDF read successfully\"},{\"type\":\"document\",\"source\":{\"type\":\"base64\",\"media_type\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}}]}]}],\"tools\":[{\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"input_schema\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false}}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"model\":\"claude-haiku-4-5-20251001\",\"id\":\"msg_011CdHYzxyRpSVFgwTm6ccUr\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"stop_reason\":null,\"stop_sequence\":null,\"stop_details\":null,\"usage\":{\"input_tokens\":2229,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"cache_creation\":{\"ephemeral_5m_input_tokens\":0,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":2,\"service_tier\":\"standard\",\"inference_geo\":\"not_available\"}}        }\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}              }\n\nevent: ping\ndata: {\"type\": \"ping\"}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"ORCH\"}  }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"ID-7391\"}           }\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0               }\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"stop_details\":null},\"usage\":{\"input_tokens\":2229,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":9}       }\n\nevent: message_stop\ndata: {\"type\":\"message_stop\" }\n\n"
-      }
-    }
-  ]
-}
@@ -1,34 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:anthropic",
-      "protocol:anthropic-messages",
-      "user-input"
-    ],
-    "name": "pdf/anthropic-user-input",
-    "recordedAt": "2026-07-22T18:15:37.979Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"claude-haiku-4-5-20251001\",\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"document\",\"source\":{\"type\":\"base64\",\"media_type\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}},{\"type\":\"text\",\"text\":\"Return only the verification code from the PDF.\"}]}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"model\":\"claude-haiku-4-5-20251001\",\"id\":\"msg_011CdHYzsayb45rgfamcjFt3\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"stop_reason\":null,\"stop_sequence\":null,\"stop_details\":null,\"usage\":{\"input_tokens\":1602,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"cache_creation\":{\"ephemeral_5m_input_tokens\":0,\"ephemeral_1h_input_tokens\":0},\"output_tokens\":2,\"service_tier\":\"standard\",\"inference_geo\":\"not_available\"}}           }\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}         }\n\nevent: ping\ndata: {\"type\": \"ping\"}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"ORCH\"}              }\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"ID-7391\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0      }\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\",\"stop_sequence\":null,\"stop_details\":null},\"usage\":{\"input_tokens\":1602,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":0,\"output_tokens\":9}    }\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"              }\n\n"
-      }
-    }
-  ]
-}
@@ -1,36 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:amazon-bedrock",
-      "protocol:bedrock-converse",
-      "tool",
-      "tool-result"
-    ],
-    "name": "pdf/bedrock-tool-result",
-    "recordedAt": "2026-07-22T18:15:52.400Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://bedrock-runtime.us-east-1.amazonaws.com/model/us.anthropic.claude-haiku-4-5-20251001-v1%3A0/converse-stream",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"modelId\":\"us.anthropic.claude-haiku-4-5-20251001-v1:0\",\"messages\":[{\"role\":\"user\",\"content\":[{\"text\":\"Return only the verification code from the PDF.\"}]},{\"role\":\"assistant\",\"content\":[{\"toolUse\":{\"toolUseId\":\"call_pdf_1\",\"name\":\"read_pdf\",\"input\":{}}}]},{\"role\":\"user\",\"content\":[{\"toolResult\":{\"toolUseId\":\"call_pdf_1\",\"content\":[{\"text\":\"PDF read successfully\"},{\"document\":{\"format\":\"pdf\",\"name\":\"verification\",\"source\":{\"bytes\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}}}],\"status\":\"success\"}}]}],\"system\":[{\"text\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"}],\"inferenceConfig\":{\"maxTokens\":40,\"temperature\":0},\"toolConfig\":{\"tools\":[{\"toolSpec\":{\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"inputSchema\":{\"json\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false}}}}]}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "application/vnd.amazon.eventstream"
-        },
-        "body": "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",
-        "bodyEncoding": "base64"
-      }
-    }
-  ]
-}
@@ -1,35 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:amazon-bedrock",
-      "protocol:bedrock-converse",
-      "user-input"
-    ],
-    "name": "pdf/bedrock-user-input",
-    "recordedAt": "2026-07-22T18:15:48.408Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://bedrock-runtime.us-east-1.amazonaws.com/model/us.anthropic.claude-haiku-4-5-20251001-v1%3A0/converse-stream",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"modelId\":\"us.anthropic.claude-haiku-4-5-20251001-v1:0\",\"messages\":[{\"role\":\"user\",\"content\":[{\"document\":{\"format\":\"pdf\",\"name\":\"verification\",\"source\":{\"bytes\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}}},{\"text\":\"Return only the verification code from the PDF.\"}]}],\"inferenceConfig\":{\"maxTokens\":40,\"temperature\":0}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "application/vnd.amazon.eventstream"
-        },
-        "body": "AAAAtgAAAFJ/wBIFCzpldmVudC10eXBlBwAMbWVzc2FnZVN0YXJ0DTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNCIsInJvbGUiOiJhc3Npc3RhbnQifURlAvAAAADGAAAAV/Z4BkULOmV2ZW50LXR5cGUHABFjb250ZW50QmxvY2tEZWx0YQ06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImNvbnRlbnRCbG9ja0luZGV4IjowLCJkZWx0YSI6eyJ0ZXh0IjoiT1JDSCJ9LCJwIjoiYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk8ifU1V/fQAAADWAAAAV5aYkccLOmV2ZW50LXR5cGUHABFjb250ZW50QmxvY2tEZWx0YQ06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7ImNvbnRlbnRCbG9ja0luZGV4IjowLCJkZWx0YSI6eyJ0ZXh0IjoiSUQtIn0sInAiOiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ekFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaMDEyMzQ1In1Rr1g8AAAAoAAAAFfgCoSoCzpldmVudC10eXBlBwARY29udGVudEJsb2NrRGVsdGENOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJjb250ZW50QmxvY2tJbmRleCI6MCwiZGVsdGEiOnsidGV4dCI6IjcifSwicCI6ImFiY2RlZiJ9UwQMPQAAAM8AAABX+2hkNAs6ZXZlbnQtdHlwZQcAEWNvbnRlbnRCbG9ja0RlbHRhDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsiY29udGVudEJsb2NrSW5kZXgiOjAsImRlbHRhIjp7InRleHQiOiIzOTEifSwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWSJ9ZmoyCwAAAJAAAABWNiwMuAs6ZXZlbnQtdHlwZQcAEGNvbnRlbnRCbG9ja1N0b3ANOmNvbnRlbnQtdHlwZQcAEGFwcGxpY2F0aW9uL2pzb24NOm1lc3NhZ2UtdHlwZQcABWV2ZW50eyJjb250ZW50QmxvY2tJbmRleCI6MCwicCI6ImFiY2RlZmdoaWprbCJ9wtmmXgAAAIgAAABR+NhFWAs6ZXZlbnQtdHlwZQcAC21lc3NhZ2VTdG9wDTpjb250ZW50LXR5cGUHABBhcHBsaWNhdGlvbi9qc29uDTptZXNzYWdlLXR5cGUHAAVldmVudHsicCI6ImFiY2RlZmciLCJzdG9wUmVhc29uIjoiZW5kX3R1cm4ifa8D/doAAADvAAAATl7C4/ALOmV2ZW50LXR5cGUHAAhtZXRhZGF0YQ06Y29udGVudC10eXBlBwAQYXBwbGljYXRpb24vanNvbg06bWVzc2FnZS10eXBlBwAFZXZlbnR7Im1ldHJpY3MiOnsibGF0ZW5jeU1zIjo0NTQ1fSwicCI6ImFiY2RlZmdoaWprbG1ub3BxcnN0dXYiLCJ1c2FnZSI6eyJpbnB1dFRva2VucyI6MTYxNCwib3V0cHV0VG9rZW5zIjo2LCJzZXJ2ZXJUb29sVXNhZ2UiOnt9LCJ0b3RhbFRva2VucyI6MTYyMH19db4j2Q==",
-        "bodyEncoding": "base64"
-      }
-    }
-  ]
-}
@@ -1,53 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:google",
-      "protocol:gemini",
-      "tool",
-      "tool-result"
-    ],
-    "name": "pdf/gemini-tool-result",
-    "recordedAt": "2026-07-22T18:21:59.606Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:streamGenerateContent?alt=sse",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"contents\":[{\"role\":\"user\",\"parts\":[{\"text\":\"Use read_pdf with path verification.pdf and return the verification code.\"}]}],\"systemInstruction\":{\"parts\":[{\"text\":\"Call read_pdf exactly once with path verification.pdf, then reply only with the verification code from its PDF.\"}]},\"tools\":[{\"functionDeclarations\":[{\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"parameters\":{\"required\":[\"path\"],\"type\":\"object\",\"properties\":{\"path\":{\"type\":\"string\"}}}}]}],\"generationConfig\":{\"maxOutputTokens\":256,\"temperature\":0}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"candidates\": [{\"content\": {\"parts\": [{\"functionCall\": {\"name\": \"read_pdf\",\"args\": {\"path\": \"verification.pdf\"},\"id\": \"58shgmez\"},\"thoughtSignature\": \"EqkCCqYCARFNMg/JrCTv5i3zYENFBVpZNFL3pbzJmi5Eu387ncF703xFMB4pwyaP7a1gi49EqBhCI2hWOpesU5nZQOLAhGgExKGa2GM+HzpEB5g62r0NFblm/BGkVZaImTuHR7bytfRC5jHQlHKo4OS27OLUVjvkMkBIYsvjhDErY7niERbXJVpyxTVqUf1GgZMSu8kC9/5WDlMs9xVKNT/6KMW4PhhSR9nXg4KZUa+bC03/ydhsWWgBa5aLCgvTq7WPj217xIsmUkSiRedIffPsUSNjYdMHUvWi8bOlvM1veEEP6GIfv5h9gXXzjnHbEHfQxV8PZuBAyY7iM6nqyfkJNdkZ1HdB7DXMBsMsRN6SgrIrFoXX2WaGrkoEI5tdZx1t/gdwF1jEVT6k\"}],\"role\": \"model\"},\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 81,\"candidatesTokenCount\": 18,\"totalTokenCount\": 151,\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 81}],\"thoughtsTokenCount\": 52,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"RAphaui3OaSHz7IPy8Kb4Ak\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"\"}],\"role\": \"model\"},\"finishReason\": \"STOP\",\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 81,\"candidatesTokenCount\": 18,\"totalTokenCount\": 151,\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 81}],\"thoughtsTokenCount\": 52,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"RAphaui3OaSHz7IPy8Kb4Ak\"}\r\n\r\n"
-      }
-    },
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:streamGenerateContent?alt=sse",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"contents\":[{\"role\":\"user\",\"parts\":[{\"text\":\"Use read_pdf with path verification.pdf and return the verification code.\"}]},{\"role\":\"model\",\"parts\":[{\"functionCall\":{\"id\":\"58shgmez\",\"name\":\"read_pdf\",\"args\":{\"path\":\"verification.pdf\"}},\"thoughtSignature\":\"EqkCCqYCARFNMg/JrCTv5i3zYENFBVpZNFL3pbzJmi5Eu387ncF703xFMB4pwyaP7a1gi49EqBhCI2hWOpesU5nZQOLAhGgExKGa2GM+HzpEB5g62r0NFblm/BGkVZaImTuHR7bytfRC5jHQlHKo4OS27OLUVjvkMkBIYsvjhDErY7niERbXJVpyxTVqUf1GgZMSu8kC9/5WDlMs9xVKNT/6KMW4PhhSR9nXg4KZUa+bC03/ydhsWWgBa5aLCgvTq7WPj217xIsmUkSiRedIffPsUSNjYdMHUvWi8bOlvM1veEEP6GIfv5h9gXXzjnHbEHfQxV8PZuBAyY7iM6nqyfkJNdkZ1HdB7DXMBsMsRN6SgrIrFoXX2WaGrkoEI5tdZx1t/gdwF1jEVT6k\"}]},{\"role\":\"user\",\"parts\":[{\"functionResponse\":{\"id\":\"58shgmez\",\"name\":\"read_pdf\",\"response\":{\"name\":\"read_pdf\",\"content\":\"PDF read successfully\"},\"parts\":[{\"inlineData\":{\"mimeType\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}}]}}]}],\"systemInstruction\":{\"parts\":[{\"text\":\"Call read_pdf exactly once with path verification.pdf, then reply only with the verification code from its PDF.\"}]},\"tools\":[{\"functionDeclarations\":[{\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"parameters\":{\"required\":[\"path\"],\"type\":\"object\",\"properties\":{\"path\":{\"type\":\"string\"}}}}]}],\"generationConfig\":{\"maxOutputTokens\":256,\"temperature\":0}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"ORCHID-7391\"}],\"role\": \"model\"},\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 123,\"candidatesTokenCount\": 8,\"totalTokenCount\": 184,\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 123}],\"thoughtsTokenCount\": 53,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"RgphaoL6CMjQz7IPjOnEmQI\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"\",\"thoughtSignature\": \"EqECCp4CARFNMg9obBl8O6iU9lawUIWiE+1vztZm9NtaT9FuyJz343hd9ruz+xPco4Q1DY1GF81ZiSI2ElBkt8Wfwsqtix9LNGSMvbZhhk/ZnB54t05M/Dft1kujcMvEdZUWUI/jWaJ349tO1bKVH9MacG5+gl0n4y8DwyQZSV3xIcet547drSkcA/TM03RB+yj1/dcLHsvUjmv9EnO897vZgO2Dk4tbZ2NyCtOeQ3JKVhUTLg2pjkGk+POCNiOdESWiUzxdQKw9LiV6nnzi071tXNiMeVimq6d7xAzRVNapI2uXynvn9Uk3eyn85purOFa8cKriK9oD6vcyGMqgd9+gu2m3to0IHqd7o+2YSr1m5qV1xT1R2/WRQEtb1b1AuOAU6w==\"}],\"role\": \"model\"},\"finishReason\": \"STOP\",\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 1277,\"candidatesTokenCount\": 8,\"totalTokenCount\": 1338,\"promptTokensDetails\": [{\"modality\": \"IMAGE\",\"tokenCount\": 1102},{\"modality\": \"TEXT\",\"tokenCount\": 175}],\"thoughtsTokenCount\": 53,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"RgphaoL6CMjQz7IPjOnEmQI\"}\r\n\r\n"
-      }
-    }
-  ]
-}
@@ -1,34 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:google",
-      "protocol:gemini",
-      "user-input"
-    ],
-    "name": "pdf/gemini-user-input",
-    "recordedAt": "2026-07-22T18:20:55.140Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:streamGenerateContent?alt=sse",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"contents\":[{\"role\":\"user\",\"parts\":[{\"inlineData\":{\"mimeType\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}},{\"text\":\"Return only the verification code from the PDF.\"}]}],\"generationConfig\":{\"maxOutputTokens\":256,\"temperature\":0}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": "data: {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"ORCH\"}],\"role\": \"model\"},\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 10,\"candidatesTokenCount\": 2,\"totalTokenCount\": 127,\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 10}],\"thoughtsTokenCount\": 115,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"BQpharW2KaPgz7IP6uSLiAw\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"ID-7391\"}],\"role\": \"model\"},\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 10,\"candidatesTokenCount\": 8,\"totalTokenCount\": 133,\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 10}],\"thoughtsTokenCount\": 115,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"BQpharW2KaPgz7IP6uSLiAw\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"\",\"thoughtSignature\": \"EokECoYEARFNMg8L4fpLqaX8tIQZcvw2vLt3WsFjGqpuJGgna0/AGczwuzndRcf3LGIEaliCf4ijVOb1AG4/VPBh1kMzfjeAyHhvWIe4yQVoBwI7BjpFyLie+SnGTXQXKKy5ygRqRLFsV6DcAixNXXBHJw2x/2Nhtriryqs4fhWrL/P7ppHC10sMnTwN6Mw5x20NKwgT+rrw6lvYmQe9rdQsBJ6Zmp0GpPlwZZiAgzvwPfVoNwHSGb54xe/T9wjISjwWNgpedhbsIBDRZFDwruS4x57KBKeMPO69GLfeMP8PJ7rpR0HgT7nRbrl/OdykG/jqSMTvoRSqxawsD+Yr/DukgGatyfB5Ic+X4RhD07URpkGTAu/cakBtzhSmM/hpzKU9m/cId1UCjopLTtonUqSAKkroPdp8kIYw0MI2OZCNVwbDrdClUPmjRKfcTkcC2jNj1rS+WDFbm+mo+SP3rDSvvCdyJuiXHGKiM2EhbYnu42aHVC6w7eAe4Gv3Fq/0faW47r0ihbiAohFB9XUA+fD07g83EjIuc9Q6BRVTTcBfoRkrR/yFZKt3qwPq02W6rPD13/1wAnMtabNcxePMMGk7Dlxwng9yPS0NEge2KD+miOj9SC4aTvOTq2451tfK1x3UZqqb205zGOPbjizhH/CA/PGkG84hdkAG4mrUK0rEHqeWwRXDsxpyfto=\"}],\"role\": \"model\"},\"finishReason\": \"STOP\",\"index\": 0}],\"usageMetadata\": {\"promptTokenCount\": 530,\"candidatesTokenCount\": 8,\"totalTokenCount\": 653,\"promptTokensDetails\": [{\"modality\": \"IMAGE\",\"tokenCount\": 520},{\"modality\": \"TEXT\",\"tokenCount\": 10}],\"thoughtsTokenCount\": 115,\"serviceTier\": \"standard\"},\"modelVersion\": \"gemini-3.5-flash\",\"responseId\": \"BQpharW2KaPgz7IP6uSLiAw\"}\r\n\r\n"
-      }
-    }
-  ]
-}
@@ -59,12 +59,7 @@ export const runTools = <T extends Tools>(options: RunOptions<T>) =>
            ...request.messages,
            Message.assistant(state.assistantContent),
            ...dispatched.map(([call, dispatched]) =>
-              Message.tool({
-                id: call.id,
-                name: call.name,
-                result: dispatched.result,
-                providerMetadata: call.providerMetadata,
-              }),
+              Message.tool({ id: call.id, name: call.name, result: dispatched.result }),
            ),
          ],
        })
@@ -235,9 +235,9 @@ describe("Anthropic Messages route", () => {
    }),
  )

-  // Regression: read tool results must stay structured so base64 media data is
-  // not JSON-stringified into `tool_result.content`.
-  it.effect("lowers media tool-result content as structured blocks", () =>
+  // Regression: screenshot/read tool results must stay structured so base64
+  // image data is not JSON-stringified into `tool_result.content`.
+  it.effect("lowers image tool-result content as structured image blocks", () =>
    Effect.gen(function* () {
      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
        LLM.request({
@@ -253,7 +253,6 @@ describe("Anthropic Messages route", () => {
              result: [
                { type: "text", text: "Image read successfully" },
                { type: "file", uri: "data:image/png;base64,AAECAw==", mime: "image/png" },
-                { type: "file", uri: "data:application/pdf;base64,JVBERi0xLjQ=", mime: "application/pdf" },
              ],
            }),
          ],
@@ -264,7 +263,6 @@ describe("Anthropic Messages route", () => {
      expect(expectToolResult(prepared.body).content).toEqual([
        { type: "text", text: "Image read successfully" },
        { type: "image", source: { type: "base64", media_type: "image/png", data: "AAECAw==" } },
-        { type: "document", source: { type: "base64", media_type: "application/pdf", data: "JVBERi0xLjQ=" } },
      ])
    }),
  )
@@ -294,7 +292,7 @@ describe("Anthropic Messages route", () => {
    }),
  )

-  it.effect("rejects unsupported media in tool-result content with a clear error", () =>
+  it.effect("rejects non-image media in tool-result content with a clear error", () =>
    Effect.gen(function* () {
      const error = yield* LLMClient.prepare(
        LLM.request({
@@ -758,7 +756,7 @@ describe("Anthropic Messages route", () => {
    }),
  )

-  it.effect("continues a conversation with user media content", () =>
+  it.effect("continues a conversation with user image content", () =>
    Effect.gen(function* () {
      const response = yield* LLMClient.generate(
        LLM.request({
@@ -768,7 +766,6 @@ describe("Anthropic Messages route", () => {
            Message.user([
              { type: "text", text: "What is in this image?" },
              { type: "media", mediaType: "image/png", data: "AAECAw==" },
-              { type: "media", mediaType: "application/pdf", data: "JVBERi0xLjQ=", filename: "report.pdf" },
            ]),
          ],
        }),
@@ -784,7 +781,6 @@ describe("Anthropic Messages route", () => {
                    content: [
                      { type: "text", text: "What is in this image?" },
                      { type: "image", source: { type: "base64", media_type: "image/png", data: "AAECAw==" } },
-                      { type: "document", source: { type: "base64", media_type: "application/pdf", data: "JVBERi0xLjQ=" } },
                    ],
                  },
                ],
@@ -13,8 +13,12 @@ const RECORDING_REGION = process.env.BEDROCK_RECORDING_REGION ?? "us-east-1"
 // call wouldn't deterministically prove cache mapping works. Override with
 // BEDROCK_CACHE_MODEL_ID if your account has access elsewhere.
 const model = AmazonBedrock.configure({
-  apiKey: process.env.AWS_BEARER_TOKEN_BEDROCK ?? "fixture",
-  region: RECORDING_REGION,
+  credentials: {
+    region: RECORDING_REGION,
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID ?? "fixture",
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY ?? "fixture",
+    sessionToken: process.env.AWS_SESSION_TOKEN,
+  },
 }).model(process.env.BEDROCK_CACHE_MODEL_ID ?? "us.anthropic.claude-haiku-4-5-20251001-v1:0")

 const cacheRequest = LLM.request({
@@ -32,7 +36,7 @@ const recorded = recordedTests({
  prefix: "bedrock-converse-cache",
  provider: "amazon-bedrock",
  protocol: "bedrock-converse",
-  requires: ["AWS_BEARER_TOKEN_BEDROCK"],
+  requires: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
  // Two identical requests in one cassette — replay walks the cassette in
  // recording order so the second call replays the cached-hit interaction.
 })
@@ -41,20 +45,10 @@ describe("Bedrock Converse cache recorded", () => {
  recorded.effect.with("writes then reads cachePoint on identical second call", { tags: ["cache"] }, () =>
    Effect.gen(function* () {
      const first = yield* LLMClient.generate(cacheRequest)
-      expect(first.usage?.cacheWriteInputTokens ?? 0).toBeGreaterThan(0)
-      expect(first.usage?.inputTokens).toBe(
-        (first.usage?.nonCachedInputTokens ?? 0) +
-          (first.usage?.cacheReadInputTokens ?? 0) +
-          (first.usage?.cacheWriteInputTokens ?? 0),
-      )
+      expect(first.usage?.cacheReadInputTokens ?? 0).toBeGreaterThanOrEqual(0)

      const second = yield* LLMClient.generate(cacheRequest)
      expect(second.usage?.cacheReadInputTokens ?? 0).toBeGreaterThan(0)
-      expect(second.usage?.inputTokens).toBe(
-        (second.usage?.nonCachedInputTokens ?? 0) +
-          (second.usage?.cacheReadInputTokens ?? 0) +
-          (second.usage?.cacheWriteInputTokens ?? 0),
-      )
    }),
  )
 })
@@ -269,39 +269,6 @@ describe("Bedrock Converse route", () => {
    }),
  )

-  it.effect("adds cache reads and writes to Bedrock input usage", () =>
-    Effect.gen(function* () {
-      const body = eventStreamBody(
-        ["messageStart", { role: "assistant" }],
-        ["contentBlockDelta", { contentBlockIndex: 0, delta: { text: "Hello" } }],
-        ["contentBlockStop", { contentBlockIndex: 0 }],
-        ["messageStop", { stopReason: "end_turn" }],
-        [
-          "metadata",
-          {
-            usage: {
-              inputTokens: 5,
-              outputTokens: 2,
-              totalTokens: 12,
-              cacheReadInputTokens: 3,
-              cacheWriteInputTokens: 2,
-            },
-          },
-        ],
-      )
-      const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
-
-      expect(response.usage).toMatchObject({
-        inputTokens: 10,
-        nonCachedInputTokens: 5,
-        cacheReadInputTokens: 3,
-        cacheWriteInputTokens: 2,
-        outputTokens: 2,
-        totalTokens: 12,
-      })
-    }),
-  )
-
  it.effect("assembles streamed tool call input", () =>
    Effect.gen(function* () {
      const body = eventStreamBody(
@@ -582,12 +549,10 @@ describe("Bedrock Converse route", () => {
        LLM.request({
          id: "req_doc",
          model,
-          cache: "none",
          messages: [
            Message.user([
-              { type: "text", text: "Summarize these documents." },
              { type: "media", mediaType: "application/pdf", data: "UERGREFUQQ==", filename: "report.pdf" },
-              { type: "media", mediaType: "text/csv", data: "Q1NWREFUQQ==", filename: "data.csv" },
+              { type: "media", mediaType: "text/csv", data: "Q1NWREFUQQ==" },
            ]),
          ],
        }),
@@ -598,9 +563,10 @@ describe("Bedrock Converse route", () => {
          {
            role: "user",
            content: [
-              { text: "Summarize these documents." },
+              // Filename round-trips when supplied.
              { document: { format: "pdf", name: "report.pdf", source: { bytes: "UERGREFUQQ==" } } },
-              { document: { format: "csv", name: "data.csv", source: { bytes: "Q1NWREFUQQ==" } } },
+              // Falls back to a stable placeholder when filename is missing.
+              { document: { format: "csv", name: "document.csv", source: { bytes: "Q1NWREFUQQ==" } } },
            ],
          },
        ],
@@ -608,96 +574,6 @@ describe("Bedrock Converse route", () => {
    }),
  )

-  it.effect("requires names for document media", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
-        LLM.request({
-          model,
-          messages: [Message.user({ type: "media", mediaType: "application/pdf", data: "UERGREFUQQ==" })],
-        }),
-      ).pipe(Effect.flip)
-
-      expect(error.message).toContain("document media requires a filename")
-    }),
-  )
-
-  it.effect("passes named document-only messages through for provider validation", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
-        LLM.request({
-          model,
-          cache: "none",
-          messages: [
-            Message.user({
-              type: "media",
-              mediaType: "application/pdf",
-              data: "UERGREFUQQ==",
-              filename: "report.pdf",
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        {
-          role: "user",
-          content: [{ document: { format: "pdf", name: "report.pdf", source: { bytes: "UERGREFUQQ==" } } }],
-        },
-      ])
-    }),
-  )
-
-  it.effect("lowers document media in tool results", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "read", input: { path: "report.pdf" } })]),
-            Message.tool({
-              id: "call_1",
-              name: "read",
-              result: {
-                type: "content",
-                value: [
-                  { type: "text", text: "Read successfully" },
-                  {
-                    type: "file",
-                    uri: "data:application/pdf;base64,UERGREFUQQ==",
-                    mime: "application/pdf",
-                    name: "report",
-                  },
-                ],
-              },
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        {
-          role: "assistant",
-          content: [{ toolUse: { toolUseId: "call_1", name: "read", input: { path: "report.pdf" } } }],
-        },
-        {
-          role: "user",
-          content: [
-            {
-              toolResult: {
-                toolUseId: "call_1",
-                status: "success",
-                content: [
-                  { text: "Read successfully" },
-                  { document: { format: "pdf", name: "report", source: { bytes: "UERGREFUQQ==" } } },
-                ],
-              },
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
  it.effect("rejects unsupported image media types", () =>
    Effect.gen(function* () {
      const error = yield* LLMClient.prepare(
@@ -70,7 +70,6 @@ describe("Gemini route", () => {
            Message.user([
              { type: "text", text: "What is in this image?" },
              { type: "media", mediaType: "image/png", data: "AAECAw==" },
-              { type: "media", mediaType: "application/pdf", data: "JVBERi0xLjQ=" },
            ]),
            Message.assistant([ToolCallPart.make({ id: "call_1", name: "lookup", input: { query: "weather" } })]),
            Message.tool({ id: "call_1", name: "lookup", result: { forecast: "sunny" } }),
@@ -82,11 +81,7 @@ describe("Gemini route", () => {
        contents: [
          {
            role: "user",
-            parts: [
-              { text: "What is in this image?" },
-              { inlineData: { mimeType: "image/png", data: "AAECAw==" } },
-              { inlineData: { mimeType: "application/pdf", data: "JVBERi0xLjQ=" } },
-            ],
+            parts: [{ text: "What is in this image?" }, { inlineData: { mimeType: "image/png", data: "AAECAw==" } }],
          },
          {
            role: "model",
@@ -95,12 +90,7 @@ describe("Gemini route", () => {
          {
            role: "user",
            parts: [
-              {
-                functionResponse: {
-                  name: "lookup",
-                  response: { name: "lookup", content: '{"forecast":"sunny"}' },
-                },
-              },
+              { functionResponse: { name: "lookup", response: { name: "lookup", content: '{"forecast":"sunny"}' } } },
            ],
          },
        ],
@@ -120,7 +110,7 @@ describe("Gemini route", () => {
    }),
  )

-  it.effect("continues media tool results as inline model input without base64 text", () =>
+  it.effect("continues image tool results as inline vision input without base64 text", () =>
    Effect.gen(function* () {
      const prepared = yield* LLMClient.prepare<Gemini.GeminiBody>(
        LLM.request({
@@ -135,7 +125,6 @@ describe("Gemini route", () => {
                value: [
                  { type: "text", text: "Image read successfully" },
                  { type: "file", uri: "data:image/png;base64,AAECAw==", mime: "image/png", name: "pixel.png" },
-                  { type: "file", uri: "data:application/pdf;base64,JVBERi0xLjQ=", mime: "application/pdf" },
                ],
              },
            }),
@@ -152,12 +141,9 @@ describe("Gemini route", () => {
              functionResponse: {
                name: "read",
                response: { name: "read", content: "Image read successfully" },
-                parts: [
-                  { inlineData: { mimeType: "image/png", data: "AAECAw==" } },
-                  { inlineData: { mimeType: "application/pdf", data: "JVBERi0xLjQ=" } },
-                ],
              },
            },
+            { inlineData: { mimeType: "image/png", data: "AAECAw==" } },
          ],
        },
      ])
@@ -188,13 +174,8 @@ describe("Gemini route", () => {
        {
          role: "user",
          parts: [
-            {
-              functionResponse: {
-                name: "read",
-                response: { name: "read", content: "" },
-                parts: [{ inlineData: { mimeType: "image/jpeg", data: "/9j/" } }],
-              },
-            },
+            { functionResponse: { name: "read", response: { name: "read", content: "" } } },
+            { inlineData: { mimeType: "image/jpeg", data: "/9j/" } },
          ],
        },
      ])
@@ -391,10 +372,7 @@ describe("Gemini route", () => {
              parts: [
                { text: "thinking", thought: true },
                { text: "", thought: true, thoughtSignature: "thought_sig" },
-                {
-                  functionCall: { id: "provider_call", name: "lookup", args: { query: "weather" } },
-                  thoughtSignature: "tool_sig",
-                },
+                { functionCall: { name: "lookup", args: { query: "weather" } }, thoughtSignature: "tool_sig" },
              ],
            },
            finishReason: "STOP",
@@ -420,10 +398,7 @@ describe("Gemini route", () => {
        id: "reasoning-0",
        providerMetadata: { google: { thoughtSignature: "thought_sig" } },
      })
-      expect(toolCall).toMatchObject({
-        id: "tool_0",
-        providerMetadata: { google: { functionCallId: "provider_call", thoughtSignature: "tool_sig" } },
-      })
+      expect(toolCall).toMatchObject({ providerMetadata: { google: { thoughtSignature: "tool_sig" } } })
      expect(response.events.findIndex((event) => event.type === "reasoning-end")).toBeLessThan(
        response.events.findIndex((event) => event.type === "tool-call"),
      )
@@ -441,13 +416,6 @@ describe("Gemini route", () => {
                providerMetadata: toolCall?.providerMetadata,
              }),
            ]),
-            Message.tool({
-              id: "tool_0",
-              name: "lookup",
-              result: "done",
-              resultType: "text",
-              providerMetadata: toolCall?.providerMetadata,
-            }),
          ],
        }),
      )
@@ -456,22 +424,7 @@ describe("Gemini route", () => {
          role: "model",
          parts: [
            { text: "thinking", thought: true, thoughtSignature: "thought_sig" },
-            {
-              functionCall: { id: "provider_call", name: "lookup", args: { query: "weather" } },
-              thoughtSignature: "tool_sig",
-            },
-          ],
-        },
-        {
-          role: "user",
-          parts: [
-            {
-              functionResponse: {
-                id: "provider_call",
-                name: "lookup",
-                response: { name: "lookup", content: "done" },
-              },
-            },
+            { functionCall: { name: "lookup", args: { query: "weather" } }, thoughtSignature: "tool_sig" },
          ],
        },
      ])
@@ -545,7 +498,7 @@ describe("Gemini route", () => {
            content: {
              role: "model",
              parts: [
-                { functionCall: { id: "tool_0", name: "lookup", args: { query: "weather" } } },
+                { functionCall: { name: "lookup", args: { query: "weather" } } },
                { functionCall: { name: "lookup", args: { query: "news" } } },
              ],
            },
@@ -560,13 +513,7 @@ describe("Gemini route", () => {
      ).pipe(Effect.provide(fixedResponse(body)))

      expect(response.toolCalls).toEqual([
-        {
-          type: "tool-call",
-          id: "tool_0",
-          name: "lookup",
-          input: { query: "weather" },
-          providerMetadata: { google: { functionCallId: "tool_0" } },
-        },
+        { type: "tool-call", id: "tool_0", name: "lookup", input: { query: "weather" } },
        { type: "tool-call", id: "tool_1", name: "lookup", input: { query: "news" } },
      ])
      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "tool-calls" })
@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { LLM, LLMEvent, LLMResponse, Model } from "../../src"
+import { LLM, LLMEvent, LLMResponse } from "../../src"
 import { OpenAIChat } from "../../src/protocols/openai-chat"
 import * as OpenAICompatible from "../../src/providers/openai-compatible"
 import * as OpenRouter from "../../src/providers/openrouter"
@@ -11,28 +11,22 @@ import { expectWeatherToolLoop, goldenWeatherToolLoopRequest, runWeatherToolLoop
 const cases = [
  {
    name: "OpenRouter",
-    model: Model.update(
-      OpenRouter.configure({
-        apiKey: process.env.OPENROUTER_API_KEY ?? "fixture",
-        providerOptions: { openrouter: { reasoning: { max_tokens: 1024 } } },
-      }).model("anthropic/claude-sonnet-4.6"),
-      { compatibility: { reasoningField: "reasoning" } },
-    ),
+    model: OpenRouter.configure({
+      apiKey: process.env.OPENROUTER_API_KEY ?? "fixture",
+      providerOptions: { openrouter: { reasoning: { max_tokens: 1024 } } },
+    }).model("anthropic/claude-sonnet-4.6"),
    requires: ["OPENROUTER_API_KEY"],
    cassette: "openrouter-reasoning",
    structured: true,
  },
  {
    name: "Vercel AI Gateway",
-    model: Model.update(
-      OpenAICompatible.configure({
-        provider: "vercel-ai-gateway",
-        baseURL: "https://ai-gateway.vercel.sh/v1",
-        apiKey: process.env.AI_GATEWAY_API_KEY ?? "fixture",
-        http: { body: { reasoning: { enabled: true, max_tokens: 1024 } } },
-      }).model("anthropic/claude-sonnet-4.6"),
-      { compatibility: { reasoningField: "reasoning" } },
-    ),
+    model: OpenAICompatible.configure({
+      provider: "vercel-ai-gateway",
+      baseURL: "https://ai-gateway.vercel.sh/v1",
+      apiKey: process.env.AI_GATEWAY_API_KEY ?? "fixture",
+      http: { body: { reasoning: { enabled: true, max_tokens: 1024 } } },
+    }).model("anthropic/claude-sonnet-4.6"),
    requires: ["AI_GATEWAY_API_KEY"],
    cassette: "vercel-ai-gateway-reasoning",
    structured: true,
@@ -92,45 +92,6 @@ describe("OpenAI Chat route", () => {
    }),
  )

-  it.effect("writes reasoning to a configured custom field on every assistant message", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({
-          model: Model.update(model, { compatibility: { reasoningField: "vendor_reasoning" } }),
-          messages: [
-            Message.assistant([
-              {
-                type: "reasoning",
-                text: "thinking",
-                providerMetadata: { openai: { reasoningField: "reasoning" } },
-              },
-              { type: "text", text: "Hello" },
-            ]),
-            Message.assistant("Done"),
-          ],
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        { role: "assistant", content: "Hello", vendor_reasoning: "thinking" },
-        { role: "assistant", content: "Done", vendor_reasoning: "" },
-      ])
-    }),
-  )
-
-  it.effect("rejects reasoning fields that conflict with assistant message fields", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
-        LLM.request({
-          model: Model.update(model, { compatibility: { reasoningField: "content" } }),
-          messages: [Message.assistant([{ type: "reasoning", text: "thinking" }])],
-        }),
-      ).pipe(Effect.flip)
-
-      expect(error.message).toContain("reserved field content")
-    }),
-  )
-
  it.effect("maps OpenAI provider options to Chat options", () =>
    Effect.gen(function* () {
      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
@@ -609,35 +570,6 @@ describe("OpenAI Chat route", () => {
    }),
  )

-  it.effect("parses and replays a configured custom reasoning field", () =>
-    Effect.gen(function* () {
-      const custom = Model.update(model, { compatibility: { reasoningField: "vendor_reasoning" } })
-      const response = yield* LLMClient.generate(LLM.updateRequest(request, { model: custom })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { vendor_reasoning: "thinking" } }] },
-              { choices: [{ delta: { content: "Hello" } }] },
-              { choices: [{ delta: {}, finish_reason: "stop" }] },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.reasoning).toBe("thinking")
-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        openai: { reasoningField: "vendor_reasoning" },
-      })
-
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model: custom, messages: [response.message] }),
-      )
-      expect(replay.body.messages).toEqual([
-        { role: "assistant", content: "Hello", vendor_reasoning: "thinking" },
-      ])
-    }),
-  )
-
  it.effect("preserves and replays reasoning details alongside scalar reasoning", () =>
    Effect.gen(function* () {
      const details = [
@@ -5,7 +5,6 @@ import { LLM, LLMError, LLMEvent, Message, Model, ToolCallPart, ToolResultPart,
 import { Auth, LLMClient, RequestExecutor, WebSocketExecutor } from "../../src/route"
 import * as Azure from "../../src/providers/azure"
 import * as OpenAI from "../../src/providers/openai"
-import * as XAI from "../../src/providers/xai"
 import * as OpenAIResponses from "../../src/protocols/openai-responses"
 import * as ProviderShared from "../../src/protocols/shared"
 import { continuationRequest, nativeOpenAIResponsesContinuation } from "../continuation-scenarios"
@@ -17,8 +16,6 @@ const model = OpenAIResponses.route
  .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
  .model({ id: "gpt-4.1-mini" })

-const xaiModel = XAI.configure({ apiKey: "test", baseURL: "https://api.x.ai/v1" }).responses("grok-4.5")
-
 const request = LLM.request({
  id: "req_1",
  model,
@@ -527,77 +524,7 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("lowers PDF tool-result content as structured input_file array", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
-        LLM.request({
-          id: "req_tool_result_pdf",
-          model,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "read", input: {} })]),
-            Message.tool({
-              id: "call_1",
-              name: "read",
-              resultType: "content",
-              result: [
-                {
-                  type: "file",
-                  uri: "data:application/pdf;base64,JVBERi0xLjQ=",
-                  mime: "application/pdf",
-                  name: "report.pdf",
-                },
-              ],
-            }),
-          ],
-        }),
-      )
-
-      expect(expectToolOutput(prepared.body).output).toEqual([
-        {
-          type: "input_file",
-          filename: "report.pdf",
-          file_data: "data:application/pdf;base64,JVBERi0xLjQ=",
-        },
-      ])
-    }),
-  )
-
-  it.effect("uses xAI inline file encoding for PDF tool results", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
-        LLM.request({
-          model: xaiModel,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "read", input: {} })]),
-            Message.tool({
-              id: "call_1",
-              name: "read",
-              resultType: "content",
-              result: [
-                {
-                  type: "file",
-                  uri: "data:application/pdf;base64,JVBERi0xLjQ=",
-                  mime: "application/pdf",
-                  name: "report.pdf",
-                },
-              ],
-            }),
-          ],
-        }),
-      )
-
-      expect(expectToolOutput(prepared.body).output).toEqual([
-        {
-          type: "input_file",
-          filename: "report.pdf",
-          file_data: "JVBERi0xLjQ=",
-          mime_type: "application/pdf",
-        },
-      ])
-    }),
-  )
-
-  it.effect("rejects unsupported media in tool-result content with a clear error", () =>
+  it.effect("rejects non-image media in tool-result content with a clear error", () =>
    Effect.gen(function* () {
      const error = yield* LLMClient.prepare(
        LLM.request({
@@ -870,32 +797,6 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("maps incomplete response reasons", () =>
-    Effect.gen(function* () {
-      const generate = (incompleteDetails: object) =>
-        LLMClient.generate(request).pipe(
-          Effect.provide(
-            fixedResponse(
-              sseEvents({
-                type: "response.incomplete",
-                response: { id: "resp_incomplete", incomplete_details: incompleteDetails },
-              }),
-            ),
-          ),
-        )
-
-      const length = yield* generate({ reason: "max_output_tokens" })
-      const contentFilter = yield* generate({ reason: "content_filter" })
-      const unknown = yield* generate({})
-
-      expect([length.finishReason, contentFilter.finishReason, unknown.finishReason]).toEqual([
-        "length",
-        "content-filter",
-        "unknown",
-      ])
-    }),
-  )
-
  // OpenAI's documented stream orders output text within one message item; no
  // provider-valid same-kind overlap is evidenced, so done boundaries close it.
  it.effect("closes sequential output messages before starting the next", () =>
@@ -1625,64 +1526,20 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("lowers user image and PDF content", () =>
+  it.effect("lowers user image content", () =>
    Effect.gen(function* () {
      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
        LLM.request({
          id: "req_media",
          model,
-          messages: [
-            Message.user([
-              { type: "media", mediaType: "image/png", data: "AAECAw==" },
-              { type: "media", mediaType: "application/pdf", data: "JVBERi0xLjQ=", filename: "report.pdf" },
-            ]),
-          ],
+          messages: [Message.user({ type: "media", mediaType: "image/png", data: "AAECAw==" })],
        }),
      )

      expect(prepared.body.input).toEqual([
        {
          role: "user",
-          content: [
-            { type: "input_image", image_url: "data:image/png;base64,AAECAw==" },
-            {
-              type: "input_file",
-              filename: "report.pdf",
-              file_data: "data:application/pdf;base64,JVBERi0xLjQ=",
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("uses xAI inline file encoding for user PDFs", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
-        LLM.request({
-          model: xaiModel,
-          messages: [
-            Message.user({
-              type: "media",
-              mediaType: "application/pdf",
-              data: "data:application/pdf;base64,JVBERi0xLjQ=",
-              filename: "report.pdf",
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.input).toEqual([
-        {
-          role: "user",
-          content: [
-            {
-              type: "input_file",
-              filename: "report.pdf",
-              file_data: "JVBERi0xLjQ=",
-              mime_type: "application/pdf",
-            },
-          ],
+          content: [{ type: "input_image", image_url: "data:image/png;base64,AAECAw==" }],
        },
      ])
    }),
@@ -1694,11 +1551,11 @@ describe("OpenAI Responses route", () => {
        LLM.request({
          id: "req_media",
          model,
-          messages: [Message.user({ type: "media", mediaType: "application/x-tar", data: "AAECAw==" })],
+          messages: [Message.user({ type: "media", mediaType: "application/pdf", data: "AAECAw==" })],
        }),
      ).pipe(Effect.flip)

-      expect(error.message).toContain("OpenAI Responses does not support media type application/x-tar")
+      expect(error.message).toContain("OpenAI Responses does not support media type application/pdf")
    }),
  )

@@ -1,207 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Schema, Stream } from "effect"
-import { LLM, LLMResponse, Message, ToolDefinition, type Model } from "../../src"
-import { AmazonBedrock, Anthropic, Google, OpenAI, XAI } from "../../src/providers"
-import { LLMClient } from "../../src/route"
-import { Tool } from "../../src/tool"
-import { runTools } from "../lib/tool-runtime"
-import { recordedTests } from "../recorded-test"
-
-const CODE = "ORCHID-7391"
-const PDF =
-  "JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK"
-
-const openai = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY ?? "fixture" })
-const anthropic = Anthropic.configure({ apiKey: process.env.ANTHROPIC_API_KEY ?? "fixture" })
-const google = Google.configure({ apiKey: process.env.GOOGLE_API_KEY ?? "fixture" })
-const xai = XAI.configure({ apiKey: process.env.XAI_API_KEY ?? "fixture" })
-const bedrock = AmazonBedrock.configure({
-  apiKey: process.env.AWS_BEDROCK_API_KEY ?? "fixture",
-  region: process.env.AWS_REGION ?? "us-east-1",
-})
-
-const targets: ReadonlyArray<{
-  readonly id: string
-  readonly name: string
-  readonly provider: string
-  readonly protocol: string
-  readonly requires: string
-  readonly filename: string
-  readonly maxTokens: number
-  readonly model: Model
-}> = [
-  {
-    id: "openai",
-    name: "OpenAI Responses gpt-4o-mini",
-    provider: "openai",
-    protocol: "openai-responses",
-    requires: "OPENAI_API_KEY",
-    filename: "verification.pdf",
-    maxTokens: 40,
-    model: openai.responses("gpt-4o-mini"),
-  },
-  {
-    id: "anthropic",
-    name: "Anthropic Haiku 4.5",
-    provider: "anthropic",
-    protocol: "anthropic-messages",
-    requires: "ANTHROPIC_API_KEY",
-    filename: "verification.pdf",
-    maxTokens: 40,
-    model: anthropic.model("claude-haiku-4-5-20251001"),
-  },
-  {
-    id: "gemini",
-    name: "Gemini 3.5 Flash",
-    provider: "google",
-    protocol: "gemini",
-    requires: "GOOGLE_API_KEY",
-    filename: "verification.pdf",
-    maxTokens: 256,
-    model: google.model("gemini-3.5-flash"),
-  },
-  {
-    id: "xai",
-    name: "xAI Grok 4.5",
-    provider: "xai",
-    protocol: "openai-responses",
-    requires: "XAI_API_KEY",
-    filename: "verification.pdf",
-    maxTokens: 40,
-    model: xai.responses("grok-4.5"),
-  },
-  {
-    id: "bedrock",
-    name: "Bedrock Claude Haiku 4.5",
-    provider: "amazon-bedrock",
-    protocol: "bedrock-converse",
-    requires: "AWS_BEDROCK_API_KEY",
-    filename: "verification",
-    maxTokens: 40,
-    model: bedrock.model("us.anthropic.claude-haiku-4-5-20251001-v1:0"),
-  },
-]
-
-const recorded = recordedTests({ prefix: "pdf", tags: ["pdf"] })
-const prompt = "Return only the verification code from the PDF."
-const readPdf = ToolDefinition.make({
-  name: "read_pdf",
-  description: "Read the attached PDF.",
-  inputSchema: { type: "object", properties: {}, additionalProperties: false },
-})
-const readPdfRuntime = Tool.make({
-  description: readPdf.description,
-  parameters: Schema.Struct({ path: Schema.String }),
-  success: Schema.String,
-  execute: () => Effect.succeed("PDF read successfully"),
-  toModelOutput: () => [
-    { type: "text", text: "PDF read successfully" },
-    {
-      type: "file",
-      uri: `data:application/pdf;base64,${PDF}`,
-      mime: "application/pdf",
-      name: "verification.pdf",
-    },
-  ],
-})
-
-const expectCode = (response: LLMResponse) => {
-  expect(response.finishReason).toBe("stop")
-  expect(response.text.toUpperCase()).toContain(CODE)
-}
-
-describe("PDF recorded", () => {
-  for (const target of targets) {
-    recorded.effect.with(
-      `reads a user PDF with ${target.name}`,
-      {
-        id: `${target.id}-user-input`,
-        provider: target.provider,
-        protocol: target.protocol,
-        requires: [target.requires],
-        tags: ["user-input"],
-      },
-      Effect.gen(function* () {
-        expectCode(
-          yield* LLMClient.generate(
-            LLM.request({
-              id: `recorded_pdf_${target.id}_user_input`,
-              model: target.model,
-              cache: "none",
-              generation: { maxTokens: target.maxTokens, temperature: 0 },
-              messages: [
-                Message.user([
-                  { type: "media", mediaType: "application/pdf", data: PDF, filename: target.filename },
-                  { type: "text", text: prompt },
-                ]),
-              ],
-            }),
-          ),
-        )
-      }),
-    )
-
-    recorded.effect.with(
-      `reads a PDF tool result with ${target.name}`,
-      {
-        id: `${target.id}-tool-result`,
-        provider: target.provider,
-        protocol: target.protocol,
-        requires: [target.requires],
-        tags: ["tool", "tool-result"],
-      },
-      Effect.gen(function* () {
-        if (target.id === "gemini") {
-          const events = Array.from(
-            yield* runTools({
-              request: LLM.request({
-                id: "recorded_pdf_gemini_tool_result",
-                model: target.model,
-                system:
-                  "Call read_pdf exactly once with path verification.pdf, then reply only with the verification code from its PDF.",
-                prompt: "Use read_pdf with path verification.pdf and return the verification code.",
-                cache: "none",
-                generation: { maxTokens: target.maxTokens, temperature: 0 },
-              }),
-              tools: { read_pdf: readPdfRuntime },
-            }).pipe(Stream.runCollect),
-          )
-          expect(events.at(-1)).toMatchObject({ type: "finish", reason: "stop" })
-          expect(LLMResponse.text({ events }).toUpperCase()).toContain(CODE)
-          return
-        }
-
-        expectCode(
-          yield* LLMClient.generate(
-            LLM.request({
-              id: `recorded_pdf_${target.id}_tool_result`,
-              model: target.model,
-              system: "Read the PDF returned by the tool and follow the user's response format exactly.",
-              cache: "none",
-              generation: { maxTokens: target.maxTokens, temperature: 0 },
-              messages: [
-                Message.user(prompt),
-                Message.assistant([{ type: "tool-call", id: "call_pdf_1", name: readPdf.name, input: {} }]),
-                Message.tool({
-                  id: "call_pdf_1",
-                  name: readPdf.name,
-                  resultType: "content",
-                  result: [
-                    { type: "text", text: "PDF read successfully" },
-                    {
-                      type: "file",
-                      uri: `data:application/pdf;base64,${PDF}`,
-                      mime: "application/pdf",
-                      name: target.filename,
-                    },
-                  ],
-                }),
-              ],
-              tools: [readPdf],
-            }),
-          ),
-        )
-      }),
-    )
-  }
-})
@@ -183,51 +183,6 @@ describe("LLMClient tools", () => {
    }),
  )

-  it.effect("preserves provider metadata on dispatched tool results", () =>
-    Effect.gen(function* () {
-      const tool = Tool.make({
-        description: "Return text.",
-        parameters: Schema.Struct({}),
-        success: Schema.String,
-        execute: () => Effect.succeed("hello"),
-      })
-      const providerMetadata = { google: { functionCallId: "provider_call" } }
-      const dispatched = yield* ToolRuntime.dispatch(
-        { tool },
-        LLMEvent.toolCall({ id: "call_1", name: "tool", input: {}, providerMetadata }),
-      )
-
-      expect(dispatched.events).toEqual([
-        LLMEvent.toolResult({
-          id: "call_1",
-          name: "tool",
-          result: { type: "text", value: "hello" },
-          output: { structured: "hello", content: [{ type: "text", text: "hello" }] },
-          providerMetadata,
-        }),
-      ])
-
-      const failed = yield* ToolRuntime.dispatch(
-        {},
-        LLMEvent.toolCall({ id: "call_2", name: "missing", input: {}, providerMetadata }),
-      )
-      expect(failed.events).toEqual([
-        LLMEvent.toolError({
-          id: "call_2",
-          name: "missing",
-          message: "Unknown tool: missing",
-          providerMetadata,
-        }),
-        LLMEvent.toolResult({
-          id: "call_2",
-          name: "missing",
-          result: { type: "error", value: "Unknown tool: missing" },
-          providerMetadata,
-        }),
-      ])
-    }),
-  )
-
  it.effect("uses the narrow default projection for encoded typed success", () =>
    Effect.gen(function* () {
      const text = Tool.make({
@@ -32,23 +32,6 @@ for (const expanded of [false, true]) {
  })
 }

-test("shows and expands a running shell command without shimmering it", async ({ page }) => {
-  const id = "prt_shell_running_command"
-  const command = "sleep 10 && echo done"
-  await setupTimeline(page, {
-    messages: [userMessage(), assistantMessage([shell(id, "running", "still running", command)], { completed: false })],
-    settings: { shellToolPartsExpanded: false },
-  })
-
-  const tool = page.locator(`[data-timeline-part-id="${id}"]`)
-  await expect(tool.locator('[data-component="text-shimmer"]')).toHaveAttribute("data-active", "true")
-  await expect(tool.locator('[data-component="shell-submessage"]')).toHaveText(command)
-  await expect(tool.locator('[data-component="shell-submessage"] [data-component="text-shimmer"]')).toHaveCount(0)
-  await tool.locator('[data-slot="collapsible-trigger"]').click()
-  await expect(tool.locator('[data-slot="collapsible-trigger"]')).toHaveAttribute("aria-expanded", "true")
-  await expect(tool.locator('[data-slot="bash-pre"]')).toContainText("still running")
-})
-
 test("transitions thinking and hidden reasoning through busy to idle", async ({ page }) => {
  const reasoningID = "prt_reasoning_hidden"
  const assistant = assistantMessage([reasoningPart(reasoningID, "## Inspecting stability")], { completed: false })
@@ -13,6 +13,7 @@ export function useSessionTabAvatarState(
  const global = useGlobal()
  const notification = useNotification()
  const permission = usePermission()
+  const permissionState = createMemo(() => permission.ensureServerState(server()))
  const connection = createMemo(() => global.servers.list().find((item) => ServerConnection.key(item) === server()))
  const sync = createMemo(() => {
    const conn = connection()
@@ -21,10 +22,9 @@ export function useSessionTabAvatarState(
  const hasPermissions = createMemo(() => {
    const serverSync = sync()
    if (!serverSync) return false
-    const permissionState = permission.ensureServerState(server())
    const [store] = serverSync.child(directory(), { bootstrap: false })
    return !!sessionPermissionRequest(store.session, serverSync.session.data.permission, sessionId(), (item) => {
-      return !permissionState.autoResponds(item, directory())
+      return !permissionState().autoResponds(item, directory())
    })
  })
  const hasQuestions = createMemo(() => {
@@ -34,11 +34,9 @@ export function useSessionTabAvatarState(
    return !!sessionQuestionRequest(store.session, serverSync.session.data.question, sessionId())
  })
  const needsAttention = createMemo(() => hasPermissions() || hasQuestions())
-  const notificationState = createMemo(() => {
-    if (!connection()) return
-    return notification.ensureServerState(server())
-  })
-  const unread = createMemo(() => needsAttention() || (notificationState()?.session.unseenCount(sessionId()) ?? 0) > 0)
+  const unread = createMemo(
+    () => needsAttention() || notification.ensureServerState(server()).session.unseenCount(sessionId()) > 0,
+  )
  const loading = createMemo(() => {
    const serverSync = sync()
    if (!serverSync) return false
@@ -11,6 +11,7 @@
    "bin"
  ],
  "exports": {
+    "./daemon": "./src/daemon.ts",
    "./run": "./src/run/index.ts",
    "./server-process": "./src/server-process.ts"
  },
@@ -22,7 +23,7 @@
    "typecheck": "tsgo --noEmit"
  },
  "dependencies": {
-    "@agentclientprotocol/sdk": "1.2.1",
+    "@agentclientprotocol/sdk": "0.21.0",
    "@effect/platform-node": "catalog:",
    "@opencode-ai/client": "workspace:*",
    "@opencode-ai/plugin": "workspace:*",
@@ -5,7 +5,6 @@ import {
  type AuthenticateRequest,
  type CancelNotification,
  type CloseSessionRequest,
-  type DeleteSessionRequest,
  type ForkSessionRequest,
  type InitializeRequest,
  type ListSessionsRequest,
@@ -14,6 +13,7 @@ import {
  type PromptRequest,
  type ResumeSessionRequest,
  type SetSessionConfigOptionRequest,
+  type SetSessionModelRequest,
  type SetSessionModeRequest,
 } from "@agentclientprotocol/sdk"
 import type { OpenCodeClient } from "@opencode-ai/client/promise"
@@ -28,12 +28,12 @@ export function create(client: OpenCodeClient, connection: AgentSideConnection)
    newSession: (params: NewSessionRequest) => run(service.newSession(params)),
    loadSession: (params: LoadSessionRequest) => run(service.loadSession(params)),
    listSessions: (params: ListSessionsRequest) => run(service.listSessions(params)),
-    deleteSession: (params: DeleteSessionRequest) => run(service.deleteSession(params)),
    resumeSession: (params: ResumeSessionRequest) => run(service.resumeSession(params)),
    closeSession: (params: CloseSessionRequest) => run(service.closeSession(params)),
    unstable_forkSession: (params: ForkSessionRequest) => run(service.forkSession(params)),
    setSessionConfigOption: (params: SetSessionConfigOptionRequest) => run(service.setSessionConfigOption(params)),
    setSessionMode: (params: SetSessionModeRequest) => run(service.setSessionMode(params)),
+    unstable_setSessionModel: (params: SetSessionModelRequest) => run(service.setSessionModel(params)),
    prompt: (params: PromptRequest) => run(service.prompt(params)),
    cancel: (params: CancelNotification) => run(service.cancel(params)),
  } satisfies Agent
@@ -47,7 +47,7 @@ export async function streamTurn(input: {
  readonly sessionID: string
  readonly cwd: string
  readonly start: TurnStart
-  readonly writeTextFile: boolean
+  readonly userMessageID?: string | null
  readonly submit: (signal: AbortSignal) => Promise<unknown>
  readonly control: TurnControl
 }): Promise<PromptResponse> {
@@ -170,7 +170,6 @@ export async function streamTurn(input: {
        tools.delete(event.data.callID)
        await syncEditedFiles({
          connection: input.connection,
-          writeTextFile: input.writeTextFile,
          sessionID: input.sessionID,
          cwd: input.cwd,
          toolName: current.name,
@@ -199,8 +198,8 @@ export async function streamTurn(input: {
            toolCallId: event.data.callID,
            toolName: current.name,
            input: current.input,
-            structured: event.data.metadata ?? current.structured,
-            content: event.data.content ?? current.content,
+            structured: current.structured,
+            content: current.content,
            error: event.data.error.message,
            cwd: input.cwd,
          }),
@@ -232,7 +231,7 @@ export async function streamTurn(input: {
      if (!started) {
        streamController.abort()
        await completed.catch(() => {})
-        return response(undefined, undefined, "interrupted", true, undefined)
+        return response(undefined, undefined, "interrupted", true, undefined, input.userMessageID)
      }
    }
    const terminal = await completed
@@ -247,6 +246,7 @@ export async function streamTurn(input: {
      terminal,
      control.cancelled,
      finish,
+      input.userMessageID,
    )
  } catch (error) {
    streamController.abort()
@@ -400,6 +400,7 @@ function response(
  terminal: "succeeded" | "failed" | "interrupted",
  cancelled: boolean,
  finish: SessionMessageAssistant["finish"],
+  messageID: string | null | undefined,
 ): PromptResponse {
  const error = assistant?.error ?? executionError
  if (error?.type === "provider.auth") throw new ACPError.AuthRequiredError()
@@ -422,7 +423,7 @@ function response(
      }
    : undefined
  const stopReason = resolveStopReason({ terminal, cancelled, finish, error: error?.type })
-  return { stopReason, ...(usage ? { usage } : {}), _meta: {} }
+  return { stopReason, ...(usage ? { usage } : {}), ...(messageID ? { userMessageId: messageID } : {}), _meta: {} }
 }

 function resolveStopReason(input: {
@@ -53,14 +53,13 @@ export async function replyPermission(input: {

 export async function syncEditedFiles(input: {
  readonly connection: Partial<Pick<AgentSideConnection, "writeTextFile">>
-  readonly writeTextFile: boolean
  readonly sessionID: string
  readonly cwd: string
  readonly toolName: string
  readonly toolInput: ToolInput
  readonly structured: Readonly<Record<string, unknown>>
 }) {
-  if (!input.writeTextFile || !input.connection.writeTextFile || toToolKind(input.toolName) !== "edit") return
+  if (!input.connection.writeTextFile || toToolKind(input.toolName) !== "edit") return
  const files = Array.isArray(input.structured.files)
    ? input.structured.files.flatMap((file): string[] => {
        if (!file || typeof file !== "object") return []
@@ -16,8 +16,6 @@ import type {
  CancelNotification,
  CloseSessionRequest,
  CloseSessionResponse,
-  DeleteSessionRequest,
-  DeleteSessionResponse,
  ForkSessionRequest,
  ForkSessionResponse,
  InitializeRequest,
@@ -35,6 +33,8 @@ import type {
  ResumeSessionResponse,
  SetSessionConfigOptionRequest,
  SetSessionConfigOptionResponse,
+  SetSessionModelRequest,
+  SetSessionModelResponse,
  SetSessionModeRequest,
  SetSessionModeResponse,
 } from "@agentclientprotocol/sdk"
@@ -47,8 +47,7 @@ import { ACPError } from "./error"

 export const AuthMethodID = "opencode-login"

-type Connection = Pick<AgentSideConnection, "sessionUpdate" | "requestPermission"> &
-  Partial<Pick<AgentSideConnection, "writeTextFile">>
+type Connection = Pick<AgentSideConnection, "sessionUpdate" | "requestPermission">

 type Catalog = {
  readonly providers: ConfigOptionProvider[]
@@ -84,12 +83,12 @@ export interface Interface {
  newSession(input: NewSessionRequest): Promise<NewSessionResponse>
  loadSession(input: LoadSessionRequest): Promise<LoadSessionResponse>
  listSessions(input: ListSessionsRequest): Promise<ListSessionsResponse>
-  deleteSession(input: DeleteSessionRequest): Promise<DeleteSessionResponse>
  resumeSession(input: ResumeSessionRequest): Promise<ResumeSessionResponse>
  closeSession(input: CloseSessionRequest): Promise<CloseSessionResponse>
  forkSession(input: ForkSessionRequest): Promise<ForkSessionResponse>
  setSessionConfigOption(input: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>
  setSessionMode(input: SetSessionModeRequest): Promise<SetSessionModeResponse>
+  setSessionModel(input: SetSessionModelRequest): Promise<SetSessionModelResponse>
  prompt(input: PromptRequest): Promise<PromptResponse>
  cancel(input: CancelNotification): Promise<void>
 }
@@ -99,7 +98,6 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
  const catalogs = new Map<string, Promise<Catalog>>()
  const registeredMcp = new Map<string, Set<string>>()
  const active = new Map<string, TurnControl>()
-  const capabilities = { writeTextFile: false }

  const catalog = (cwd: string) => {
    const cached = catalogs.get(cwd)
@@ -159,7 +157,6 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti

  return {
    initialize: async (params) => {
-      capabilities.writeTextFile = params.clientCapabilities?.fs?.writeTextFile === true
      const authMethod: AuthMethod = {
        description: "Run `opencode auth login` in the terminal",
        name: "Login with opencode",
@@ -176,7 +173,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
          loadSession: true,
          mcpCapabilities: { http: true, sse: false },
          promptCapabilities: { embeddedContext: true, image: true },
-          sessionCapabilities: { close: {}, delete: {}, fork: {}, list: {}, resume: {} },
+          sessionCapabilities: { close: {}, fork: {}, list: {}, resume: {} },
        },
        authMethods: [authMethod],
        agentInfo: { name: "OpenCode", version: OPENCODE_VERSION },
@@ -219,14 +216,6 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
        ...(page.cursor.next ? { nextCursor: page.cursor.next } : {}),
      }
    },
-    deleteSession: async (params) => {
-      await input.client.session.remove({ sessionID: params.sessionId }).catch((error) => {
-        if (!isSessionNotFoundError(error)) throw error
-      })
-      sessions.delete(params.sessionId)
-      registeredMcp.delete(params.sessionId)
-      return {}
-    },
    resumeSession: async (params) => {
      const session = await getSession(input.client, params.sessionId)
      const state = await attach(session, session.location.directory, params.mcpServers ?? [])
@@ -281,6 +270,13 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
      await selectMode(input.client, await requireSession(params.sessionId), params.modeId)
      return {}
    },
+    setSessionModel: async (params) => {
+      const state = await requireSession(params.sessionId)
+      const selected = requireModel(state.catalog, params.modelId)
+      state.model = selected
+      await input.client.session.switchModel({ sessionID: state.id, model: selected })
+      return {}
+    },
    prompt: async (params) => {
      const state = await requireSession(params.sessionId)
      if (active.has(state.id)) {
@@ -299,7 +295,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
        sessionID: state.id,
        cwd: state.cwd,
        start: prepared.start,
-        writeTextFile: capabilities.writeTextFile,
+        userMessageID: params.messageId,
        control,
        submit: (signal) => submitPrompt(input.client, state, prepared, signal),
      }).finally(() => {
@@ -483,7 +479,6 @@ async function registerMcpServers(

 function mcpConfig(server: McpServer) {
  if ("type" in server) {
-    if (server.type === "acp") throw new Error("MCP-over-ACP is not supported")
    return {
      type: "remote" as const,
      url: server.url,
@@ -32,7 +32,6 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
      Flag.withDescription("Session ID to continue"),
      Flag.optional,
    ),
-    prompt: Flag.string("prompt").pipe(Flag.withDescription("Prompt to use"), Flag.optional),
  },
  commands: [
    Spec.make("acp", { description: "Start an Agent Client Protocol server" }),
@@ -140,11 +139,11 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
          Flag.withDefault(false),
        ),
        replay: Flag.boolean("replay").pipe(
-          Flag.withDescription("Restore session history on resume and resize (disable with --no-replay)"),
-          Flag.optional,
+          Flag.withDescription("Replay session history on resume and after resize"),
+          Flag.withDefault(true),
        ),
        replayLimit: Flag.integer("replay-limit").pipe(
-          Flag.withDescription("Limit replay to the newest N messages (default: 200)"),
+          Flag.withDescription("Cap visible replay to the newest N messages"),
          Flag.optional,
        ),
        model: Flag.string("model").pipe(
@@ -55,11 +55,7 @@ export default Runtime.handler(Commands, (input) =>
            }
          : undefined,
      },
-      args: {
-        continue: input.continue,
-        sessionID: Option.getOrUndefined(input.session),
-        prompt: Option.getOrUndefined(input.prompt),
-      },
+      args: { continue: input.continue, sessionID: Option.getOrUndefined(input.session) },
      config: {
        path: config.path,
        get: () => runPromise(config.get()),
@@ -28,8 +28,8 @@ export default Runtime.handler(Commands.commands.mini, (input) =>
        model: Option.getOrUndefined(input.model),
        agent: Option.getOrUndefined(input.agent),
        prompt: Option.getOrUndefined(input.prompt),
-        replay: Option.getOrUndefined(input.replay) ?? resolved.mini?.replay ?? true,
-        replayLimit: Option.getOrUndefined(input.replayLimit) ?? resolved.mini?.replay_limit,
+        replay: input.replay,
+        replayLimit: Option.getOrUndefined(input.replayLimit),
        demo: input.demo,
        tuiConfig: resolved,
        config: {
@@ -2,6 +2,7 @@ import { Service, type Endpoint } from "@opencode-ai/client/effect/service"
 import { ClientError, OpenCode, type OpenCodeClient } from "@opencode-ai/client/promise"
 import type { MiniFrontendInput } from "@opencode-ai/tui/mini"
 import { setTimeout } from "node:timers/promises"
+import { waitForCatalogReady } from "./services/catalog"
 import { readStdin } from "./util/io"
 import { createMiniHost, INTERACTIVE_INPUT_ERROR, usingInteractiveStdin } from "./mini-host"
 import { parseSessionTargetModel, resolveSessionTarget, type SessionTargetPreparation } from "./session-target"
@@ -213,7 +214,63 @@ function parseModel(value?: string) {
 }

 function prepareTarget(requestedAgent?: string): SessionTargetPreparation {
-  return async (input) => ({ model: input.model, agent: requestedAgent ?? input.agent })
+  return async (input) => {
+    if (input.model)
+      await waitForCatalogReady({
+        sdk: input.client,
+        directory: input.location.directory,
+        workspace: input.location.workspaceID,
+        model: { providerID: input.model.providerID, modelID: input.model.id },
+        signal: input.signal,
+      })
+    return {
+      model: input.model,
+      agent: requestedAgent
+        ? await validateAgent(
+            input.client,
+            input.location.directory,
+            input.location.workspaceID,
+            requestedAgent,
+            input.signal,
+          )
+        : input.agent,
+    }
+  }
+}
+
+async function validateAgent(
+  sdk: OpenCodeClient,
+  directory: string,
+  workspace: string | undefined,
+  name?: string,
+  signal?: AbortSignal,
+) {
+  if (!name) return
+  const deadline = Date.now() + 5_000
+  let agents: Awaited<ReturnType<OpenCodeClient["agent"]["list"]>> | undefined
+  while (Date.now() < deadline && !signal?.aborted) {
+    agents = await sdk.agent.list({ location: { directory, workspace } }, { signal }).catch((error) => {
+      if (signal && error instanceof ClientError && error.reason === "Transport") throw error
+      return undefined
+    })
+    const agent = agents?.data.find((item) => item.id === name)
+    if (agent?.mode === "subagent") {
+      warning(`agent "${name}" is a subagent, not a primary agent. Falling back to default agent`)
+      return
+    }
+    if (agent) return name
+    await setTimeout(25, undefined, { signal }).catch(() => {})
+  }
+  if (signal?.aborted) return
+  if (!agents) {
+    warning("failed to list agents. Falling back to default agent")
+    return
+  }
+  warning(`agent "${name}" not found. Falling back to default agent`)
+}
+
+function warning(message: string) {
+  process.stderr.write(`\x1b[93m\x1b[1m!\x1b[0m ${message}\n`)
 }

 function fail(message: string): never {
@@ -211,17 +211,10 @@ export async function runNonInteractivePrompt(input: Input) {
      }
      if (!promoted && event.type === "session.execution.failed") {
        prePromotionError = event.data.error
-        if (finalizing) return
        continue
      }
-      if (
-        !promoted &&
-        finalizing &&
-        (event.type === "session.execution.succeeded" || event.type === "session.execution.interrupted")
-      )
-        return
      if (!promoted) continue
-      if (finalizing && !event.type.startsWith("session.execution.")) continue
+      if (finalizing) continue

      if (event.type === "session.step.started") {
        const part = {
@@ -398,8 +391,6 @@ export async function runNonInteractivePrompt(input: Input) {
        const key = toolKey(event.data.assistantMessageID, event.data.callID)
        const current = tools.get(key) ?? fallbackTool(event)
        const error = event.data.error.message
-        const structured = event.data.metadata ?? current.structured
-        const content = event.data.content ?? current.content
        const tool: SessionMessageAssistantTool = {
          type: "tool",
          id: event.data.callID,
@@ -410,8 +401,8 @@ export async function runNonInteractivePrompt(input: Input) {
          state: {
            status: "error",
            input: current.input,
-            structured,
-            content,
+            structured: current.structured,
+            content: current.content,
            error: event.data.error,
            result: event.data.result,
          },
@@ -441,14 +432,14 @@ export async function runNonInteractivePrompt(input: Input) {
        renderedTools.add(key)
        if (input.compatibility === "v1" && (permissionRejected || formCancelled)) continue
        if (!emit("tool_use", time, { part })) {
-          if (toolOutputText(current.tool, content).trim())
+          if (toolOutputText(current.tool, current.content).trim())
            await input.renderTool({
              ...tool,
              state: {
                status: "completed",
                input: current.input,
-                structured,
-                content,
+                structured: current.structured,
+                content: current.content,
                result: event.data.result,
              },
            })
@@ -627,10 +618,7 @@ export async function runNonInteractivePrompt(input: Input) {
        if (!emit("error", timestamp, { error: message.error })) UI.error(message.error.message)
      }
    }
-    return {
-      found: projected.found,
-      responded: projected.messages.some((message) => message.type === "assistant"),
-    }
+    return projected.found
  }

  const interrupt = () => {
@@ -720,18 +708,9 @@ export async function runNonInteractivePrompt(input: Input) {
    const waiting = input.client.session.wait({ sessionID: input.sessionID })
    await Promise.race([waiting, completed.then(() => waiting)])
    finalizing = true
-    const projected = await reconcile()
-    if (
-      !projected.responded &&
-      !interrupted &&
-      !permissionRejected &&
-      !formCancelled &&
-      !emittedError &&
-      !prePromotionError
-    ) {
-      await completed
-    }
-    if (!projected.found && !interrupted && !permissionRejected && !formCancelled && !emittedError) {
+    controller.abort()
+    const found = await reconcile()
+    if (!found && !interrupted && !permissionRejected && !formCancelled && !emittedError) {
      const error = prePromotionError ?? { type: "unknown", message: "Prompt was not promoted" }
      emittedError = true
      process.exitCode = 1
@@ -5,6 +5,7 @@ import { open } from "node:fs/promises"
 import path from "node:path"
 import { readStdin } from "../util/io"
 import { ServerConnection } from "../services/server-connection"
+import { waitForCatalogReady } from "../services/catalog"
 import { parseSessionTargetModel, resolveSessionTarget } from "../session-target"
 import { toolInlineInfo } from "@opencode-ai/tui/mini/tool"
 import { runNonInteractivePrompt } from "./noninteractive"
@@ -94,11 +95,9 @@ async function execute(input: RunCommandInput, prepared: Prepared, endpoint: End
    prepare: async (next) => {
      const selected =
        next.model ??
-        (options.variant
-          ? await client.model
-              .default({ location: { directory: next.location.directory, workspace: next.location.workspaceID } })
-              .then((result) => result.data)
-          : undefined)
+        (await client.model
+          .default({ location: { directory: next.location.directory, workspace: next.location.workspaceID } })
+          .then((result) => result.data))
      const model = selected
        ? {
            providerID: selected.providerID,
@@ -108,7 +107,25 @@ async function execute(input: RunCommandInput, prepared: Prepared, endpoint: End
        : undefined
      if ((options.variant ?? explicit?.variant) && !model)
        throw new RunTargetError("Cannot select a variant before selecting a model", next.session?.id)
-      return { model, agent: next.agent }
+      if (model) {
+        await waitForCatalogReady({
+          sdk: client,
+          directory: next.location.directory,
+          workspace: next.location.workspaceID,
+          model: { providerID: model.providerID, modelID: model.id },
+        })
+        const available = await client.model.list({
+          location: { directory: next.location.directory, workspace: next.location.workspaceID },
+        })
+        if (!available.data.some((item) => item.providerID === model.providerID && item.id === model.id))
+          throw new RunTargetError(`Model unavailable: ${model.providerID}/${model.id}`, next.session?.id)
+      }
+      return {
+        model,
+        agent: input.agent
+          ? await validateAgent(client, next.location.directory, next.location.workspaceID, input.agent)
+          : next.agent,
+      }
    },
  }).catch((error) => {
    if (!(error instanceof RunTargetError)) throw error
@@ -173,6 +190,28 @@ export function parseRunModel(value?: string) {
  }
 }

+async function validateAgent(client: OpenCodeClient, directory: string, workspace: string | undefined, name?: string) {
+  if (!name) return
+  const agents = await client.agent
+    .list({ location: { directory, workspace } })
+    .then((result) => result.data)
+    .catch(() => undefined)
+  if (!agents) {
+    warning("failed to list agents. Falling back to default agent")
+    return
+  }
+  const agent = agents.find((item) => item.id === name)
+  if (!agent) {
+    warning(`agent "${name}" not found. Falling back to default agent`)
+    return
+  }
+  if (agent.mode === "subagent") {
+    warning(`agent "${name}" is a subagent, not a primary agent. Falling back to default agent`)
+    return
+  }
+  return name
+}
+
 async function prepareFile(input: string, directory: string, options: ExecutionOptions): Promise<FilePart> {
  const file = path.resolve(directory, input)
  const handle = await open(file, "r").catch(() => fail(`File not found: ${input}`))
@@ -0,0 +1,43 @@
+import { ClientError, type OpenCodeClient } from "@opencode-ai/client/promise"
+
+// Location plugins initialize asynchronously, so explicit model selection must
+// wait for that exact model before prompt admission. The execution path owns
+// the authoritative error if readiness times out.
+export async function waitForCatalogReady(input: {
+  sdk: OpenCodeClient
+  directory: string
+  workspace?: string
+  model: { providerID: string; modelID: string }
+  timeoutMs?: number
+  signal?: AbortSignal
+}) {
+  const deadline = Date.now() + (input.timeoutMs ?? 5_000)
+  while (Date.now() < deadline && !input.signal?.aborted) {
+    const models = await input.sdk.model
+      .list(
+        { location: { directory: input.directory, workspace: input.workspace } },
+        { signal: input.signal },
+      )
+      .then((result) => result.data)
+      .catch((error) => {
+        if (input.signal && error instanceof ClientError && error.reason === "Transport") throw error
+        return undefined
+      })
+    if (models?.some((model) => model.providerID === input.model.providerID && model.id === input.model.modelID)) return
+    await wait(25, input.signal)
+  }
+}
+
+function wait(delay: number, signal?: AbortSignal) {
+  if (!signal) return new Promise<void>((resolve) => setTimeout(resolve, delay))
+  if (signal.aborted) return Promise.resolve()
+  return new Promise<void>((resolve) => {
+    const timer = setTimeout(done, delay)
+    signal.addEventListener("abort", done, { once: true })
+    function done() {
+      clearTimeout(timer)
+      signal?.removeEventListener("abort", done)
+      resolve()
+    }
+  })
+}
@@ -95,7 +95,7 @@ export const layer = Layer.effect(
      const response = yield* Effect.tryPromise({
        try: () =>
          fetch(
-            `https://update.opencode.ai/api/${encodeURIComponent(channel)}/cli/npm`,
+            `https://registry.npmjs.org/${encodeURIComponent(packageName)}/${encodeURIComponent(OPENCODE_CHANNEL)}`,
            { headers: { "User-Agent": `opencode/${OPENCODE_VERSION}` }, signal: AbortSignal.timeout(10_000) },
          ),
        catch: (cause) => new Error("Failed to check for updates", { cause }),
@@ -74,7 +74,7 @@ export async function resolveSessionTarget(input: {
    session,
    location,
    model: prepared.model,
-    agent: prepared.agent ?? session.agent,
+    agent: prepared.agent,
    resume: selected !== undefined,
  }
 }
@@ -214,7 +214,7 @@ describe("acp event behavior", () => {
          }),
        )
        send(
-          ephemeralEvent("session.tool.progress", {
+          durableEvent("session.tool.progress", {
            sessionID: "ses_tools",
            assistantMessageID: "msg_tools",
            callID: "call_ok",
@@ -251,7 +251,7 @@ describe("acp event behavior", () => {
          }),
        )
        send(
-          ephemeralEvent("session.tool.progress", {
+          durableEvent("session.tool.progress", {
            sessionID: "ses_tools",
            assistantMessageID: "msg_tools",
            callID: "call_fail",
@@ -265,8 +265,6 @@ describe("acp event behavior", () => {
            assistantMessageID: "msg_tools",
            callID: "call_fail",
            error: { type: "tool.error", message: "not found" },
-            metadata: { bytes: 0 },
-            content: [{ type: "text", text: "opening" }],
            executed: true,
          }),
        )
@@ -439,7 +437,6 @@ describe("acp event behavior", () => {
      sessionID: "ses_cancel",
      cwd: "/workspace",
      start: { type: "input", id: "input_cancel" },
-      writeTextFile: false,
      control,
      submit: async (signal) => {
        await fixture.client.session.prompt(
@@ -482,7 +479,6 @@ describe("acp event behavior", () => {
      sessionID: "ses_cancel_admission",
      cwd: "/workspace",
      start: { type: "input", id: "input_cancel_admission" },
-      writeTextFile: false,
      control,
      submit: (signal) =>
        fixture.client.session.prompt(
@@ -568,7 +564,7 @@ function turn(input: {
    sessionID: input.sessionID,
    cwd: "/workspace",
    start: { type: "input", id: input.inputID },
-    writeTextFile: false,
+    userMessageID: `client_${input.inputID}`,
    control: { cancelled: false, admission: new AbortController() },
    submit: (signal) =>
      input.fixture.client.session.prompt({ sessionID: input.sessionID, id: input.inputID, text: "hello" }, { signal }),
@@ -85,6 +85,7 @@ test("acp prompt resolves after ordered turn updates", async () => {

  try {
    const id = "msg_prompt"
+    const userMessageID = "client-message"
    const response = await streamTurn({
      client,
      connection: {
@@ -96,7 +97,7 @@ test("acp prompt resolves after ordered turn updates", async () => {
      sessionID: "ses_test",
      cwd: "/workspace",
      start: { type: "input", id },
-      writeTextFile: false,
+      userMessageID,
      control: { cancelled: false, admission: new AbortController() },
      submit: () => client.session.prompt({ sessionID: "ses_test", id, text: "hi" }),
    })
@@ -111,7 +112,7 @@ test("acp prompt resolves after ordered turn updates", async () => {
        },
      },
    ])
-    expect(response).toMatchObject({ stopReason: "end_turn", usage: { totalTokens: 2 } })
+    expect(response).toMatchObject({ stopReason: "end_turn", userMessageId: userMessageID, usage: { totalTokens: 2 } })
  } finally {
    events?.close()
    await server.stop(true)
@@ -14,7 +14,6 @@ describe("acp initialize/auth subprocess", () => {
    expect(initialized.agentCapabilities?.mcpCapabilities?.sse).toBe(false)
    expect(initialized.agentCapabilities?.loadSession).toBe(true)
    expect(initialized.agentCapabilities?.sessionCapabilities?.close).toEqual({})
-    expect(initialized.agentCapabilities?.sessionCapabilities?.delete).toEqual({})
    expect(initialized.agentCapabilities?.sessionCapabilities?.fork).toEqual({})
    expect(initialized.agentCapabilities?.sessionCapabilities?.list).toEqual({})
    expect(initialized.agentCapabilities?.sessionCapabilities?.resume).toEqual({})
@@ -1,6 +1,5 @@
 import type {
  CloseSessionResponse,
-  DeleteSessionResponse,
  ListSessionsResponse,
  LoadSessionResponse,
  ResumeSessionResponse,
@@ -61,20 +60,6 @@ describe("acp lifecycle subprocess", () => {
    expect(listed.sessions.some((item) => item.sessionId === session.sessionId)).toBe(true)
  }, 60_000)

-  test("delete capability and delete request", async () => {
-    await using fixture = await createAcpFixture()
-    const acp = fixture.spawn()
-    const initialized = await initialize(acp)
-    expect(initialized.agentCapabilities?.sessionCapabilities?.delete).toEqual({})
-    const session = await newSession(acp, fixture.home)
-
-    expect(
-      expectOk(await acp.request<DeleteSessionResponse>("session/delete", { sessionId: session.sessionId })),
-    ).toEqual({})
-    const listed = expectOk(await acp.request<ListSessionsResponse>("session/list", { cwd: fixture.home }))
-    expect(listed.sessions.some((item) => item.sessionId === session.sessionId)).toBe(false)
-  }, 60_000)
-
  test("resume capability advertisement", async () => {
    await using fixture = await createAcpFixture()
    const initialized = await initialize(fixture.spawn())
@@ -4,7 +4,6 @@ import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
 import { streamTurn } from "../../src/acp/event"
-import { syncEditedFiles } from "../../src/acp/permission"
 import { createSseFixture, durableEvent, ephemeralEvent, withTimeout } from "./sse-fixture"

 type SessionUpdateParams = Parameters<AgentSideConnection["sessionUpdate"]>[0]
@@ -13,27 +12,6 @@ type Connection = Pick<AgentSideConnection, "sessionUpdate" | "requestPermission
 type Fixture = ReturnType<typeof createSseFixture>

 describe("acp permission behavior", () => {
-  test("does not sync edits when writeTextFile was not advertised", async () => {
-    const writes: Parameters<AgentSideConnection["writeTextFile"]>[0][] = []
-
-    await syncEditedFiles({
-      connection: {
-        writeTextFile: async (input) => {
-          writes.push(input)
-          return {}
-        },
-      },
-      writeTextFile: false,
-      sessionID: "ses_no_write",
-      cwd: "/workspace",
-      toolName: "edit",
-      toolInput: { filePath: "/workspace/file.ts" },
-      structured: {},
-    })
-
-    expect(writes).toEqual([])
-  })
-
  test("forwards allow-once and allow-always selections to the generated client", async () => {
    const permissionRequests: RequestPermissionRequest[] = []
    const fixture = createSseFixture({
@@ -487,7 +465,6 @@ function startTurn(fixture: Fixture, connection: Connection, sessionID: string,
    sessionID,
    cwd,
    start: { type: "input", id: inputID },
-    writeTextFile: true,
    control: { cancelled: false, admission: new AbortController() },
    submit: (signal) => fixture.client.session.prompt({ sessionID, id: inputID, text: "hello" }, { signal }),
  })
@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { McpServer, SessionConfigOption } from "@agentclientprotocol/sdk"
-import { makeACPFixture, makeSession, secondModel } from "./service-fixture"
+import { makeACPFixture, makeSession, secondModel, testModel } from "./service-fixture"

 describe("acp service directory behavior", () => {
  test("creates sessions from a catalog shared by concurrent callers in the same cwd", async () => {
@@ -134,6 +134,7 @@ describe("acp service directory behavior", () => {
      configId: "mode",
      value: "plan",
    })
+    await fixture.service.setSessionModel({ sessionId: session.sessionId, modelId: "test/test-model/high" })
    await fixture.service.setSessionMode({ sessionId: session.sessionId, modeId: "build" })

    expect(currentValue(selectedModel, "model")).toBe("test/second-model")
@@ -147,6 +148,7 @@ describe("acp service directory behavior", () => {
    ).toEqual([
      { model: { providerID: "test", id: secondModel.id } },
      { model: { providerID: "test", id: secondModel.id, variant: "medium" } },
+      { model: { providerID: "test", id: testModel.id, variant: "high" } },
    ])
    expect(
      fixture.requests
@@ -225,33 +225,6 @@ describe("acp service lifecycle", () => {
      "/api/session/missing/interrupt",
    ])
  })
-
-  test("deletes sessions from backing and local storage", async () => {
-    await using fixture = makeACPFixture({
-      fetch(request) {
-        if (request.method === "POST" && request.path === "/api/session") {
-          return Response.json({ data: makeSession("ses_delete") })
-        }
-        if (request.method === "DELETE" && request.path === "/api/session/ses_delete") {
-          return new Response(null, { status: 204 })
-        }
-        return undefined
-      },
-    })
-    const session = await fixture.service.newSession({ cwd: "/workspace", mcpServers: [] })
-
-    expect(await fixture.service.deleteSession({ sessionId: session.sessionId })).toEqual({})
-    expect(fixture.requests).toContainEqual({
-      method: "DELETE",
-      path: "/api/session/ses_delete",
-      query: {},
-      body: undefined,
-    })
-    const missing = await fixture.service
-      .setSessionConfigOption({ sessionId: session.sessionId, configId: "effort", value: "high" })
-      .catch((error: unknown) => error)
-    expect(missing).toMatchObject({ _tag: "ACPSessionNotFoundError", sessionId: session.sessionId })
-  })
 })

 function currentValue(result: { readonly configOptions?: readonly SessionConfigOption[] | null }, id: string) {
@@ -45,14 +45,17 @@ describe("acp service prompt routing and usage", () => {

    const commandResult = await fixture.service.prompt({
      sessionId: session.sessionId,
+      messageId: "client-command",
      prompt: [{ type: "text", text: "/review now" }],
    })
    const skillResult = await fixture.service.prompt({
      sessionId: session.sessionId,
+      messageId: "client-skill",
      prompt: [{ type: "text", text: "/verify" }],
    })
    const compactResult = await fixture.service.prompt({
      sessionId: session.sessionId,
+      messageId: "client-compact",
      prompt: [{ type: "text", text: "/compact" }],
    })

@@ -151,11 +154,13 @@ describe("acp service prompt routing and usage", () => {

    const response = await fixture.service.prompt({
      sessionId: session.sessionId,
+      messageId: "client-message",
      prompt: [{ type: "text", text: "hello" }],
    })

    expect(response).toEqual({
      stopReason: "end_turn",
+      userMessageId: "client-message",
      usage: {
        inputTokens: 100,
        outputTokens: 40,
@@ -131,7 +131,7 @@ test("updates a config draft while preserving JSONC comments", async () => {
        const service = yield* Config.Service
        return yield* service.update((draft) => {
          draft.prompt = { paste: "compact" }
-          draft.mini = { thinking: "hide", shell_output: "hide", turn_summary: "hide", splash: "hide", mono: true }
+          draft.mini = { thinking: "hide", shell_output: "hide", turn_summary: "hide", mono: true }
        })
      }),
    )
@@ -139,7 +139,7 @@ test("updates a config draft while preserving JSONC comments", async () => {
    expect(config).toEqual({
      animations: true,
      prompt: { paste: "compact" },
-      mini: { thinking: "hide", shell_output: "hide", turn_summary: "hide", splash: "hide", mono: true },
+      mini: { thinking: "hide", shell_output: "hide", turn_summary: "hide", mono: true },
    })
    expect(await Bun.file(path.join(directory, "cli.json")).text()).toContain("// Keep this comment")
  } finally {
@@ -16,30 +16,7 @@ export default defineScript({
      const preload = Bun.resolveSync("@opentui/solid/preload", path.join(root, "packages/cli"))
      const session = `mini-stage2-${process.pid}`
      const snapshots = path.join(artifacts, "mini-stage2")
-      const explicitDirectory = path.join(artifacts, "explicit-model")
-      yield* Effect.promise(() => Promise.all([snapshots, explicitDirectory].map((dir) => mkdir(dir, { recursive: true }))))
-      /** @param {string} directory @param {string | undefined} model */
-      const mini = (directory, model) => [
-        "env",
-        `PWD=${directory}`,
-        `OPENCODE_PASSWORD=${registration.password}`,
-        `OPENCODE_CONFIG_DIR=${path.join(artifacts, "files/.opencode")}`,
-        `OPENCODE_TEST_HOME=${artifacts}`,
-        `XDG_CACHE_HOME=${path.join(artifacts, "home/.cache")}`,
-        `XDG_CONFIG_HOME=${path.join(artifacts, "home/.config")}`,
-        `XDG_DATA_HOME=${path.join(artifacts, "logs")}`,
-        `XDG_STATE_HOME=${path.join(artifacts, "home/.local/state")}`,
-        "OPENCODE_DISABLE_AUTOUPDATE=1",
-        "OPENCODE_DIRECT_TRACE=1",
-        process.execPath,
-        "--conditions=browser",
-        `--preload=${preload}`,
-        path.join(root, "packages/cli/src/index.ts"),
-        "mini",
-        "--server",
-        registration.url,
-        ...(model ? ["--model", model] : []),
-      ]
+      yield* Effect.promise(() => mkdir(snapshots, { recursive: true }))

      yield* llm.queue(
        Llm.toolCall({
@@ -65,7 +42,26 @@ export default defineScript({
              "-y",
              "30",
              "--",
-              ...mini(path.join(artifacts, "files"), undefined),
+              "env",
+              `PWD=${path.join(artifacts, "files")}`,
+              `OPENCODE_PASSWORD=${registration.password}`,
+              `OPENCODE_CONFIG_DIR=${path.join(artifacts, "files/.opencode")}`,
+              `OPENCODE_TEST_HOME=${artifacts}`,
+              `XDG_CACHE_HOME=${path.join(artifacts, "home/.cache")}`,
+              `XDG_CONFIG_HOME=${path.join(artifacts, "home/.config")}`,
+              `XDG_DATA_HOME=${path.join(artifacts, "logs")}`,
+              `XDG_STATE_HOME=${path.join(artifacts, "home/.local/state")}`,
+              "OPENCODE_DISABLE_AUTOUPDATE=1",
+              "OPENCODE_DIRECT_TRACE=1",
+              process.execPath,
+              "--conditions=browser",
+              `--preload=${preload}`,
+              path.join(root, "packages/cli/src/index.ts"),
+              "mini",
+              "--server",
+              registration.url,
+              "--model",
+              "simulation/gpt-sim-model",
            ]),
          ),
        )
@@ -76,16 +72,7 @@ export default defineScript({
        if (first.includes("drive mini response complete"))
          throw new Error("response rendered before prompt submission")

-        yield* Effect.promise(() => waitForPane(session, "Default model", 15_000))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-p"]))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Commands"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "model"]))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Switch model"))
-        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Select model"))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Simulated Model", 15_000))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "Escape"]))
-        yield* Effect.promise(() => waitForVisiblePane(session, "Ask anything..."))
+        yield* Effect.promise(() => waitForPane(session, "Simulated Model", 15_000))
        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "-l", "exercise the mini frontend"]))
        yield* Effect.sleep(100)
        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
@@ -147,7 +134,7 @@ export default defineScript({
        yield* Effect.promise(() => tmux(["send-keys", "-H", "-t", session, "0d"]))
        yield* Effect.promise(() => waitForPane(session, "$ sleep 10"))
        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "Escape"]))
-        const armed = yield* Effect.promise(() => waitForPane(session, "esc again"))
+        const armed = yield* Effect.promise(() => waitForPane(session, "again to interrupt"))
        yield* Effect.promise(() => Bun.write(path.join(snapshots, "04-interrupt-armed.txt"), armed))
        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "Escape"]))
        const interrupted = yield* Effect.promise(() => waitForPane(session, "Step interrupted", 10_000))
@@ -157,7 +144,7 @@ export default defineScript({
          if (!(await paneAlive(session))) throw new Error("Mini exited while interrupting an active turn")
        })
        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForPane(session, "EXIT  Press ctrl+"))
+        yield* Effect.promise(() => waitForPane(session, "Press ctrl+c again to exit"))
        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
        yield* Effect.promise(() => waitForDeadPane(session))
        const status = yield* Effect.promise(() => paneDeadStatus(session))
@@ -166,75 +153,6 @@ export default defineScript({
        if (!exited.includes("Continue") || !exited.includes("opencode mini -s"))
          throw new Error("Mini exit splash was not rendered before teardown")
        yield* Effect.promise(() => Bun.write(path.join(snapshots, "06-exit-teardown.txt"), exited))
-
-        yield* Effect.promise(() => tmux(["clear-history", "-t", session]))
-        yield* Effect.promise(() =>
-          tmux([
-            "respawn-pane",
-            "-k",
-            "-t",
-            session,
-            "--",
-            ...mini(explicitDirectory, "simulation/gpt-sim-model"),
-          ]),
-        )
-        const explicitModel = yield* Effect.promise(() => waitForPane(session, "Simulated Model", 15_000))
-        yield* Effect.promise(() => Bun.write(path.join(snapshots, "07-explicit-model.txt"), explicitModel))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForPane(session, "EXIT  Press ctrl+"))
-        yield* Effect.promise(() => tmux(["send-keys", "-t", session, "C-c"]))
-        yield* Effect.promise(() => waitForDeadPane(session))
-        if ((yield* Effect.promise(() => paneDeadStatus(session))) !== 0)
-          throw new Error("Explicit-model Mini did not exit cleanly")
-
-        yield* Effect.promise(async () => {
-          for (const failure of [
-            {
-              args: ["--model", "simulation/definitely-missing"],
-              capture: "08-unavailable-model.txt",
-              expected: "Model unavailable: simulation/definitely-missing",
-            },
-            {
-              args: ["--agent", "definitely-missing"],
-              capture: "09-unavailable-agent.txt",
-              expected: 'Agent not found: "definitely-missing"',
-            },
-          ]) {
-            const child = Bun.spawn(
-              [
-                process.execPath,
-                path.join(root, "packages/cli/src/index.ts"),
-                "run",
-                "--server",
-                registration.url,
-                ...failure.args,
-                "optimistic selection check",
-              ],
-              {
-                cwd: path.join(root, "packages/cli"),
-                env: {
-                  ...process.env,
-                  PWD: path.join(artifacts, "files"),
-                  OPENCODE_PASSWORD: registration.password,
-                  OPENCODE_CONFIG_DIR: path.join(artifacts, "files/.opencode"),
-                  OPENCODE_DISABLE_AUTOUPDATE: "1",
-                },
-                stdin: "ignore",
-                stdout: "pipe",
-                stderr: "pipe",
-              },
-            )
-            const [exitCode, stdout, stderr] = await Promise.all([
-              child.exited,
-              new Response(child.stdout).text(),
-              new Response(child.stderr).text(),
-            ])
-            await Bun.write(path.join(snapshots, failure.capture), stdout + stderr)
-            if (exitCode !== 1) throw new Error(`${failure.expected} run exited with status ${exitCode}`)
-            if (!stderr.includes(failure.expected))
-              throw new Error(`Selection failure was not diagnosed by execution: ${stderr}`)
-          }
-        })
      })

      yield* journey.pipe(Effect.ensuring(Effect.promise(() => tmux(["kill-session", "-t", session], true))))
@@ -270,19 +188,6 @@ function captureVisiblePane(session) {
  return tmux(["capture-pane", "-p", "-t", session])
 }

-/** @param {string} session @param {string} text @param {number} [timeout] */
-async function waitForVisiblePane(session, text, timeout = 5_000) {
-  const deadline = Date.now() + timeout
-  let last = ""
-  while (Date.now() < deadline) {
-    last = await captureVisiblePane(session)
-    if (last.includes(text)) return last
-    if (!(await paneAlive(session))) throw new Error(`Mini exited before rendering ${JSON.stringify(text)}:\n${last}`)
-    await Bun.sleep(50)
-  }
-  throw new Error(`Timed out waiting for visible ${JSON.stringify(text)}:\n${last}`)
-}
-
 /** @param {string} session */
 async function paneAlive(session) {
  return (await tmux(["display-message", "-p", "-t", session, "#{pane_dead}"], true)).trim() === "0"
@@ -18,12 +18,10 @@ describe("CLI frontend import boundaries", () => {
  test("exposes only the intentional package entrypoints", async () => {
    const run = await import("@opencode-ai/cli/run")
    const mini = await import("@opencode-ai/tui/mini")
-    const tool = await import("@opencode-ai/tui/mini/tool")
    const cli = await Bun.file(path.join(root, "packages/cli/package.json")).json()

    expect(Object.keys(run).sort()).toEqual(["runNonInteractive", "runV1Bridge"])
    expect(Object.keys(mini).sort()).toEqual(["runMiniFrontend"])
-    expect(Object.keys(tool).sort()).toEqual(["toolInlineInfo", "toolOutputText"])
    expect(Object.keys(cli.exports).filter((key) => key === "./mini" || key.startsWith("./mini/"))).toEqual([])
  })

@@ -121,12 +121,11 @@ describe("mini command", () => {
    expect(result.stdout).toContain("run        Run OpenCode with a message")
  })

-  test("exposes run without legacy interactive, attach, or command modes", async () => {
+  test("exposes run without legacy attach or command modes", async () => {
    const result = await cli(["run", "--help"])

    expect(result.exitCode).toBe(0)
    expect(result.stdout).toContain("--server string")
-    expect(result.stdout).not.toContain("--interactive")
    expect(result.stdout).not.toContain("--variant")
    expect(result.stdout).not.toContain("--attach")
    expect(result.stdout).not.toContain("--command")
@@ -139,47 +138,32 @@ describe("mini command", () => {
    expect(result.stderr).not.toContain("You must provide a message")
  })

-  test("passes explicit selections to session creation without catalog preflight", async () => {
-    const requests: string[] = []
-    let session: unknown
+  test("preserves a run failure exit code", async () => {
+    let modelRequests = 0
    const server = Bun.serve({
      port: 0,
-      async fetch(request) {
+      fetch(request) {
        const url = new URL(request.url)
-        requests.push(url.pathname)
        if (url.pathname === "/api/health")
          return Response.json({ healthy: true, version: OPENCODE_VERSION, pid: process.pid })
        if (url.pathname === "/api/location")
          return Response.json({ directory: process.cwd(), project: { id: "global", directory: process.cwd() } })
-        if (url.pathname === "/api/session") {
-          session = await request.json()
-          return new Response("boom", { status: 500 })
+        if (url.pathname === "/api/model") {
+          modelRequests++
+          return Response.json({
+            location: { directory: process.cwd(), project: { id: "global", directory: process.cwd() } },
+            data: modelRequests === 1 ? [{ id: "missing", providerID: "definitely" }] : [],
+          })
        }
        return new Response(undefined, { status: 404 })
      },
    })

    try {
-      const result = await cli([
-        "run",
-        "--server",
-        server.url.toString(),
-        "--model",
-        "definitely/missing",
-        "--agent",
-        "definitely-missing",
-        "hi",
-      ])
+      const result = await cli(["run", "--server", server.url.toString(), "--model", "definitely/missing", "hi"])

      expect(result.exitCode).toBe(1)
-      expect(result.stderr).toContain("UnexpectedStatus")
-      expect(session).toMatchObject({
-        agent: "definitely-missing",
-        model: { providerID: "definitely", id: "missing" },
-      })
-      expect(requests).not.toContain("/api/model")
-      expect(requests).not.toContain("/api/agent")
-      expect(requests).not.toContain("/api/location/wait")
+      expect(result.stderr).toContain("Model unavailable: definitely/missing")
    } finally {
      server.stop(true)
    }
@@ -213,16 +197,11 @@ describe("mini command", () => {

    expect(result.exitCode).toBe(0)
    expect(result.stdout).toContain("--server string")
-    expect(result.stdout).toContain("--prompt string")
-    expect(result.stdout).toContain("--replay")
-    expect(result.stdout).toContain("disable with --no-replay")
-    expect(result.stdout).toContain("--replay-limit integer")
-    expect(result.stdout).toContain("Limit replay to the newest N messages (default: 200)")
    expect(result.stdout).not.toContain("SUBCOMMANDS")
  })

  test("routes local and explicit-server invocations into mini", async () => {
-    for (const args of [["mini"], ["mini", "--no-replay"], ["mini", "--server", "http://127.0.0.1:1"]]) {
+    for (const args of [["mini"], ["mini", "--server", "http://127.0.0.1:1"]]) {
      const result = await cli(args)

      expect(result.exitCode).toBe(1)
@@ -130,6 +130,7 @@ function failedTool(inputID: string): V2Event[] {
      id: "evt_failed_tool_progress",
      created: 3,
      type: "session.tool.progress",
+      durable: { aggregateID: "ses_1", seq: 3, version: 1 },
      data: {
        sessionID: "ses_1",
        assistantMessageID: "msg_failed_tool",
@@ -148,8 +149,6 @@ function failedTool(inputID: string): V2Event[] {
        assistantMessageID: "msg_failed_tool",
        callID: "call_failed_tool",
        error: { type: "unknown", message: "tool failed" },
-        metadata: { checkpoint: 1 },
-        content: [{ type: "text", text: "partial output" }],
        executed: true,
      },
    },
@@ -157,53 +156,6 @@ function failedTool(inputID: string): V2Event[] {
  ]
 }

-function successfulGrep(inputID: string): V2Event[] {
-  const text = "Found 2 matches\n/src/a.ts:\n  Line 1: needle\n/src/b.ts:\n  Line 2: needle"
-  return [
-    prompted(inputID),
-    {
-      id: "evt_grep_input",
-      created: 1,
-      type: "session.tool.input.started",
-      durable: { aggregateID: "ses_1", seq: 1, version: 1 },
-      data: {
-        sessionID: "ses_1",
-        assistantMessageID: "msg_grep",
-        callID: "call_grep",
-        name: "grep",
-      },
-    },
-    {
-      id: "evt_grep_called",
-      created: 2,
-      type: "session.tool.called",
-      durable: { aggregateID: "ses_1", seq: 2, version: 1 },
-      data: {
-        sessionID: "ses_1",
-        assistantMessageID: "msg_grep",
-        callID: "call_grep",
-        input: { pattern: "needle" },
-        executed: true,
-      },
-    },
-    {
-      id: "evt_grep_success",
-      created: 3,
-      type: "session.tool.success",
-      durable: { aggregateID: "ses_1", seq: 3, version: 1 },
-      data: {
-        sessionID: "ses_1",
-        assistantMessageID: "msg_grep",
-        callID: "call_grep",
-        structured: { matches: 2 },
-        content: [{ type: "text", text }],
-        executed: false,
-      },
-    },
-    settled(),
-  ]
-}
-
 // Runs one non-interactive prompt against a mocked SDK. `turn` produces the
 // live events the prompt admission triggers, keyed by the generated message ID.
 async function run(input: {
@@ -217,7 +169,6 @@ async function run(input: {
  renderToolError?: (part: SessionMessageAssistantTool) => Promise<void>
  messages?: (inputID: string) => SessionMessageInfo[]
  wait?: () => Promise<void>
-  terminalDelay?: number
 }) {
  const sdk = OpenCode.make({ baseUrl: "https://opencode.test" })
  const values: V2Event[] = [{ id: "evt_connected", type: "server.connected", data: {} }]
@@ -232,10 +183,7 @@ async function run(input: {
        })
        continue
      }
-      if (value.type.startsWith("session.execution.")) {
-        if (input.terminalDelay) await Bun.sleep(input.terminalDelay)
-        setTimeout(wait.resolve, 0)
-      }
+      if (value.type.startsWith("session.execution.")) setTimeout(wait.resolve, 0)
      yield value
    }
  })()
@@ -303,7 +251,7 @@ async function capture(input: Parameters<typeof run>[0]) {
  })
  try {
    await run(input)
-    return { stdout: stdout.join(""), stderr: stderr.join(""), exitCode: process.exitCode }
+    return { stdout: stdout.join(""), stderr: stderr.join("") }
  } finally {
    process.exitCode = exitCode ?? 0
    stdoutWrite.mockRestore()
@@ -316,32 +264,6 @@ afterEach(() => {
 })

 describe("runNonInteractivePrompt", () => {
-  test("keeps formatted tool output and compact structured metadata in JSON", async () => {
-    const output = await capture({ format: "json", turn: successfulGrep })
-    const events = output.stdout
-      .split("\n")
-      .filter(Boolean)
-      .map((line) => JSON.parse(line))
-
-    expect(events).toHaveLength(1)
-    expect(events[0]).toMatchObject({
-      type: "tool_use",
-      part: {
-        tool: "grep",
-        state: {
-          status: "completed",
-          output: expect.stringContaining("Found 2 matches"),
-          metadata: {
-            structured: { matches: 2 },
-            content: [{ type: "text", text: expect.stringContaining("/src/a.ts") }],
-          },
-        },
-      },
-    })
-    expect(events[0].part.state.metadata.structured).toEqual({ matches: 2 })
-    expect(events[0].part.state.metadata.result).toBeUndefined()
-  })
-
  test("uses session.wait then reconciles projected output without a terminal event", async () => {
    const idle = Promise.withResolvers<void>()
    let done = false
@@ -397,26 +319,6 @@ describe("runNonInteractivePrompt", () => {
        error: { type: "provider.transport", message: "instructions unavailable" },
      }),
    ])
-    expect(output.exitCode).toBe(1)
-  })
-
-  test("waits for a terminal failure when idle wins before projection", async () => {
-    for (const promotedBeforeFailure of [true, false]) {
-      const output = await capture({
-        format: "json",
-        turn: (messageID) => [
-          ...(promotedBeforeFailure ? [prompted(messageID)] : []),
-          executionFailed("selection unavailable"),
-        ],
-        messages: (messageID) =>
-          promotedBeforeFailure ? [{ id: messageID, type: "user", text: "hello", time: { created: 1 } }] : [],
-        wait: () => Promise.resolve(),
-        terminalDelay: 10,
-      })
-
-      expect(output.exitCode).toBe(1)
-      expect(output.stdout).toContain("selection unavailable")
-    }
  })

  test("cancels session and global form blockers and exits on pre-promotion interrupt", async () => {
@@ -511,14 +413,14 @@ describe("runNonInteractivePrompt", () => {
      ],
    })

-    expect(output).toEqual({ stdout: "", stderr: "", exitCode: 0 })
+    expect(output).toEqual({ stdout: "", stderr: "" })
  })

-  test("renders a native terminal failure snapshot when live progress was missed", async () => {
+  test("renders native failed tool output before the terminal error", async () => {
    const rendered: SessionMessageAssistantTool[] = []
    const failed: SessionMessageAssistantTool[] = []
    await capture({
-      turn: (inputID) => failedTool(inputID).filter((event) => event.type !== "session.tool.progress"),
+      turn: failedTool,
      renderTool: (part) => {
        rendered.push(part)
        return Promise.resolve()
@@ -78,15 +78,6 @@ describe("session target resolver", () => {
    expect(order).toEqual(["prepare", "create"])
  })

-  test("uses the agent resolved by the server for a fresh Session", async () => {
-    const client = OpenCode.make({ baseUrl: "https://opencode.test" })
-    spyOn(client.location, "get").mockResolvedValue(location("/project"))
-    spyOn(client.session, "create").mockResolvedValue({ ...session("ses_fresh", "/project"), agent: "review" })
-
-    const target = await resolveSessionTarget({ client, prepare })
-    expect(target.agent).toBe("review")
-  })
-
  test("does not retry an ambiguous Session creation", async () => {
    const client = OpenCode.make({ baseUrl: "https://opencode.test" })
    spyOn(client.location, "get").mockResolvedValue(location("/project"))
@@ -8,7 +8,7 @@ export type ModelRef = { id: string; providerID: string; variant?: string }

 export type ProviderSettings = { [x: string]: JsonValue }

-export type AgentColor = string
+export type AgentColor = string | "primary" | "secondary" | "accent" | "success" | "warning" | "error" | "info"

 export type PermissionV2Effect = "allow" | "deny" | "ask"

@@ -163,8 +163,6 @@ export type SessionMessageProviderState7 = { [x: string]: any }

 export type EventLogSynced = { type: "log.synced"; aggregateID: string; seq?: number }

-export type ModelReasoningField = "reasoning" | "reasoning_content" | "reasoning_text" | (string & {})
-
 export type ModelCapabilities = { tools: boolean; input: Array<string>; output: Array<string> }

 export type ModelVariant = {
@@ -1096,7 +1094,7 @@ export type TuiCommandExecute = {
      | "prompt.clear"
      | "prompt.submit"
      | "agent.cycle"
-      | (string & {})
+      | string
  }
 }

@@ -1387,7 +1385,23 @@ export type SessionToolCalled = {
  }
 }

-export type ModelCompatibility = { reasoningField?: ModelReasoningField }
+export type SessionToolFailed = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.tool.failed"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: {
+    sessionID: string
+    assistantMessageID: string
+    callID: string
+    error: SessionStructuredError
+    result?: any
+    executed: boolean
+    resultState?: SessionMessageProviderState7
+  }
+}

 export type ModelCost = {
  tier?: { type: "context"; size: number }
@@ -1833,6 +1847,22 @@ export type SessionMessageToolStateError = {
  result?: JsonValue
 }

+export type SessionToolProgress = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.tool.progress"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: {
+    sessionID: string
+    assistantMessageID: string
+    callID: string
+    structured: { [x: string]: any }
+    content: Array<LLMToolContent>
+  }
+}
+
 export type SessionToolSuccess = {
  id: string
  created: number
@@ -1852,41 +1882,6 @@ export type SessionToolSuccess = {
  }
 }

-export type SessionToolFailed = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.tool.failed"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: {
-    sessionID: string
-    assistantMessageID: string
-    callID: string
-    error: SessionStructuredError
-    content?: [LLMToolContent, ...Array<LLMToolContent>]
-    metadata?: { [x: string]: any }
-    result?: any
-    executed: boolean
-    resultState?: SessionMessageProviderState7
-  }
-}
-
-export type SessionToolProgress = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.tool.progress"
-  location?: LocationRef
-  data: {
-    sessionID: string
-    assistantMessageID: string
-    callID: string
-    structured: { [x: string]: any }
-    content: Array<LLMToolContent>
-  }
-}
-
 export type SessionMessageCompaction =
  | SessionMessageCompactionRunning
  | SessionMessageCompactionCompleted
@@ -1898,7 +1893,6 @@ export type ModelInfo = {
  providerID: string
  family?: string
  name: string
-  compatibility?: ModelCompatibility
  package?: string
  settings?: { [x: string]: JsonValue }
  headers?: { [x: string]: string }
@@ -2225,6 +2219,7 @@ export type SessionEventDurable =
  | SessionToolInputStarted
  | SessionToolInputEnded
  | SessionToolCalled
+  | SessionToolProgress
  | SessionToolSuccess
  | SessionToolFailed
  | SessionRetryScheduled
@@ -29,8 +29,7 @@ ultimate source of truth.
 ## Values and literals

 - [x] `null`, `undefined`, booleans, finite and non-finite numbers, and strings.
- [x] Array literals, including holes and spread from arrays, strings, Maps, Sets, URLSearchParams, custom synchronous
-      iterators, and synchronous generators.
+- [x] Array literals, including holes and spread from arrays, strings, Maps, Sets, and URLSearchParams.
 - [x] Object literals with shorthand, computed string/number keys, and spread from plain data objects; `null` and
      `undefined` are no-ops, while arrays are rejected.
 - [x] Template literals with interpolation.
@@ -58,9 +57,7 @@ ultimate source of truth.
 - [ ] Hoist function declarations accepted directly in switch cases.
 - [x] Computed object destructuring keys such as `const { [field]: value } = record`.
 - [x] Object destructuring from arrays, such as `const { length } = values`.
- [x] Array binding and assignment destructuring from strings, Maps, Sets, URLSearchParams, custom synchronous
-      iterators, and synchronous generators, including stepwise elisions/rest and `IteratorClose` on early completion
-      or binding/default failure.
+- [x] Array destructuring from supported non-array iterables: strings, Maps, Sets, and URLSearchParams.

 ## Statements and control flow

@@ -68,8 +65,7 @@ ultimate source of truth.
 - [x] `if`/`else` and conditional expressions.
 - [x] `switch`, including default clauses and fallthrough.
 - [x] `for`, `while`, and `do...while`.
- [x] `for...of` over arrays, strings, Maps, Sets, URLSearchParams, custom synchronous iterators, and confined
-      synchronous generators. Abrupt completion invokes the iterator's optional `return()`.
+- [x] `for...of` over arrays, strings, Maps, Sets, and URLSearchParams.
 - [x] `for...in` over own keys of plain objects, arrays, and tool references.
 - [x] Unlabeled `break` and `continue`.
 - [x] `try`, `catch`, optional catch bindings, and `finally`.
@@ -79,7 +75,7 @@ ultimate source of truth.
      `Symbol.asyncIterator` or the `Symbol.iterator` fallback. Each iterator step is sequential, yielded promises and
      plain values from synchronous collections and sync iterators are awaited before binding, and abrupt loop
      completion invokes the iterator's optional `return()`. Custom async iterators control their yielded values, as in
-      JavaScript; only their `next()` results are awaited. Confined sync and async generators are iterable here.
+      JavaScript; only their `next()` results are awaited. Async generators remain outside the supported subset.

 ## Functions and callbacks

@@ -108,27 +104,7 @@ ultimate source of truth.
 - [ ] User-defined constructor calls.
 - [ ] `Function.prototype.call`, `apply`, and `bind` for CodeMode functions.
 - [ ] Classes and private fields.
- [x] Synchronous and async generator declarations/expressions, `yield`, and `yield*`, including lazy bodies,
-      `next(value)`, `return(value)`, `throw(value)`, exhaustion, promise adoption, async request ordering,
-      `try`/`catch`/`finally`, and sync/async iterator symbols. Async `yield*` awaits values while adapting a sync
-      iterator but preserves values supplied by a manually implemented async iterator. Generator values are opaque
-      runtime references.
- [x] Synchronous generators and custom synchronous iterators are consumed stepwise by array/argument spread, array
-      destructuring, `Array.from`, Map/Set/URLSearchParams construction, `Object.fromEntries`, Object/Map `groupBy`,
-      Promise combinators, `AggregateError`, and `Math.sumPrecise`. Mapper/grouping callbacks interleave with iterator
-      steps; synchronous consumers preserve yielded promise objects rather than awaiting them. Async generators are
-      rejected by every synchronous consumer.
- [x] Synchronous iterator acquisition and result validation follow `IteratorClose` boundaries: consumer errors and
-      intentional early stops invoke `return()`, acquisition/`next()` failures do not, and an original consumer error
-      wins over a cleanup failure. Async iterator consumption remains limited to `for await...of` and async `yield*`.
- [x] Portable generator protocol coverage is adapted from pinned Test262 cases for suspended-start, suspended-yield,
-      and completed states; sync and async `next`/`return`/`throw`; finally yields and completion overrides; rejected
-      yielded promises; mixed async request queues; sync and async `yield*` forwarding; malformed methods/results;
-      and declaration, expression, and object-method forms with closure and parameter behavior. The adapted suite
-      deliberately skips Test262 variants whose observation mechanism requires unsupported getter definitions,
-      proxies, prototype inspection or mutation, non-arrow `this`, classes, or arbitrary symbols. It also skips tests
-      asserting exact promise reaction-turn counts beyond the observable ordering guarantee documented below. These
-      are interpreter-surface boundaries, not claims that the corresponding full Test262 families pass unchanged.
+- [ ] Generator functions and `yield`.

 ## Expressions and operators

@@ -136,8 +112,8 @@ ultimate source of truth.
 - [x] Optional property access and optional calls.
 - [x] Function/tool calls and spread arguments.
 - [x] Sequence expressions (the comma operator).
- [x] `await` for CodeMode promises and callable thenables; a plain value passes through unchanged, though every
-      `await` still defers its continuation one reaction turn.
+- [x] `await` for CodeMode promises; a plain value passes through unchanged, though every `await` still defers its
+      continuation one reaction turn.
 - [x] `new` for Array, Object, Error types, Date, RegExp, Map, Set, URL, URLSearchParams, and Promise.
 - [x] Arithmetic operators: `+`, `-`, `*`, `/`, `%`, and `**`.
 - [x] Equality and ordering: `==`, `!=`, `===`, `!==`, `<`, `<=`, `>`, and `>=`.
@@ -152,11 +128,10 @@ ultimate source of truth.
 ## Promises and tools

 - [x] Tool calls start eagerly and return supervised, run-once CodeMode promises.
- [x] Direct `await`, repeated awaits, and recursive thenable assimilation when a promise or thenable is returned from
-      a function/program.
+- [x] Direct `await`, repeated awaits, and implicit resolution when a promise is returned from a function/program.
 - [x] `Promise.resolve` and `Promise.reject`.
- [x] `Promise.all`, `Promise.allSettled`, `Promise.race`, and `Promise.any` over finite collections, custom synchronous
-      iterators, and synchronous generators containing promises and plain values.
+- [x] `Promise.all`, `Promise.allSettled`, `Promise.race`, and `Promise.any` over supported collections containing
+      promises and plain values.
 - [x] `Promise.all` preserves result order and rejects on the first observed failure without cancelling siblings.
 - [x] `Promise.allSettled` returns plain fulfilled/rejected outcome records.
 - [x] `Promise.race` settles from the first result without cancelling losers at settlement time.
@@ -179,14 +154,11 @@ ultimate source of truth.
      the catch-normalized reasons in input order, and empty input rejects with an empty `AggregateError`.
 - [x] `new Promise((resolve, reject) => ...)`: the executor runs synchronously and receives first-class resolve/reject
      callables that settle the promise exactly once (they may escape the executor and settle later); an executor
-      throw rejects unless the promise already settled, resolving with a promise or callable thenable adopts it, and
-      resolving with the promise itself rejects with a `TypeError`. Resolver callables work anywhere callbacks are
-      accepted, including `.then`/`.catch` handlers and collection callbacks, but remain opaque references that cannot
-      cross the data boundary.
- [x] Recursive assimilation of objects with an own callable `then` field across `Promise.resolve`, combinators,
-      constructors, reactions, `finally`, `await`, and async returns. Thenable methods run deferred, receive
-      first-call-wins resolve/reject functions, and ignore throws after settlement. Inherited/accessor `then` fields
-      and a JavaScript `this` receiver remain outside the supported object/function model.
+      throw rejects unless the promise already settled, resolving with a promise adopts it, and resolving with the
+      promise itself rejects with a `TypeError`. Resolver callables work anywhere callbacks are accepted, including
+      `.then`/`.catch` handlers and collection callbacks, but remain opaque references that cannot cross the data
+      boundary.
+- [ ] Thenable assimilation; objects with a callable `then` field remain plain data.
 - [x] Dotted tool names are canonicalized into namespace paths; a path can be both callable and a namespace, and the
      last definition supplied for a canonical path wins.
 - [x] Tool path segments may be named `constructor`, `prototype`, or `__proto__` because paths use inert Map keys.
@@ -203,16 +175,14 @@ ultimate source of truth.
 - [x] `Object()` and `new Object()` return `{}` for nullish arguments and pass objects through unchanged;
      primitive wrapper objects (`Object(1)`) are rejected explicitly.
 - [x] Computed property names and object spread.
- [x] `Object.keys`, `Object.values`, `Object.entries`, `Object.hasOwn`, `Object.assign`, and `Object.fromEntries`, with
-      synchronous iterator support for `fromEntries`.
+- [x] `Object.keys`, `Object.values`, `Object.entries`, `Object.hasOwn`, `Object.assign`, and `Object.fromEntries`.
 - [x] `Object.keys` over arrays and tool references.
 - [x] Object identity is preserved by in-CodeMode Object helpers.
 - [x] Prototype traversal and mutation through `__proto__`, `constructor`, and `prototype` are blocked.
 - [ ] Legal own data fields named `__proto__`, `constructor`, or `prototype` are rejected at JSON/tool boundaries and
      cannot be created, read, or written in CodeMode; tool path segments with those names remain supported.
 - [x] `Object.is` for supported data values.
- [x] `Object.groupBy` over finite collections and custom synchronous iterators/generators, with string-key coercion
-      and null-prototype results.
+- [x] `Object.groupBy` over supported collection iterables, with string-key coercion and null-prototype results.

 ## Arrays

@@ -220,7 +190,7 @@ ultimate source of truth.
      array of that length; invalid lengths throw `RangeError`. Iteration, spread, join, and JSON handle holes like
      JavaScript, and host results normalize holes to `null`.
 - [x] Static methods: `Array.isArray`, `Array.of`, and `Array.from`, including the `Array.from` mapper form with
-      `(value, index)` arguments and stepwise synchronous iterator consumption.
+      `(value, index)` arguments.
 - [x] Iteration/transformation: `map`, `filter`, `flatMap`, and `forEach`.
 - [x] Searching/tests: `find`, `findIndex`, `findLast`, `findLastIndex`, `some`, `every`, `includes`, `indexOf`, and
      `lastIndexOf`.
@@ -275,8 +245,7 @@ ultimate source of truth.
      for feature detection. Calling any undefined value reports a native-style `TypeError` naming the callee, for
      example `Math.sum is not a function.` Blocked members (`constructor`, `__proto__`, ...) still throw,
      and unknown `Promise` statics keep their descriptive error.
- [x] `Math.sumPrecise` over finite collections and custom synchronous iterators/generators, rejecting non-number
-      elements without coercion.
+- [x] `Math.sumPrecise` over supported collection iterables, rejecting non-number elements without coercion.
 - [x] Global coercing `isFinite` and `isNaN`; opaque runtime references reject as data errors, like `Number(...)`.

 ## JSON and console
@@ -328,10 +297,10 @@ ultimate source of truth.

 ## Map and Set

- [x] Static `Map.groupBy` over finite collections and custom synchronous iterators/generators, preserving key identity.
- [x] `new Map()` from synchronous iterables of entries.
+- [x] Static `Map.groupBy` over supported collection iterables, preserving key identity.
+- [x] `new Map()` from entry arrays or another Map.
 - [x] Map `get`, `set`, `has`, `delete`, `clear`, `size`, and `forEach`.
- [x] `new Set()` from synchronous iterables.
+- [x] `new Set()` from arrays, strings, or another Set.
 - [x] Set `add`, `has`, `delete`, `clear`, `size`, and `forEach`.
 - [x] Materialized `keys`, `values`, and `entries` arrays for Map and Set.
 - [x] Spread, `for...of`, `Array.from`, and `Object.fromEntries` integration.
@@ -347,7 +316,7 @@ ultimate source of truth.
 - [x] Readable URL fields: `href`, `origin`, `protocol`, `username`, `password`, `host`, `hostname`, `port`,
      `pathname`, `search`, and `hash`.
 - [x] Writable URL fields except `origin`.
- [x] `new URLSearchParams()` from query strings, data objects, synchronous iterables of pairs, and URLSearchParams.
+- [x] `new URLSearchParams()` from query strings, data objects, pairs, Maps, and URLSearchParams.
 - [x] URLSearchParams `append`, `delete`, `get`, `getAll`, `has`, `set`, `sort`, `forEach`, `keys`, `values`,
      `entries`, `toString`, and `size`.
 - [x] URL values serialize to their href; URLSearchParams serialize to `{}`.
@@ -357,7 +326,7 @@ ultimate source of truth.
 - [x] `Error`, `TypeError`, `RangeError`, `SyntaxError`, `ReferenceError`, `EvalError`, and `URIError`, callable with
      or without `new`.
 - [x] `AggregateError` with the `(errors, message?)` signature and an own `errors` array, constructed directly or by
-      an all-rejected `Promise.any`; direct construction accepts custom synchronous iterators and generators.
+      an all-rejected `Promise.any`.
 - [x] Error `name`/`message`, error inheritance through `instanceof`, and plain-data serialization.
 - [x] `instanceof` for Date, RegExp, Map, Set, URL, URLSearchParams, Array, Object, Promise, and Error types.
 - [x] Catchable user throws, runtime failures raised during interpreted evaluation, awaited tool failures, and awaited
@@ -1,10 +1,9 @@
-import { Effect } from "effect"
 import type { Diagnostic } from "../codemode.js"
 import { ToolError } from "../tool-error.js"
 import { copyOut, ToolRuntimeError, type SafeObject } from "../tool-runtime.js"
 import { type AstNode, formatLocation, InterpreterRuntimeError, ProgramThrow, sourceLocation } from "./model.js"
 import { containsRuntimeReference } from "./references.js"
-import { type SyncIteratorRunner } from "./iterator.js"
+import { spreadItems } from "../stdlib/collections.js"
 import { coerceToString, createAggregateErrorValue, createErrorValue, errorConstructors } from "../stdlib/value.js"

 export const normalizeError = (error: unknown): Diagnostic => {
@@ -80,27 +79,15 @@ export const caughtErrorValue = (thrown: unknown): unknown => {
  return createErrorValue(name, normalizeError(thrown).message)
 }

-export const constructErrorValue = (name: string, args: Array<unknown>): SafeObject =>
-  createErrorValue(name, args[0] === undefined ? "" : coerceToString(args[0]))
-
-export const constructAggregateErrorValue = <R>(
-  runner: SyncIteratorRunner<R>,
-  args: Array<unknown>,
-  node: AstNode,
-): Effect.Effect<SafeObject, unknown, R> =>
-  Effect.gen(function* () {
-    const cursor = yield* runner.syncIterator(args[0], node)
-    if (cursor === undefined) {
-      throw new InterpreterRuntimeError("new AggregateError(...) expects a synchronous iterable of errors.", node).as(
-        "TypeError",
-      )
-    }
-    const errors: Array<unknown> = []
-    while (true) {
-      const step = yield* cursor.next
-      if (step.done) {
-        return createAggregateErrorValue(errors, args[1] === undefined ? "" : coerceToString(args[1]))
-      }
-      errors.push(step.value)
-    }
-  })
+export const constructErrorValue = (name: string, args: Array<unknown>, node: AstNode): SafeObject => {
+  if (name !== "AggregateError") return createErrorValue(name, args[0] === undefined ? "" : coerceToString(args[0]))
+  const errors = spreadItems(args[0])
+  if (errors === undefined) {
+    throw new InterpreterRuntimeError(
+      "new AggregateError(...) expects an array of errors (e.g. new AggregateError(errors, message?)).",
+      node,
+    ).as("TypeError")
+  }
+  // Error values must not alias caller-owned arrays.
+  return createAggregateErrorValue([...errors], args[1] === undefined ? "" : coerceToString(args[1]))
+}
@@ -1,21 +0,0 @@
-import { Effect, Exit } from "effect"
-import type { AstNode } from "./model.js"
-
-export type IteratorCursor<R> = {
-  readonly next: Effect.Effect<{ readonly done: boolean; readonly value: unknown }, unknown, R>
-  readonly close: Effect.Effect<void, unknown, R>
-}
-
-export type SyncIteratorRunner<R> = {
-  readonly syncIterator: (value: unknown, node: AstNode) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>
-}
-
-export const preserveConsumerError = <A, R>(
-  cursor: IteratorCursor<R>,
-  effect: Effect.Effect<A, unknown, R>,
-): Effect.Effect<A, unknown, R> =>
-  Effect.flatMap(Effect.exit(effect), (exit) =>
-    Exit.isSuccess(exit)
-      ? Effect.succeed(exit.value)
-      : Effect.andThen(Effect.exit(cursor.close), Effect.failCause(exit.cause)),
-  )
@@ -2,7 +2,6 @@ import { Effect } from "effect"
 import {
  type AstNode,
  CodeModeFunction,
-  CodeModeGenerator,
  CoercionFunction,
  ErrorConstructorReference,
  GlobalMethodReference,
@@ -34,7 +33,6 @@ import { invokeRegExpMethod, invokeRegExpStatic, matchToValue, toHostRegex } fro
 import { invokeStringStatic } from "../stdlib/string.js"
 import { invokeURLMethod, invokeURLStatic, uriArgument } from "../stdlib/url.js"
 import { boundedData, coerceToNumber, coerceToString, errorBrandName } from "../stdlib/value.js"
-import { preserveConsumerError, type SyncIteratorRunner } from "./iterator.js"

 export type CallbackRunner<R> = {
  readonly invokeFunction: (fn: CodeModeFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>
@@ -362,12 +360,19 @@ const invokeArrayStatic = (name: string, args: Array<unknown>, node: AstNode): u
      return Array.isArray(args[0])
    case "of":
      return [...args]
+    case "from":
+      return arrayFromItems(args[0], node)
    default:
      throw new InterpreterRuntimeError(`Array.${name} is not available.`, node)
  }
 }

-const arrayLikeSource = (source: unknown, node: AstNode): { readonly length: number; readonly source: object } => {
+const arrayFromItems = (source: unknown, node: AstNode): Array<unknown> => {
+  if (source instanceof CodeModeMap) return Array.from(source.map.entries(), ([key, item]) => [key, item])
+  if (source instanceof CodeModeSet) return Array.from(source.set.values())
+  if (source instanceof CodeModeURLSearchParams) {
+    return Array.from(source.params.entries(), ([key, value]) => [key, value])
+  }
  if (source instanceof CodeModePromise) {
    throw new InterpreterRuntimeError(
      "Array.from received an un-awaited Promise; await it before creating the array.",
@@ -375,16 +380,15 @@ const arrayLikeSource = (source: unknown, node: AstNode): { readonly length: num
      "InvalidDataValue",
    )
  }
+  if (typeof source === "string") return Array.from(source)
+  if (Array.isArray(source)) return [...source]
  if (
    source !== null &&
    typeof source === "object" &&
    (Object.getPrototypeOf(source) === Object.prototype || Object.getPrototypeOf(source) === null) &&
    typeof (source as { length?: unknown }).length === "number"
  ) {
-    const length = (source as { length: number }).length
-    const normalized = Number.isNaN(length) || length <= 0 ? 0 : Math.trunc(length)
-    if (normalized > 4_294_967_295) throw new RangeError("Invalid array length")
-    return { length: normalized, source }
+    return Array.from(source as ArrayLike<unknown>)
  }
  throw new InterpreterRuntimeError(
    "Array.from expects an array, string, Map, Set, or array-like value.",
@@ -394,42 +398,24 @@ const arrayLikeSource = (source: unknown, node: AstNode): { readonly length: num
 }

 export const invokeArrayFrom = <R>(
-  runner: CallbackRunner<R> & SyncIteratorRunner<R>,
+  runner: CallbackRunner<R>,
  args: Array<unknown>,
  node: AstNode,
 ): Effect.Effect<unknown, unknown, R> => {
-  const source = args[0]
-  const apply =
-    args.length < 2 || args[1] === undefined ? undefined : applyCollectionCallback(runner, args[1], "Array.from", node)
+  const items = arrayFromItems(args[0], node)
+  if (args.length < 2 || args[1] === undefined) return Effect.succeed(items)
+  const apply = applyCollectionCallback(runner, args[1], "Array.from", node)
  return Effect.gen(function* () {
-    const cursor = yield* runner.syncIterator(source, node)
-    if (cursor === undefined) {
-      if (source instanceof CodeModeGenerator) {
-        throw new InterpreterRuntimeError("Array.from expects a synchronous iterable or array-like value.", node).as(
-          "TypeError",
-        )
-      }
-      const arrayLike = arrayLikeSource(source, node)
-      const values: Array<unknown> = []
-      for (let index = 0; index < arrayLike.length; index += 1) {
-        const item = Reflect.get(arrayLike.source, index)
-        values.push(apply === undefined ? item : yield* apply([item, index]))
-      }
-      return values
-    }
    const values: Array<unknown> = []
-    let index = 0
-    while (true) {
-      const step = yield* cursor.next
-      if (step.done) return values
-      values.push(apply === undefined ? step.value : yield* preserveConsumerError(cursor, apply([step.value, index])))
-      index += 1
+    for (let index = 0; index < items.length; index += 1) {
+      values.push(yield* apply([items[index], index]))
    }
+    return values
  })
 }

 export const invokeGroupBy = <R>(
-  runner: CallbackRunner<R> & SyncIteratorRunner<R>,
+  runner: CallbackRunner<R>,
  namespace: "Map" | "Object",
  args: Array<unknown>,
  node: AstNode,
@@ -439,50 +425,47 @@ export const invokeGroupBy = <R>(
    throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError")
  }
  const apply = applyCollectionCallback(runner, args[1], `${namespace}.groupBy`, node)
+  const items = supportedIterableItems(source)
+  if (items === undefined) {
+    throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError")
+  }
  return Effect.gen(function* () {
-    const cursor = yield* runner.syncIterator(source, node)
-    if (cursor === undefined) {
-      throw new InterpreterRuntimeError(`${namespace}.groupBy expects an iterable collection.`, node).as("TypeError")
-    }
    if (namespace === "Map") {
      const result = new CodeModeMap()
      let index = 0
-      while (true) {
-        const step = yield* cursor.next
-        if (step.done) return result
-        const item = step.value
-        const key = yield* preserveConsumerError(cursor, apply([item, index]))
+      for (const item of items) {
+        const key = yield* apply([item, index])
        const group = result.map.get(key)
        if (group === undefined) result.map.set(key, [item])
        else (group as Array<unknown>).push(item)
        index += 1
      }
+      return result
    }

    const result: SafeObject = Object.create(null) as SafeObject
    let index = 0
-    while (true) {
-      const step = yield* cursor.next
-      if (step.done) return result
-      const item = step.value
-      const key = yield* preserveConsumerError(
-        cursor,
-        Effect.flatMap(apply([item, index]), (value) => coerceGroupByPropertyKey(runner, value, node)),
-      )
+    for (const item of items) {
+      const key = yield* coerceGroupByPropertyKey(runner, yield* apply([item, index]), node)
      if (isBlockedMember(key)) {
-        return yield* preserveConsumerError(
-          cursor,
-          Effect.fail(new InterpreterRuntimeError(`Property '${key}' is not available.`, node)),
-        )
+        throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node)
      }
      const group = result[key]
      if (group === undefined) result[key] = [item]
      else (group as Array<unknown>).push(item)
      index += 1
    }
+    return result
  })
 }

+const supportedIterableItems = (source: unknown): Iterable<unknown> | undefined => {
+  if (Array.isArray(source) || typeof source === "string") return source
+  if (source instanceof CodeModeMap) return source.map.entries()
+  if (source instanceof CodeModeSet) return source.set.values()
+  if (source instanceof CodeModeURLSearchParams) return source.params.entries()
+}
+
 const coerceGroupByPropertyKey = <R>(
  runner: CallbackRunner<R>,
  value: unknown,
@@ -1,4 +1,3 @@
-import type { Effect } from "effect"
 import type { SafeObject } from "../tool-runtime.js"
 import type { CodeModePromise, CodeModeRegExp, CodeModeURL } from "../values.js"

@@ -46,27 +45,6 @@ export class CodeModeFunction {
    readonly body: AstNode,
    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>,
    readonly async: boolean,
-    readonly generator: boolean,
-  ) {}
-}
-
-export type GeneratorRequestKind = "next" | "return" | "throw"
-
-export class CodeModeGenerator {
-  constructor(
-    readonly asynchronous: boolean,
-    readonly request: (
-      kind: GeneratorRequestKind,
-      value: unknown,
-      node: AstNode,
-    ) => Effect.Effect<unknown, unknown, unknown>,
-  ) {}
-}
-
-export class GeneratorMethodReference {
-  constructor(
-    readonly generator: CodeModeGenerator,
-    readonly kind: GeneratorRequestKind | "iterator",
  ) {}
 }

@@ -150,10 +128,6 @@ export class ProgramThrow {
  constructor(readonly value: unknown) {}
 }

-export class GeneratorReturn {
-  constructor(readonly value: unknown) {}
-}
-
 export class ErrorConstructorReference {
  constructor(readonly name: string) {}
 }
@@ -13,9 +13,9 @@ import {
 import { caughtErrorValue, normalizeError } from "./errors.js"
 import { applyCollectionCallback, isSupportedCallback, type CallbackRunner, type SupportedCallback } from "./methods.js"
 import { typeofValue } from "./references.js"
+import { spreadItems } from "../stdlib/collections.js"
 import { createAggregateErrorValue } from "../stdlib/value.js"
 import { CodeModePromise } from "../values.js"
-import type { SyncIteratorRunner } from "./iterator.js"

 // Observation only controls rejection reporting; program completion interrupts all promise work.
 export class PromiseRuntime<R> {
@@ -64,10 +64,6 @@ export class PromiseRuntime<R> {
    return Fiber.await(promise.fiber)
  }

-  fork(effect: Effect.Effect<unknown, unknown, R>): Effect.Effect<void, never, R> {
-    return Effect.asVoid(Effect.forkIn(effect, this.scope, { startImmediately: true }))
-  }
-
  diagnostics(): Array<Diagnostic> {
    return [...this.failures].sort(([left], [right]) => left - right).map(([, failure]) => failure)
  }
@@ -87,138 +83,114 @@ export class PromiseRuntime<R> {
 export const selfResolutionError = (node?: AstNode): InterpreterRuntimeError =>
  new InterpreterRuntimeError("Chaining cycle detected: a promise cannot resolve with itself.", node).as("TypeError")

-export const resolvePromiseValue = <R>(
-  runner: CallbackRunner<R>,
-  value: unknown,
-  node: AstNode,
-  own?: { promise?: CodeModePromise },
-): Effect.Effect<unknown, unknown, R> => {
-  if (own?.promise !== undefined && value === own.promise) return Effect.fail(selfResolutionError(node))
-  if (value instanceof CodeModePromise) return runner.settlePromise(value)
-  if (value === null || typeof value !== "object" || !Object.hasOwn(value, "then")) return Effect.succeed(value)
-  const then = (value as SafeObject).then
-  if (typeofValue(then) !== "function") return Effect.succeed(value)
-
-  return Effect.gen(function* () {
-    // Promise resolution invokes a thenable's method in a later job.
-    yield* Effect.yieldNow
-    const deferred = Deferred.makeUnsafe<unknown, unknown>()
-    const resolve = new PromiseCapabilityFunction((result) => {
-      Deferred.doneUnsafe(deferred, Exit.succeed(result))
-    })
-    const reject = new PromiseCapabilityFunction((reason) => {
-      Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(reason)))
-    })
-    const executed = yield* Effect.exit(runner.invokeCallable(then, [resolve, reject], node))
-    if (!Exit.isSuccess(executed)) {
-      if (Cause.hasInterruptsOnly(executed.cause)) return yield* Effect.failCause(executed.cause)
-      Deferred.doneUnsafe(deferred, Exit.fail(Cause.squash(executed.cause)))
-    }
-    return yield* resolvePromiseValue(runner, yield* Deferred.await(deferred), node, own)
-  })
-}
-
-export const resolvePromise = <R>(
-  runner: CallbackRunner<R>,
-  promises: PromiseRuntime<R>,
-  value: unknown,
-  node: AstNode,
-): Effect.Effect<CodeModePromise, never, R> => {
-  if (value instanceof CodeModePromise) return Effect.succeed(value)
-  const box: { promise?: CodeModePromise } = {}
-  return Effect.map(promises.create(resolvePromiseValue(runner, value, node, box)), (promise) => {
-    box.promise = promise
-    return promise
-  })
-}
-
 export const invokePromiseMethod = <R>(
-  runner: CallbackRunner<R> & SyncIteratorRunner<R>,
+  runner: CallbackRunner<R>,
  promises: PromiseRuntime<R>,
  ref: PromiseMethodReference,
  args: Array<unknown>,
  node: AstNode,
 ): Effect.Effect<unknown, unknown, R> => {
  if (ref.name === "resolve") {
-    return resolvePromise(runner, promises, args[0], node)
+    const value = args[0]
+    return value instanceof CodeModePromise ? Effect.succeed(value) : promises.create(Effect.succeed(value))
  }
  if (ref.name === "reject") {
    return promises.create(Effect.fail(new ProgramThrow(args[0])))
  }

-  return promises.create(
-    Effect.gen(function* () {
-      const cursor = yield* runner.syncIterator(args[0], node)
-      if (cursor === undefined) {
-        throw new InterpreterRuntimeError(
-          `Promise.${ref.name} expects an array or other synchronous iterable.`,
+  const spread = spreadItems(args[0])
+  if (spread === undefined) {
+    return promises.create(
+      Effect.fail(
+        new InterpreterRuntimeError(
+          `Promise.${ref.name} expects an array of promises or plain values (e.g. Promise.${ref.name}(items.map((item) => tools.ns.tool(item)))).`,
          node,
-        ).as("TypeError")
-      }
-      const items: Array<CodeModePromise> = []
-      while (true) {
-        const step = yield* cursor.next
-        if (step.done) break
-        const item = yield* resolvePromise(runner, promises, step.value, node)
-        promises.markObserved(item)
-        items.push(item)
-      }
+        ).as("TypeError"),
+      ),
+    )
+  }
+  const items = Array.from(spread)

-      if (ref.name === "all") {
-        return yield* settleAfterTurn(
-          Effect.all(
-            items.map((item) => Effect.flatten(promises.await(item))),
-            { concurrency: "unbounded" },
+  for (const item of items) {
+    if (item instanceof CodeModePromise) promises.markObserved(item)
+  }
+
+  switch (ref.name) {
+    case "all": {
+      const observations = items.map((item) =>
+        item instanceof CodeModePromise ? Effect.flatten(promises.await(item)) : Effect.succeed(item),
+      )
+      return promises.create(settleAfterTurn(Effect.all(observations, { concurrency: "unbounded" })))
+    }
+    case "allSettled": {
+      const observations = items.map((item) =>
+        item instanceof CodeModePromise ? promises.await(item) : Effect.succeed(Exit.succeed(item)),
+      )
+      return promises.create(
+        settleAfterTurn(
+          Effect.gen(function* () {
+            const outcomes: Array<unknown> = []
+            for (const observation of observations) {
+              const exit = yield* observation
+              if (Exit.isSuccess(exit)) {
+                outcomes.push(
+                  Object.assign(Object.create(null) as SafeObject, { status: "fulfilled", value: exit.value }),
+                )
+                continue
+              }
+              if (Cause.hasInterruptsOnly(exit.cause)) {
+                // Teardown interruption is not a program-level rejection.
+                return yield* Effect.failCause(exit.cause)
+              }
+              outcomes.push(
+                Object.assign(Object.create(null) as SafeObject, {
+                  status: "rejected",
+                  reason: caughtErrorValue(Cause.squash(exit.cause)),
+                }),
+              )
+            }
+            return outcomes
+          }),
+        ),
+      )
+    }
+    case "race": {
+      if (items.length === 0) {
+        return promises.create(
+          Effect.fail(
+            new InterpreterRuntimeError(
+              "Promise.race([]) would never settle; provide at least one promise or value.",
+              node,
+            ),
          ),
        )
      }
-      if (ref.name === "allSettled") {
-        const outcomes: Array<unknown> = []
-        for (const item of items) {
-          const exit = yield* promises.await(item)
-          if (Exit.isSuccess(exit)) {
-            outcomes.push(Object.assign(Object.create(null) as SafeObject, { status: "fulfilled", value: exit.value }))
-            continue
-          }
-          if (Cause.hasInterruptsOnly(exit.cause)) return yield* Effect.failCause(exit.cause)
-          outcomes.push(
-            Object.assign(Object.create(null) as SafeObject, {
-              status: "rejected",
-              reason: caughtErrorValue(Cause.squash(exit.cause)),
-            }),
-          )
-        }
-        yield* Effect.yieldNow
-        return outcomes
-      }
-      if (ref.name === "race") {
-        if (items.length === 0) {
-          throw new InterpreterRuntimeError(
-            "Promise.race([]) would never settle; provide at least one promise or value.",
-            node,
-          )
-        }
-        return yield* settleAfterTurn(Effect.flatten(Effect.raceAll(items.map((item) => promises.await(item)))))
-      }
-      const flipped = items.map((item) =>
-        Effect.flatMap(promises.await(item), (exit) => {
-          if (Exit.isSuccess(exit)) return Effect.fail(new PromiseAnyFulfilled(exit.value))
-          if (Cause.hasInterruptsOnly(exit.cause)) return Effect.failCause(exit.cause)
-          return Effect.succeed(caughtErrorValue(Cause.squash(exit.cause)))
-        }),
+      const observations = items.map((item) =>
+        item instanceof CodeModePromise ? promises.await(item) : Effect.succeed(Exit.succeed(item)),
      )
-      return yield* settleAfterTurn(
-        Effect.all(flipped, { concurrency: "unbounded" }).pipe(
-          Effect.flatMap((reasons) =>
-            Effect.fail(new ProgramThrow(createAggregateErrorValue(reasons, "All promises were rejected"))),
-          ),
-          Effect.catch((error) =>
-            error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error),
-          ),
+      return promises.create(settleAfterTurn(Effect.flatten(Effect.raceAll(observations))))
+    }
+    case "any": {
+      const flipped = items.map((item) =>
+        item instanceof CodeModePromise
+          ? Effect.flatMap(promises.await(item), (exit) => {
+              if (Exit.isSuccess(exit)) return Effect.fail(new PromiseAnyFulfilled(exit.value))
+              if (Cause.hasInterruptsOnly(exit.cause)) return Effect.failCause(exit.cause)
+              return Effect.succeed(caughtErrorValue(Cause.squash(exit.cause)))
+            })
+          : Effect.fail(new PromiseAnyFulfilled(item)),
+      )
+      const body = Effect.all(flipped, { concurrency: "unbounded" }).pipe(
+        Effect.flatMap((reasons) =>
+          Effect.fail(new ProgramThrow(createAggregateErrorValue(reasons, "All promises were rejected"))),
+        ),
+        Effect.catch((error) =>
+          error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error),
        ),
      )
-    }),
-  )
+      return promises.create(settleAfterTurn(body))
+    }
+  }
 }

 export const invokePromiseInstanceMethod = <R>(
@@ -252,11 +224,15 @@ export const constructPromise = <R>(
  }
  return Effect.gen(function* () {
    const deferred = Deferred.makeUnsafe<unknown, unknown>()
-    const box: { promise?: CodeModePromise } = {}
+    const box: { own?: CodeModePromise } = {}
    const promise = yield* promises.create(
-      Effect.flatMap(Deferred.await(deferred), (value) => resolvePromiseValue(runner, value, node, box)),
+      Effect.flatMap(Deferred.await(deferred), (value) => {
+        if (!(value instanceof CodeModePromise)) return Effect.succeed(value)
+        if (value === box.own) return Effect.fail(selfResolutionError(node))
+        return runner.settlePromise(value)
+      }),
    )
-    box.promise = promise
+    box.own = promise
    const resolve = new PromiseCapabilityFunction((value) => {
      Deferred.doneUnsafe(deferred, Exit.succeed(value))
    })
@@ -312,17 +288,19 @@ const chainReaction = <R>(
  method: string,
  node: AstNode,
 ): Effect.Effect<CodeModePromise, never, R> => {
-  const box: { promise?: CodeModePromise } = {}
+  const box: { derived?: CodeModePromise } = {}
  const body = Effect.gen(function* () {
    const exit = yield* reactionExit(promises, source)
    const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected
    if (handler === undefined) return yield* exit
    const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(Cause.squash(exit.cause))
    const result = yield* applyCollectionCallback(runner, handler, method, node)([input])
-    return yield* resolvePromiseValue(runner, result, node, box)
+    if (result === box.derived) return yield* Effect.fail(selfResolutionError(node))
+    if (result instanceof CodeModePromise) return yield* runner.settlePromise(result)
+    return result
  })
  return Effect.map(promises.create(body), (derived) => {
-    box.promise = derived
+    box.derived = derived
    return derived
  })
 }
@@ -340,13 +318,7 @@ const chainFinally = <R>(
      const exit = yield* reactionExit(promises, source)
      if (cleanup !== undefined) {
        const result = yield* applyCollectionCallback(runner, cleanup, method, node)([])
-        const intermediate = yield* promises.create(
-          Effect.gen(function* () {
-            yield* runner.settlePromise(yield* resolvePromise(runner, promises, result, node))
-            return yield* exit
-          }),
-        )
-        return yield* runner.settlePromise(intermediate)
+        if (result instanceof CodeModePromise) yield* runner.settlePromise(result)
      }
      return yield* exit
    }),
@@ -1,12 +1,10 @@
 import {
  type AstNode,
  CodeModeFunction,
-  CodeModeGenerator,
  CoercionFunction,
  ErrorConstructorReference,
  GlobalMethodReference,
  GlobalNamespace,
-  GeneratorMethodReference,
  InterpreterRuntimeError,
  IntrinsicReference,
  JsonMethodReference,
@@ -23,8 +21,6 @@ import { isCodeModeValue, CodeModePromise } from "../values.js"

 export const isRuntimeReference = (value: unknown): boolean =>
  value instanceof CodeModeFunction ||
-  value instanceof CodeModeGenerator ||
-  value instanceof GeneratorMethodReference ||
  value instanceof ToolReference ||
  value instanceof IntrinsicReference ||
  value instanceof GlobalNamespace ||
@@ -111,7 +107,6 @@ export const rejectCircularInsertion = (container: object, value: unknown, label
 export const typeofValue = (value: unknown): string => {
  if (
    value instanceof CodeModeFunction ||
-    value instanceof GeneratorMethodReference ||
    value instanceof CoercionFunction ||
    value instanceof IntrinsicReference ||
    value instanceof GlobalMethodReference ||
@@ -1,6 +1,5 @@
-import { Effect } from "effect"
-import { preserveConsumerError, type SyncIteratorRunner } from "../interpreter/iterator.js"
 import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
+import { spreadItems } from "./collections.js"

 // Bun exposes ES2026 Math.sumPrecise before TypeScript's standard library types.
 declare global {
@@ -54,6 +53,17 @@ export const mathMethods = new Set([
 export const invokeMathMethod = (name: string, args: Array<unknown>, node: AstNode): number => {
  if (!mathMethods.has(name)) throw new InterpreterRuntimeError(`Math.${name} is not available.`, node)
  if (name === "random") return Math.random()
+  if (name === "sumPrecise") {
+    const items = spreadItems(args[0])
+    if (items === undefined) {
+      throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable collection.", node).as("TypeError")
+    }
+    const numbers = Array.from(items)
+    if (!numbers.every((item): item is number => typeof item === "number")) {
+      throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable of numbers.", node).as("TypeError")
+    }
+    return Math.sumPrecise(numbers)
+  }
  // Validate only the arguments the method consumes; like JS, extras are ignored
  // (so built-ins work as callbacks receiving (element, index, array)).
  const num = (index: number): number => {
@@ -143,29 +153,3 @@ export const invokeMathMethod = (name: string, args: Array<unknown>, node: AstNo
  }
  throw new InterpreterRuntimeError(`Math.${name} is not available.`, node)
 }
-
-export const invokeMathSumPrecise = <R>(
-  runner: SyncIteratorRunner<R>,
-  source: unknown,
-  node: AstNode,
-): Effect.Effect<number, unknown, R> =>
-  Effect.gen(function* () {
-    const cursor = yield* runner.syncIterator(source, node)
-    if (cursor === undefined) {
-      throw new InterpreterRuntimeError("Math.sumPrecise expects a synchronous iterable.", node).as("TypeError")
-    }
-    const numbers: Array<number> = []
-    while (true) {
-      const step = yield* cursor.next
-      if (step.done) return Math.sumPrecise(numbers)
-      yield* preserveConsumerError(
-        cursor,
-        Effect.sync(() => {
-          if (typeof step.value !== "number") {
-            throw new InterpreterRuntimeError("Math.sumPrecise expects an iterable of numbers.", node).as("TypeError")
-          }
-          numbers.push(step.value)
-        }),
-      )
-    }
-  })
@@ -1,4 +1,3 @@
-import { Effect } from "effect"
 import {
  type AstNode,
  AsyncIteratorSymbol,
@@ -8,9 +7,8 @@ import {
 } from "../interpreter/model.js"
 import { containsOpaqueReference } from "../interpreter/references.js"
 import { isBlockedMember } from "../tool-runtime.js"
-import { isCodeModeValue, CodeModePromise } from "../values.js"
+import { isCodeModeValue, CodeModeMap, CodeModePromise, CodeModeSet, CodeModeURLSearchParams } from "../values.js"
 import { boundedData, coerceToString } from "./value.js"
-import { preserveConsumerError, type SyncIteratorRunner } from "../interpreter/iterator.js"

 export const objectMethodsPreservingIdentity = new Set(["assign", "values", "entries", "fromEntries"])

@@ -41,6 +39,11 @@ export const invokeObjectMethod = (name: string, args: Array<unknown>, node: Ast
    if (isBlockedMember(key)) throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node)
    out[key] = item
  }
+  const addEntry = (out: Record<string, unknown>, key: unknown, item: unknown): void => {
+    boundedData(key, "Object.fromEntries key")
+    boundedData(item, "Object.fromEntries value")
+    guardedSet(out, coerceToString(key), item)
+  }
  switch (name) {
    case "keys":
      return Object.keys(requireObject())
@@ -76,47 +79,32 @@ export const invokeObjectMethod = (name: string, args: Array<unknown>, node: Ast
      }
      return out
    }
+    case "fromEntries": {
+      if (args[0] instanceof CodeModeMap) {
+        const out: Record<string, unknown> = Object.create(null)
+        for (const [key, item] of args[0].map.entries()) addEntry(out, key, item)
+        return out
+      }
+      if (args[0] instanceof CodeModeURLSearchParams) {
+        const out: Record<string, unknown> = Object.create(null)
+        for (const [key, value] of args[0].params.entries()) guardedSet(out, key, value)
+        return out
+      }
+      const pairs = args[0] instanceof CodeModeSet ? Array.from(args[0].set.values()) : args[0]
+      if (!Array.isArray(pairs)) {
+        boundedData(args[0], "Object.fromEntries input")
+        throw new InterpreterRuntimeError("Object.fromEntries expects an array of [key, value] pairs.", node)
+      }
+      const out: Record<string, unknown> = Object.create(null)
+      for (const pair of pairs) {
+        const validated = boundedData(pair, "Object.fromEntries entry")
+        if (validated === null || typeof validated !== "object" || isCodeModeValue(validated))
+          throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node)
+        const entry = pair as Record<string, unknown>
+        addEntry(out, entry[0], entry[1])
+      }
+      return out
+    }
  }
  throw new InterpreterRuntimeError(`Object.${name} is not available.`, node)
 }
-
-export const invokeObjectFromEntries = <R>(
-  runner: SyncIteratorRunner<R>,
-  source: unknown,
-  node: AstNode,
-): Effect.Effect<Record<string, unknown>, unknown, R> => {
-  const out: Record<string, unknown> = Object.create(null)
-  return Effect.gen(function* () {
-    const cursor = yield* runner.syncIterator(source, node)
-    if (cursor === undefined) {
-      throw new InterpreterRuntimeError("Object.fromEntries expects a synchronous iterable of entries.", node).as(
-        "TypeError",
-      )
-    }
-    while (true) {
-      const step = yield* cursor.next
-      if (step.done) return out
-      yield* preserveConsumerError(
-        cursor,
-        Effect.sync(() => {
-          if (
-            step.value === null ||
-            typeof step.value !== "object" ||
-            isCodeModeValue(step.value) ||
-            containsOpaqueReference(step.value)
-          ) {
-            throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] entry objects.", node).as(
-              "TypeError",
-            )
-          }
-          const entry = step.value as Record<string, unknown>
-          boundedData(entry[0], "Object.fromEntries key")
-          boundedData(entry[1], "Object.fromEntries value")
-          const key = coerceToString(entry[0])
-          if (isBlockedMember(key)) throw new InterpreterRuntimeError(`Property '${key}' is not available.`, node)
-          out[key] = entry[1]
-        }),
-      )
-    }
-  })
-}
@@ -553,7 +553,7 @@ export const prepare = <R>(tools: Tools<R>, catalogBudget = defaultCatalogBudget
    "## Language",
    "",
    "Use common JavaScript data operations, functions, control flow, selected standard-library methods, and awaited tool calls. Built-ins include Date, RegExp, Map, Set, URL, URLSearchParams, and URI encoding helpers.",
-    "Modules/imports, classes, timers, fetch, eval, prototype access, and unlisted methods are unavailable. Use tools for external operations. Use await with try/catch.",
+    "Modules/imports, classes, generators, timers, fetch, eval, prototype access, and unlisted methods are unavailable. Use tools for external operations. Use await with try/catch.",
    "Prefer explicit `return`; otherwise only the final top-level expression becomes the result.",
    "Dates and URLs serialize to strings at data boundaries; Map/Set/RegExp/URLSearchParams serialize to `{}`.",
  ]
@@ -732,10 +732,9 @@ describe("CodeMode public contract", () => {
    expect(instructions).toContain("not a general-purpose runtime")
    expect(instructions).not.toContain("Standard modern JavaScript works")
    expect(instructions).not.toContain("TypeScript type annotations")
-    for (const missing of ["Modules/imports", "classes", "fetch"]) {
+    for (const missing of ["Modules/imports", "classes", "generators", "fetch"]) {
      expect(instructions).toContain(missing)
    }
-    expect(instructions).not.toContain("generators")
    expect(instructions).not.toContain("new Promise(...) are unavailable")
    expect(instructions).not.toContain("promise chaining")
    expect(instructions).toContain("URL, URLSearchParams, and URI encoding helpers")
@@ -10561,10 +10561,26 @@
        "additionalProperties": false
      },
      "Agent.Color": {
-        "type": "string",
-        "allOf": [
+        "anyOf": [
          {
-            "pattern": "^#[0-9a-fA-F]{6}$"
+            "type": "string",
+            "allOf": [
+              {
+                "pattern": "^#[0-9a-fA-F]{6}$"
+              }
+            ]
+          },
+          {
+            "type": "string",
+            "enum": [
+              "primary",
+              "secondary",
+              "accent",
+              "success",
+              "warning",
+              "error",
+              "info"
+            ]
          }
        ]
      },
@@ -946,7 +946,7 @@ describe("Test262 expected Promise conformance", () => {
    ).toBe("TypeError")
  })

-  test("Promise.resolve recursively assimilates callable thenables", async () => {
+  test.failing("Promise.resolve recursively assimilates callable thenables", async () => {
    // Source: test/built-ins/Promise/resolve/resolve-thenable.js
    expect(
      await value(`
@@ -958,7 +958,7 @@ describe("Test262 expected Promise conformance", () => {
    ).toBe(true)
  })

-  test("Promise combinators assimilate callable thenable inputs", async () => {
+  test.failing("Promise combinators assimilate callable thenable inputs", async () => {
    // Sources:
    // test/built-ins/Promise/all/reject-immed.js
    // test/built-ins/Promise/all/reject-ignored-immed.js
@@ -988,7 +988,7 @@ describe("Test262 expected Promise conformance", () => {
    ])
  })

-  test("await assimilates callable thenables", async () => {
+  test.failing("await assimilates callable thenables", async () => {
    // Source: test/language/expressions/await/await-awaits-thenables.js
    expect(
      await value(`
@@ -998,7 +998,7 @@ describe("Test262 expected Promise conformance", () => {
    ).toBe(42)
  })

-  test("await rejects when a callable thenable throws", async () => {
+  test.failing("await rejects when a callable thenable throws", async () => {
    // Source: test/language/expressions/await/await-awaits-thenables-that-throw.js
    expect(
      await value(`
@@ -1013,94 +1013,6 @@ describe("Test262 expected Promise conformance", () => {
      `),
    ).toBe(true)
  })
-
-  test("thenable resolution is deferred and settles only once", async () => {
-    // Sources:
-    // test/built-ins/Promise/resolve/S25.Promise_resolve_foreign_thenable_2.js
-    // test/built-ins/Promise/exception-after-resolve-in-thenable-job.js
-    expect(
-      await value(`
-        const sequence = []
-        const thenable = {
-          then: (resolve, reject) => {
-            sequence.push("then")
-            resolve(1)
-            reject(2)
-            throw 3
-          }
-        }
-        const promise = Promise.resolve(thenable)
-        sequence.push("after resolve")
-        const result = await promise
-        sequence.push("after await")
-        return [result, sequence]
-      `),
-    ).toEqual([1, ["after resolve", "then", "after await"]])
-  })
-
-  test("the first thenable rejection wins over later resolution and throws", async () => {
-    // Source: test/built-ins/Promise/exception-after-resolve-in-thenable-job.js
-    expect(
-      await value(`
-        const thenable = {
-          then: (resolve, reject) => {
-            reject("first")
-            resolve("second")
-            throw "third"
-          }
-        }
-        try {
-          await thenable
-          return "fulfilled"
-        } catch (reason) {
-          return reason
-        }
-      `),
-    ).toBe("first")
-  })
-
-  test("constructors, reactions, finally, and async returns assimilate thenables", async () => {
-    // Sources:
-    // test/built-ins/Promise/resolve-thenable-immed.js
-    // test/built-ins/Promise/prototype/then/resolve-settled-fulfilled-thenable.js
-    // test/built-ins/Promise/prototype/finally/resolved-observable-then-calls.js
-    const thenable = (value: string) => `({ then: (resolve) => resolve(${JSON.stringify(value)}) })`
-    expect(
-      await value(`
-        const fromAsync = async () => ${thenable("async")}
-        const cleanup = []
-        return await Promise.all([
-          new Promise((resolve) => resolve(${thenable("constructor")})),
-          Promise.resolve().then(() => ${thenable("reaction")}),
-          Promise.resolve("kept").finally(() => {
-            cleanup.push("ran")
-            return ${thenable("ignored")}
-          }),
-          fromAsync(),
-        ]).then((values) => [values, cleanup])
-      `),
-    ).toEqual([["constructor", "reaction", "kept", "async"], ["ran"]])
-  })
-
-  test("finally settles after its cleanup thenable reactions", async () => {
-    // Source: test/built-ins/Promise/prototype/finally/resolved-observable-then-calls-PromiseResolve.js
-    expect(
-      await value(`
-        const sequence = []
-        const cleanup = { then: (resolve) => { sequence.push("then"); resolve() } }
-        const result = Promise.resolve("kept").finally(() => cleanup)
-        result.then(() => sequence.push("finally"))
-        Promise.resolve()
-          .then(() => sequence.push("tick1"))
-          .then(() => sequence.push("tick2"))
-          .then(() => sequence.push("tick3"))
-          .then(() => sequence.push("tick4"))
-        await result
-        sequence.push("await")
-        return sequence
-      `),
-    ).toEqual(["tick1", "then", "tick2", "tick3", "tick4", "finally", "await"])
-  })
 })

 describe("Test262 Promise.any", () => {
@@ -254,7 +254,7 @@ export const dict = {
  "go.title": "OpenCode Go | نماذج برمجة منخفضة التكلفة للجميع",
  "go.banner.text": "يحصل Kimi K3 على حدود استخدام مضاعفة لفترة محدودة",
  "go.meta.description":
-    "يبدأ Go من $5 للشهر الأول، ثم $10/شهر، مع حدود طلب سخية لمدة 5 ساعات لـ Grok 4.5 وGLM-5.2 وGLM-5.1 وKimi K3 وKimi K2.7 Code وKimi K2.6 وMiMo-V2.5-Pro وMiMo-V2.5 وQwen3.7 Max وQwen3.7 Plus وQwen3.6 Plus وMiniMax M2.7 وMiniMax M3 وDeepSeek V4 Pro وDeepSeek V4 Flash وHy3.",
+    "يبدأ Go من $5 للشهر الأول، ثم $10/شهر، مع حدود طلب سخية لمدة 5 ساعات لـ Grok 4.5 وGLM-5.2 وGLM-5.1 وKimi K3 وKimi K2.7 Code وKimi K2.6 وMiMo-V2.5-Pro وMiMo-V2.5 وQwen3.7 Max وQwen3.7 Plus وQwen3.6 Plus وMiniMax M2.7 وMiniMax M3 وDeepSeek V4 Pro وDeepSeek V4 Flash.",
  "go.hero.title": "نماذج برمجة منخفضة التكلفة للجميع",
  "go.hero.body":
    "يجلب Go البرمجة الوكيلة للمبرمجين حول العالم. يوفر حدودًا سخية ووصولًا موثوقًا إلى أقوى النماذج مفتوحة المصدر، حتى تتمكن من البناء باستخدام وكلاء أقوياء دون القلق بشأن التكلفة أو التوفر.",
@@ -302,7 +302,7 @@ export const dict = {
  "go.problem.item2": "حدود سخية ووصول موثوق",
  "go.problem.item3": "مصمم لأكبر عدد ممكن من المبرمجين",
  "go.problem.item4":
-    "يتضمن Grok 4.5 وGLM-5.2 وGLM-5.1 وKimi K3 وKimi K2.7 Code وKimi K2.6 وMiMo-V2.5-Pro وMiMo-V2.5 وQwen3.7 Max وQwen3.7 Plus وQwen3.6 Plus وMiniMax M2.7 وMiniMax M3 وDeepSeek V4 Pro وDeepSeek V4 Flash وHy3",
+    "يتضمن Grok 4.5 وGLM-5.2 وGLM-5.1 وKimi K3 وKimi K2.7 Code وKimi K2.6 وMiMo-V2.5-Pro وMiMo-V2.5 وQwen3.7 Max وQwen3.7 Plus وQwen3.6 Plus وMiniMax M2.7 وMiniMax M3 وDeepSeek V4 Pro وDeepSeek V4 Flash",
  "go.how.title": "كيف يعمل Go",
  "go.how.body": "يبدأ Go من $5 للشهر الأول، ثم $10/شهر. يمكنك استخدامه مع OpenCode أو أي وكيل.",
  "go.how.step1.title": "أنشئ حسابًا",
@@ -326,7 +326,7 @@ export const dict = {
  "go.faq.a2": "يتضمن Go النماذج المدرجة أدناه، مع حدود سخية وإتاحة موثوقة.",
  "go.faq.q3": "هل Go هو نفسه Zen؟",
  "go.faq.a3":
-    "لا. Zen هو الدفع حسب الاستخدام، بينما يبدأ Go من $5 للشهر الأول، ثم $10/شهر، مع حدود سخية ووصول موثوق إلى نماذج المصدر المفتوح Grok 4.5 وGLM-5.2 وGLM-5.1 وKimi K3 وKimi K2.7 Code وKimi K2.6 وMiMo-V2.5-Pro وMiMo-V2.5 وQwen3.7 Max وQwen3.7 Plus وQwen3.6 Plus وMiniMax M2.7 وMiniMax M3 وDeepSeek V4 Pro وDeepSeek V4 Flash وHy3.",
+    "لا. Zen هو الدفع حسب الاستخدام، بينما يبدأ Go من $5 للشهر الأول، ثم $10/شهر، مع حدود سخية ووصول موثوق إلى نماذج المصدر المفتوح Grok 4.5 وGLM-5.2 وGLM-5.1 وKimi K3 وKimi K2.7 Code وKimi K2.6 وMiMo-V2.5-Pro وMiMo-V2.5 وQwen3.7 Max وQwen3.7 Plus وQwen3.6 Plus وMiniMax M2.7 وMiniMax M3 وDeepSeek V4 Pro وDeepSeek V4 Flash.",
  "go.faq.q4": "كم تكلفة Go؟",
  "go.faq.a4.p1.beforePricing": "تكلفة Go",
  "go.faq.a4.p1.pricingLink": "$5 للشهر الأول",
@@ -349,7 +349,7 @@ export const dict = {

  "go.faq.q9": "ما الفرق بين النماذج المجانية وGo؟",
  "go.faq.a9":
-    "تشمل النماذج المجانية Big Pickle بالإضافة إلى النماذج الترويجية المتاحة في ذلك الوقت، مع حصة 200 طلب/يوم. يتضمن Go نماذج Grok 4.5 وGLM-5.2 وGLM-5.1 وKimi K3 وKimi K2.7 Code وKimi K2.6 وMiMo-V2.5-Pro وMiMo-V2.5 وQwen3.7 Max وQwen3.7 Plus وQwen3.6 Plus وMiniMax M2.7 وMiniMax M3 وDeepSeek V4 Pro وDeepSeek V4 Flash وHy3 مع حصص طلبات أعلى مطبقة عبر نوافذ متجددة (5 ساعات، أسبوعيًا، وشهريًا)، تعادل تقريبًا 12 دولارًا كل 5 ساعات، و30 دولارًا في الأسبوع، و60 دولارًا في الشهر (تختلف أعداد الطلبات الفعلية حسب النموذج والاستخدام).",
+    "تشمل النماذج المجانية Big Pickle بالإضافة إلى النماذج الترويجية المتاحة في ذلك الوقت، مع حصة 200 طلب/يوم. يتضمن Go نماذج Grok 4.5 وGLM-5.2 وGLM-5.1 وKimi K3 وKimi K2.7 Code وKimi K2.6 وMiMo-V2.5-Pro وMiMo-V2.5 وQwen3.7 Max وQwen3.7 Plus وQwen3.6 Plus وMiniMax M2.7 وMiniMax M3 وDeepSeek V4 Pro وDeepSeek V4 Flash مع حصص طلبات أعلى مطبقة عبر نوافذ متجددة (5 ساعات، أسبوعيًا، وشهريًا)، تعادل تقريبًا 12 دولارًا كل 5 ساعات، و30 دولارًا في الأسبوع، و60 دولارًا في الشهر (تختلف أعداد الطلبات الفعلية حسب النموذج والاستخدام).",

  "zen.api.error.rateLimitExceeded": "تم تجاوز حد الطلبات. يرجى المحاولة مرة أخرى لاحقًا.",
  "zen.api.error.modelNotSupported": "النموذج {{model}} غير مدعوم",
@@ -258,7 +258,7 @@ export const dict = {
  "go.title": "OpenCode Go | Modelos de codificação de baixo custo para todos",
  "go.banner.text": "Kimi K3 tem limites de uso 2x maiores por tempo limitado",
  "go.meta.description":
-    "O Go começa em $5 no primeiro mês, depois $10/mês, com limites generosos de solicitação de 5 horas para Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash e Hy3.",
+    "O Go começa em $5 no primeiro mês, depois $10/mês, com limites generosos de solicitação de 5 horas para Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro e DeepSeek V4 Flash.",
  "go.hero.title": "Modelos de codificação de baixo custo para todos",
  "go.hero.body":
    "O Go traz a codificação com agentes para programadores em todo o mundo. Oferecendo limites generosos e acesso confiável aos modelos de código aberto mais capazes, para que você possa construir com agentes poderosos sem se preocupar com custos ou disponibilidade.",
@@ -307,7 +307,7 @@ export const dict = {
  "go.problem.item2": "Limites generosos e acesso confiável",
  "go.problem.item3": "Feito para o maior número possível de programadores",
  "go.problem.item4":
-    "Inclui Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash e Hy3",
+    "Inclui Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro e DeepSeek V4 Flash",
  "go.how.title": "Como o Go funciona",
  "go.how.body":
    "O Go começa em $5 no primeiro mês, depois $10/mês. Você pode usá-lo com o OpenCode ou qualquer agente.",
@@ -333,7 +333,7 @@ export const dict = {
  "go.faq.a2": "O Go inclui os modelos listados abaixo, com limites generosos e acesso confiável.",
  "go.faq.q3": "O Go é o mesmo que o Zen?",
  "go.faq.a3":
-    "Não. Zen é pay-as-you-go, enquanto o Go começa em $5 no primeiro mês, depois $10/mês, com limites generosos e acesso confiável aos modelos open source Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash e Hy3.",
+    "Não. Zen é pay-as-you-go, enquanto o Go começa em $5 no primeiro mês, depois $10/mês, com limites generosos e acesso confiável aos modelos open source Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro e DeepSeek V4 Flash.",
  "go.faq.q4": "Quanto custa o Go?",
  "go.faq.a4.p1.beforePricing": "O Go custa",
  "go.faq.a4.p1.pricingLink": "$5 no primeiro mês",
@@ -357,7 +357,7 @@ export const dict = {

  "go.faq.q9": "Qual a diferença entre os modelos gratuitos e o Go?",
  "go.faq.a9":
-    "Os modelos gratuitos incluem Big Pickle e modelos promocionais disponíveis no momento, com uma cota de 200 requisições/dia. O Go inclui Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash e Hy3 com cotas de requisição mais altas aplicadas em janelas móveis (5 horas, semanal e mensal), aproximadamente equivalentes a $12 por 5 horas, $30 por semana e $60 por mês (as contagens reais de requisições variam de acordo com o modelo e o uso).",
+    "Os modelos gratuitos incluem Big Pickle e modelos promocionais disponíveis no momento, com uma cota de 200 requisições/dia. O Go inclui Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro e DeepSeek V4 Flash com cotas de requisição mais altas aplicadas em janelas móveis (5 horas, semanal e mensal), aproximadamente equivalentes a $12 por 5 horas, $30 por semana e $60 por mês (as contagens reais de requisições variam de acordo com o modelo e o uso).",

  "zen.api.error.rateLimitExceeded": "Limite de taxa excedido. Por favor, tente novamente mais tarde.",
  "zen.api.error.modelNotSupported": "Modelo {{model}} não suportado",
@@ -256,7 +256,7 @@ export const dict = {
  "go.title": "OpenCode Go | Kodningsmodeller til lav pris for alle",
  "go.banner.text": "Kimi K3 får fordoblet brugsgrænse i en begrænset periode",
  "go.meta.description":
-    "Go starter ved $5 for den første måned, derefter $10/måned, med generøse 5-timers anmodningsgrænser for Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash og Hy3.",
+    "Go starter ved $5 for den første måned, derefter $10/måned, med generøse 5-timers anmodningsgrænser for Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro og DeepSeek V4 Flash.",
  "go.hero.title": "Kodningsmodeller til lav pris for alle",
  "go.hero.body":
    "Go bringer agentisk kodning til programmører over hele verden. Med generøse grænser og pålidelig adgang til de mest kapable open source-modeller, så du kan bygge med kraftfulde agenter uden at bekymre dig om omkostninger eller tilgængelighed.",
@@ -304,7 +304,7 @@ export const dict = {
  "go.problem.item2": "Generøse grænser og pålidelig adgang",
  "go.problem.item3": "Bygget til så mange programmører som muligt",
  "go.problem.item4":
-    "Inkluderer Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash og Hy3",
+    "Inkluderer Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro og DeepSeek V4 Flash",
  "go.how.title": "Hvordan Go virker",
  "go.how.body":
    "Go starter ved $5 for den første måned, derefter $10/måned. Du kan bruge det med OpenCode eller enhver agent.",
@@ -330,7 +330,7 @@ export const dict = {
  "go.faq.a2": "Go inkluderer modellerne nedenfor med generøse grænser og pålidelig adgang.",
  "go.faq.q3": "Er Go det samme som Zen?",
  "go.faq.a3":
-    "Nej. Zen er pay-as-you-go, mens Go starter ved $5 for den første måned, derefter $10/måned, med generøse grænser og pålidelig adgang til open source-modellerne Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash og Hy3.",
+    "Nej. Zen er pay-as-you-go, mens Go starter ved $5 for den første måned, derefter $10/måned, med generøse grænser og pålidelig adgang til open source-modellerne Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro og DeepSeek V4 Flash.",
  "go.faq.q4": "Hvad koster Go?",
  "go.faq.a4.p1.beforePricing": "Go koster",
  "go.faq.a4.p1.pricingLink": "$5 første måned",
@@ -353,7 +353,7 @@ export const dict = {

  "go.faq.q9": "Hvad er forskellen på gratis modeller og Go?",
  "go.faq.a9":
-    "Gratis modeller inkluderer Big Pickle plus salgsfremmende modeller tilgængelige på det tidspunkt, med en kvote på 200 forespørgsler/dag. Go inkluderer Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash og Hy3 med højere anmodningskvoter håndhævet over rullende vinduer (5-timers, ugentlig og månedlig), nogenlunde svarende til $12 pr. 5 timer, $30 pr. uge og $60 pr. måned (faktiske anmodningstal varierer efter model og brug).",
+    "Gratis modeller inkluderer Big Pickle plus salgsfremmende modeller tilgængelige på det tidspunkt, med en kvote på 200 forespørgsler/dag. Go inkluderer Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro og DeepSeek V4 Flash med højere anmodningskvoter håndhævet over rullende vinduer (5-timers, ugentlig og månedlig), nogenlunde svarende til $12 pr. 5 timer, $30 pr. uge og $60 pr. måned (faktiske anmodningstal varierer efter model og brug).",

  "zen.api.error.rateLimitExceeded": "Hastighedsgrænse overskredet. Prøv venligst igen senere.",
  "zen.api.error.modelNotSupported": "Model {{model}} understøttes ikke",
@@ -258,7 +258,7 @@ export const dict = {
  "go.title": "OpenCode Go | Kostengünstige Coding-Modelle für alle",
  "go.banner.text": "Kimi K3 erhält für begrenzte Zeit 2x Nutzungslimits",
  "go.meta.description":
-    "Go beginnt bei $5 für den ersten Monat, danach $10/Monat, mit großzügigen 5-Stunden-Anfragelimits für Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash und Hy3.",
+    "Go beginnt bei $5 für den ersten Monat, danach $10/Monat, mit großzügigen 5-Stunden-Anfragelimits für Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro und DeepSeek V4 Flash.",
  "go.hero.title": "Kostengünstige Coding-Modelle für alle",
  "go.hero.body":
    "Go bringt Agentic Coding zu Programmierern auf der ganzen Welt. Mit großzügigen Limits und zuverlässigem Zugang zu den leistungsfähigsten Open-Source-Modellen, damit du mit leistungsstarken Agenten entwickeln kannst, ohne dir Gedanken über Kosten oder Verfügbarkeit zu machen.",
@@ -306,7 +306,7 @@ export const dict = {
  "go.problem.item2": "Großzügige Limits und zuverlässiger Zugang",
  "go.problem.item3": "Für so viele Programmierer wie möglich gebaut",
  "go.problem.item4":
-    "Beinhaltet Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash und Hy3",
+    "Beinhaltet Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro und DeepSeek V4 Flash",
  "go.how.title": "Wie Go funktioniert",
  "go.how.body":
    "Go beginnt bei $5 für den ersten Monat, danach $10/Monat. Du kannst es mit OpenCode oder jedem Agenten nutzen.",
@@ -332,7 +332,7 @@ export const dict = {
  "go.faq.a2": "Go umfasst die unten aufgeführten Modelle mit großzügigen Limits und zuverlässigem Zugriff.",
  "go.faq.q3": "Ist Go dasselbe wie Zen?",
  "go.faq.a3":
-    "Nein. Zen ist Pay-as-you-go, während Go bei $5 für den ersten Monat beginnt, danach $10/Monat, mit großzügigen Limits und zuverlässigem Zugang zu den Open-Source-Modellen Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash und Hy3.",
+    "Nein. Zen ist Pay-as-you-go, während Go bei $5 für den ersten Monat beginnt, danach $10/Monat, mit großzügigen Limits und zuverlässigem Zugang zu den Open-Source-Modellen Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro und DeepSeek V4 Flash.",
  "go.faq.q4": "Wie viel kostet Go?",
  "go.faq.a4.p1.beforePricing": "Go kostet",
  "go.faq.a4.p1.pricingLink": "$5 im ersten Monat",
@@ -356,7 +356,7 @@ export const dict = {

  "go.faq.q9": "Was ist der Unterschied zwischen kostenlosen Modellen und Go?",
  "go.faq.a9":
-    "Kostenlose Modelle beinhalten Big Pickle sowie Werbemodelle, die zum jeweiligen Zeitpunkt verfügbar sind, mit einem Kontingent von 200 Anfragen/Tag. Go beinhaltet Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash und Hy3 mit höheren Anfragekontingenten, die über rollierende Zeitfenster (5 Stunden, wöchentlich und monatlich) durchgesetzt werden, grob äquivalent zu $12 pro 5 Stunden, $30 pro Woche und $60 pro Monat (tatsächliche Anfragezahlen variieren je nach Modell und Nutzung).",
+    "Kostenlose Modelle beinhalten Big Pickle sowie Werbemodelle, die zum jeweiligen Zeitpunkt verfügbar sind, mit einem Kontingent von 200 Anfragen/Tag. Go beinhaltet Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro und DeepSeek V4 Flash mit höheren Anfragekontingenten, die über rollierende Zeitfenster (5 Stunden, wöchentlich und monatlich) durchgesetzt werden, grob äquivalent zu $12 pro 5 Stunden, $30 pro Woche und $60 pro Monat (tatsächliche Anfragezahlen variieren je nach Modell und Nutzung).",

  "zen.api.error.rateLimitExceeded": "Ratenlimit überschritten. Bitte versuche es später erneut.",
  "zen.api.error.modelNotSupported": "Modell {{model}} wird nicht unterstützt",
@@ -255,7 +255,7 @@ export const dict = {
  "go.title": "OpenCode Go | Low cost coding models for everyone",
  "go.banner.text": "Kimi K3 gets 2× usage limits for a limited time",
  "go.meta.description":
-    "Go starts at $5 for your first month, then $10/month, with generous 5-hour request limits for Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash, and Hy3.",
+    "Go starts at $5 for your first month, then $10/month, with generous 5-hour request limits for Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, and DeepSeek V4 Flash.",
  "go.hero.title": "Low cost coding models for everyone",
  "go.hero.body":
    "Go brings agentic coding to programmers around the world. Offering generous limits and reliable access to the most capable open-source models, so you can build with powerful agents without worrying about cost or availability.",
@@ -302,7 +302,7 @@ export const dict = {
  "go.problem.item2": "Generous limits and reliable access",
  "go.problem.item3": "Built for as many programmers as possible",
  "go.problem.item4":
-    "Includes Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash, and Hy3",
+    "Includes Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, and DeepSeek V4 Flash",
  "go.how.title": "How Go works",
  "go.how.body": "Go starts at $5 for your first month, then $10/month. You can use it with OpenCode or any agent.",
  "go.how.step1.title": "Create an account",
@@ -327,7 +327,7 @@ export const dict = {
  "go.faq.a2": "Go includes the models listed below, with generous limits and reliable access.",
  "go.faq.q3": "Is Go the same as Zen?",
  "go.faq.a3":
-    "No. Zen is pay-as-you-go, while Go starts at $5 for your first month, then $10/month, with generous limits and reliable access to open-source models Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash, and Hy3.",
+    "No. Zen is pay-as-you-go, while Go starts at $5 for your first month, then $10/month, with generous limits and reliable access to open-source models Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, and DeepSeek V4 Flash.",
  "go.faq.q4": "How much does Go cost?",
  "go.faq.a4.p1.beforePricing": "Go costs",
  "go.faq.a4.p1.pricingLink": "$5 first month",
@@ -351,7 +351,7 @@ export const dict = {

  "go.faq.q9": "What is the difference between free models and Go?",
  "go.faq.a9":
-    "Free models include Big Pickle plus promotional models available at the time, with a quota of 200 requests/day. Go includes Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash, and Hy3 with higher request quotas enforced across rolling windows (5-hour, weekly, and monthly), roughly equivalent to $12 per 5 hours, $30 per week, and $60 per month (actual request counts vary by model and usage).",
+    "Free models include Big Pickle plus promotional models available at the time, with a quota of 200 requests/day. Go includes Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, and DeepSeek V4 Flash with higher request quotas enforced across rolling windows (5-hour, weekly, and monthly), roughly equivalent to $12 per 5 hours, $30 per week, and $60 per month (actual request counts vary by model and usage).",

  "zen.api.error.rateLimitExceeded": "Rate limit exceeded. Please try again later.",
  "zen.api.error.modelNotSupported": "Model {{model}} is not supported",
@@ -259,7 +259,7 @@ export const dict = {
  "go.title": "OpenCode Go | Modelos de programación de bajo coste para todos",
  "go.banner.text": "Kimi K3 tiene límites de uso 2x mayores por tiempo limitado",
  "go.meta.description":
-    "Go comienza en $5 el primer mes, luego 10 $/mes, con generosos límites de solicitudes de 5 horas para Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash y Hy3.",
+    "Go comienza en $5 el primer mes, luego 10 $/mes, con generosos límites de solicitudes de 5 horas para Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro y DeepSeek V4 Flash.",
  "go.hero.title": "Modelos de programación de bajo coste para todos",
  "go.hero.body":
    "Go lleva la programación agéntica a programadores de todo el mundo. Ofrece límites generosos y acceso fiable a los modelos de código abierto más capaces, para que puedas crear con agentes potentes sin preocuparte por el coste o la disponibilidad.",
@@ -308,7 +308,7 @@ export const dict = {
  "go.problem.item2": "Límites generosos y acceso fiable",
  "go.problem.item3": "Creado para tantos programadores como sea posible",
  "go.problem.item4":
-    "Incluye Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash y Hy3",
+    "Incluye Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro y DeepSeek V4 Flash",
  "go.how.title": "Cómo funciona Go",
  "go.how.body": "Go comienza en $5 el primer mes, luego 10 $/mes. Puedes usarlo con OpenCode o cualquier agente.",
  "go.how.step1.title": "Crear una cuenta",
@@ -333,7 +333,7 @@ export const dict = {
  "go.faq.a2": "Go incluye los modelos que se indican abajo, con límites generosos y acceso confiable.",
  "go.faq.q3": "¿Es Go lo mismo que Zen?",
  "go.faq.a3":
-    "No. Zen es pago por uso, mientras que Go comienza en $5 el primer mes, luego 10 $/mes, con límites generosos y acceso fiable a los modelos de código abierto Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash y Hy3.",
+    "No. Zen es pago por uso, mientras que Go comienza en $5 el primer mes, luego 10 $/mes, con límites generosos y acceso fiable a los modelos de código abierto Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro y DeepSeek V4 Flash.",
  "go.faq.q4": "¿Cuánto cuesta Go?",
  "go.faq.a4.p1.beforePricing": "Go cuesta",
  "go.faq.a4.p1.pricingLink": "$5 el primer mes",
@@ -357,7 +357,7 @@ export const dict = {

  "go.faq.q9": "¿Cuál es la diferencia entre los modelos gratuitos y Go?",
  "go.faq.a9":
-    "Los modelos gratuitos incluyen Big Pickle más modelos promocionales disponibles en el momento, con una cuota de 200 solicitudes/día. Go incluye Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash y Hy3 con cuotas de solicitud más altas aplicadas a través de ventanas móviles (5 horas, semanal y mensual), aproximadamente equivalente a 12 $ por 5 horas, 30 $ por semana y 60 $ por mes (los recuentos reales de solicitudes varían según el modelo y el uso).",
+    "Los modelos gratuitos incluyen Big Pickle más modelos promocionales disponibles en el momento, con una cuota de 200 solicitudes/día. Go incluye Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro y DeepSeek V4 Flash con cuotas de solicitud más altas aplicadas a través de ventanas móviles (5 horas, semanal y mensual), aproximadamente equivalente a 12 $ por 5 horas, 30 $ por semana y 60 $ por mes (los recuentos reales de solicitudes varían según el modelo y el uso).",

  "zen.api.error.rateLimitExceeded": "Límite de tasa excedido. Por favor, inténtalo de nuevo más tarde.",
  "zen.api.error.modelNotSupported": "Modelo {{model}} no soportado",
@@ -260,7 +260,7 @@ export const dict = {
  "go.title": "OpenCode Go | Modèles de code à faible coût pour tous",
  "go.banner.text": "Kimi K3 bénéficie de limites d’utilisation 2x supérieures pour une durée limitée",
  "go.meta.description":
-    "Go commence à $5 pour le premier mois, puis 10 $/mois, avec des limites de requêtes généreuses sur 5 heures pour Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash et Hy3.",
+    "Go commence à $5 pour le premier mois, puis 10 $/mois, avec des limites de requêtes généreuses sur 5 heures pour Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro et DeepSeek V4 Flash.",
  "go.hero.title": "Modèles de code à faible coût pour tous",
  "go.hero.body":
    "Go apporte le codage agentique aux programmeurs du monde entier. Offrant des limites généreuses et un accès fiable aux modèles open source les plus capables, pour que vous puissiez construire avec des agents puissants sans vous soucier du coût ou de la disponibilité.",
@@ -308,7 +308,7 @@ export const dict = {
  "go.problem.item2": "Limites généreuses et accès fiable",
  "go.problem.item3": "Conçu pour autant de programmeurs que possible",
  "go.problem.item4":
-    "Inclut Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash et Hy3",
+    "Inclut Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro et DeepSeek V4 Flash",
  "go.how.title": "Comment fonctionne Go",
  "go.how.body":
    "Go commence à $5 pour le premier mois, puis 10 $/mois. Vous pouvez l'utiliser avec OpenCode ou n'importe quel agent.",
@@ -334,7 +334,7 @@ export const dict = {
  "go.faq.a2": "Go inclut les modèles ci-dessous, avec des limites généreuses et un accès fiable.",
  "go.faq.q3": "Est-ce que Go est la même chose que Zen ?",
  "go.faq.a3":
-    "Non. Zen est un paiement à l'utilisation, tandis que Go commence à $5 pour le premier mois, puis 10 $/mois, avec des limites généreuses et un accès fiable aux modèles open source Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash et Hy3.",
+    "Non. Zen est un paiement à l'utilisation, tandis que Go commence à $5 pour le premier mois, puis 10 $/mois, avec des limites généreuses et un accès fiable aux modèles open source Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro et DeepSeek V4 Flash.",
  "go.faq.q4": "Combien coûte Go ?",
  "go.faq.a4.p1.beforePricing": "Go coûte",
  "go.faq.a4.p1.pricingLink": "$5 le premier mois",
@@ -357,7 +357,7 @@ export const dict = {
    "Oui, vous pouvez utiliser Go avec n'importe quel agent. Suivez les instructions de configuration dans votre agent de code préféré.",
  "go.faq.q9": "Quelle est la différence entre les modèles gratuits et Go ?",
  "go.faq.a9":
-    "Les modèles gratuits incluent Big Pickle ainsi que des modèles promotionnels disponibles à ce moment-là, avec un quota de 200 requêtes/jour. Go inclut Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash et Hy3 avec des quotas de requêtes plus élevés appliqués sur des fenêtres glissantes (5 heures, hebdomadaire et mensuelle), à peu près équivalent à 12 $ par 5 heures, 30 $ par semaine et 60 $ par mois (le nombre réel de requêtes varie selon le modèle et l'utilisation).",
+    "Les modèles gratuits incluent Big Pickle ainsi que des modèles promotionnels disponibles à ce moment-là, avec un quota de 200 requêtes/jour. Go inclut Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro et DeepSeek V4 Flash avec des quotas de requêtes plus élevés appliqués sur des fenêtres glissantes (5 heures, hebdomadaire et mensuelle), à peu près équivalent à 12 $ par 5 heures, 30 $ par semaine et 60 $ par mois (le nombre réel de requêtes varie selon le modèle et l'utilisation).",

  "zen.api.error.rateLimitExceeded": "Limite de débit dépassée. Veuillez réessayer plus tard.",
  "zen.api.error.modelNotSupported": "Modèle {{model}} non pris en charge",
@@ -256,7 +256,7 @@ export const dict = {
  "go.title": "OpenCode Go | Modelli di coding a basso costo per tutti",
  "go.banner.text": "Kimi K3 offre limiti di utilizzo 2x superiori per un periodo limitato",
  "go.meta.description":
-    "Go inizia a $5 per il primo mese, poi $10/mese, con generosi limiti di richiesta di 5 ore per Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash e Hy3.",
+    "Go inizia a $5 per il primo mese, poi $10/mese, con generosi limiti di richiesta di 5 ore per Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro e DeepSeek V4 Flash.",
  "go.hero.title": "Modelli di coding a basso costo per tutti",
  "go.hero.body":
    "Go porta il coding agentico ai programmatori di tutto il mondo. Offrendo limiti generosi e un accesso affidabile ai modelli open source più capaci, in modo da poter costruire con agenti potenti senza preoccuparsi dei costi o della disponibilità.",
@@ -304,7 +304,7 @@ export const dict = {
  "go.problem.item2": "Limiti generosi e accesso affidabile",
  "go.problem.item3": "Costruito per il maggior numero possibile di programmatori",
  "go.problem.item4":
-    "Include Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash e Hy3",
+    "Include Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro e DeepSeek V4 Flash",
  "go.how.title": "Come funziona Go",
  "go.how.body": "Go inizia a $5 per il primo mese, poi $10/mese. Puoi usarlo con OpenCode o qualsiasi agente.",
  "go.how.step1.title": "Crea un account",
@@ -329,7 +329,7 @@ export const dict = {
  "go.faq.a2": "Go include i modelli elencati di seguito, con limiti generosi e accesso affidabile.",
  "go.faq.q3": "Go è lo stesso di Zen?",
  "go.faq.a3":
-    "No. Zen è a consumo, mentre Go inizia a $5 per il primo mese, poi $10/mese, con limiti generosi e accesso affidabile ai modelli open source Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash e Hy3.",
+    "No. Zen è a consumo, mentre Go inizia a $5 per il primo mese, poi $10/mese, con limiti generosi e accesso affidabile ai modelli open source Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro e DeepSeek V4 Flash.",
  "go.faq.q4": "Quanto costa Go?",
  "go.faq.a4.p1.beforePricing": "Go costa",
  "go.faq.a4.p1.pricingLink": "$5 il primo mese",
@@ -353,7 +353,7 @@ export const dict = {

  "go.faq.q9": "Qual è la differenza tra i modelli gratuiti e Go?",
  "go.faq.a9":
-    "I modelli gratuiti includono Big Pickle più modelli promozionali disponibili al momento, con una quota di 200 richieste/giorno. Go include Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash e Hy3 con quote di richiesta più elevate applicate su finestre mobili (5 ore, settimanale e mensile), approssimativamente equivalenti a $12 ogni 5 ore, $30 a settimana e $60 al mese (il conteggio effettivo delle richieste varia in base al modello e all'utilizzo).",
+    "I modelli gratuiti includono Big Pickle più modelli promozionali disponibili al momento, con una quota di 200 richieste/giorno. Go include Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro e DeepSeek V4 Flash con quote di richiesta più elevate applicate su finestre mobili (5 ore, settimanale e mensile), approssimativamente equivalenti a $12 ogni 5 ore, $30 a settimana e $60 al mese (il conteggio effettivo delle richieste varia in base al modello e all'utilizzo).",

  "zen.api.error.rateLimitExceeded": "Limite di richieste superato. Riprova più tardi.",
  "zen.api.error.modelNotSupported": "Modello {{model}} non supportato",
@@ -255,7 +255,7 @@ export const dict = {
  "go.title": "OpenCode Go | すべての人のための低価格なコーディングモデル",
  "go.banner.text": "Kimi K3の利用上限が期間限定で2倍に",
  "go.meta.description":
-    "Goは最初の月$5、その後$10/月で、Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flash、Hy3に対して5時間のゆとりあるリクエスト上限があります。",
+    "Goは最初の月$5、その後$10/月で、Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flashに対して5時間のゆとりあるリクエスト上限があります。",
  "go.hero.title": "すべての人のための低価格なコーディングモデル",
  "go.hero.body":
    "Goは、世界中のプログラマーにエージェント型コーディングをもたらします。最も高性能なオープンソースモデルへの十分な制限と安定したアクセスを提供し、コストや可用性を気にすることなく強力なエージェントで構築できます。",
@@ -304,7 +304,7 @@ export const dict = {
  "go.problem.item2": "十分な制限と安定したアクセス",
  "go.problem.item3": "できるだけ多くのプログラマーのために構築",
  "go.problem.item4":
-    "Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flash、Hy3を含む",
+    "Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flashを含む",
  "go.how.title": "Goの仕組み",
  "go.how.body": "Goは最初の月$5、その後$10/月で始まります。OpenCodeまたは任意のエージェントで使えます。",
  "go.how.step1.title": "アカウントを作成",
@@ -329,7 +329,7 @@ export const dict = {
  "go.faq.a2": "Go には、十分な利用上限と安定したアクセスを備えた、以下のモデルが含まれます。",
  "go.faq.q3": "GoはZenと同じですか？",
  "go.faq.a3":
-    "いいえ。Zenは従量課金制ですが、Goは最初の月$5、その後$10/月で始まり、Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flash、Hy3のオープンソースモデルに対して、ゆとりある上限と信頼できるアクセスを提供します。",
+    "いいえ。Zenは従量課金制ですが、Goは最初の月$5、その後$10/月で始まり、Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flashのオープンソースモデルに対して、ゆとりある上限と信頼できるアクセスを提供します。",
  "go.faq.q4": "Goの料金は？",
  "go.faq.a4.p1.beforePricing": "Goは",
  "go.faq.a4.p1.pricingLink": "最初の月$5",
@@ -353,7 +353,7 @@ export const dict = {

  "go.faq.q9": "無料モデルとGoの違いは何ですか？",
  "go.faq.a9":
-    "無料モデルにはBig Pickleと、その時点で利用可能なプロモーションモデルが含まれ、1日200リクエストの制限があります。GoにはGrok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flash、Hy3が含まれ、ローリングウィンドウ（5時間、週間、月間）全体でより高いリクエスト制限が適用されます。これは概算で5時間あたり$12、週間$30、月間$60相当です（実際のリクエスト数はモデルと使用状況により異なります）。",
+    "無料モデルにはBig Pickleと、その時点で利用可能なプロモーションモデルが含まれ、1日200リクエストの制限があります。GoにはGrok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flashが含まれ、ローリングウィンドウ（5時間、週間、月間）全体でより高いリクエスト制限が適用されます。これは概算で5時間あたり$12、週間$30、月間$60相当です（実際のリクエスト数はモデルと使用状況により異なります）。",

  "zen.api.error.rateLimitExceeded": "レート制限を超えました。後でもう一度お試しください。",
  "zen.api.error.modelNotSupported": "モデル {{model}} はサポートされていません",
@@ -252,7 +252,7 @@ export const dict = {
  "go.title": "OpenCode Go | 모두를 위한 저비용 코딩 모델",
  "go.banner.text": "Kimi K3 사용 한도가 한시적으로 2배 확대됩니다",
  "go.meta.description":
-    "Go는 첫 달 $5, 이후 $10/월로 시작하며, Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash, Hy3에 대해 넉넉한 5시간 요청 한도를 제공합니다.",
+    "Go는 첫 달 $5, 이후 $10/월로 시작하며, Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash에 대해 넉넉한 5시간 요청 한도를 제공합니다.",
  "go.hero.title": "모두를 위한 저비용 코딩 모델",
  "go.hero.body":
    "Go는 전 세계 프로그래머들에게 에이전트 코딩을 제공합니다. 가장 유능한 오픈 소스 모델에 대한 넉넉한 한도와 안정적인 액세스를 제공하므로, 비용이나 가용성 걱정 없이 강력한 에이전트로 빌드할 수 있습니다.",
@@ -301,7 +301,7 @@ export const dict = {
  "go.problem.item2": "넉넉한 한도와 안정적인 액세스",
  "go.problem.item3": "가능한 한 많은 프로그래머를 위해 제작됨",
  "go.problem.item4":
-    "Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash, Hy3 포함",
+    "Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash 포함",
  "go.how.title": "Go 작동 방식",
  "go.how.body": "Go는 첫 달 $5, 이후 $10/월로 시작합니다. OpenCode 또는 어떤 에이전트와도 함께 사용할 수 있습니다.",
  "go.how.step1.title": "계정 생성",
@@ -325,7 +325,7 @@ export const dict = {
  "go.faq.a2": "Go에는 넉넉한 한도와 안정적인 액세스를 제공하는 아래 모델이 포함됩니다.",
  "go.faq.q3": "Go는 Zen과 같은가요?",
  "go.faq.a3":
-    "아니요. Zen은 종량제인 반면, Go는 첫 달 $5, 이후 $10/월로 시작하며, Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash, Hy3 오픈 소스 모델에 대한 넉넉한 한도와 안정적인 액세스를 제공합니다.",
+    "아니요. Zen은 종량제인 반면, Go는 첫 달 $5, 이후 $10/월로 시작하며, Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash 오픈 소스 모델에 대한 넉넉한 한도와 안정적인 액세스를 제공합니다.",
  "go.faq.q4": "Go 비용은 얼마인가요?",
  "go.faq.a4.p1.beforePricing": "Go 비용은",
  "go.faq.a4.p1.pricingLink": "첫 달 $5",
@@ -348,7 +348,7 @@ export const dict = {

  "go.faq.q9": "무료 모델과 Go의 차이점은 무엇인가요?",
  "go.faq.a9":
-    "무료 모델에는 Big Pickle과 당시 사용 가능한 프로모션 모델이 포함되며, 하루 200회 요청 할당량이 적용됩니다. Go는 Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash, Hy3를 포함하며, 롤링 윈도우(5시간, 주간, 월간)에 걸쳐 더 높은 요청 할당량을 적용합니다. 이는 대략 5시간당 $12, 주당 $30, 월 $60에 해당합니다(실제 요청 수는 모델 및 사용량에 따라 다름).",
+    "무료 모델에는 Big Pickle과 당시 사용 가능한 프로모션 모델이 포함되며, 하루 200회 요청 할당량이 적용됩니다. Go는 Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash를 포함하며, 롤링 윈도우(5시간, 주간, 월간)에 걸쳐 더 높은 요청 할당량을 적용합니다. 이는 대략 5시간당 $12, 주당 $30, 월 $60에 해당합니다(실제 요청 수는 모델 및 사용량에 따라 다름).",

  "zen.api.error.rateLimitExceeded": "속도 제한을 초과했습니다. 나중에 다시 시도해 주세요.",
  "zen.api.error.modelNotSupported": "{{model}} 모델은 지원되지 않습니다",
@@ -256,7 +256,7 @@ export const dict = {
  "go.title": "OpenCode Go | Rimelige kodemodeller for alle",
  "go.banner.text": "Kimi K3 får 2x bruksgrense i en begrenset periode",
  "go.meta.description":
-    "Go starter på $5 for den første måneden, deretter $10/måned, med sjenerøse 5-timers forespørselsgrenser for Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash og Hy3.",
+    "Go starter på $5 for den første måneden, deretter $10/måned, med sjenerøse 5-timers forespørselsgrenser for Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro og DeepSeek V4 Flash.",
  "go.hero.title": "Rimelige kodemodeller for alle",
  "go.hero.body":
    "Go bringer agent-koding til programmerere over hele verden. Med rause grenser og pålitelig tilgang til de mest kapable åpen kildekode-modellene, kan du bygge med kraftige agenter uten å bekymre deg for kostnader eller tilgjengelighet.",
@@ -304,7 +304,7 @@ export const dict = {
  "go.problem.item2": "Rause grenser og pålitelig tilgang",
  "go.problem.item3": "Bygget for så mange programmerere som mulig",
  "go.problem.item4":
-    "Inkluderer Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash og Hy3",
+    "Inkluderer Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro og DeepSeek V4 Flash",
  "go.how.title": "Hvordan Go fungerer",
  "go.how.body":
    "Go starter på $5 for den første måneden, deretter $10/måned. Du kan bruke det med OpenCode eller hvilken som helst agent.",
@@ -330,7 +330,7 @@ export const dict = {
  "go.faq.a2": "Go inkluderer modellene nedenfor, med høye grenser og pålitelig tilgang.",
  "go.faq.q3": "Er Go det samme som Zen?",
  "go.faq.a3":
-    "Nei. Zen er betaling etter bruk, mens Go starter på $5 for den første måneden, deretter $10/måned, med sjenerøse grenser og pålitelig tilgang til åpen kildekode-modellene Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash og Hy3.",
+    "Nei. Zen er betaling etter bruk, mens Go starter på $5 for den første måneden, deretter $10/måned, med sjenerøse grenser og pålitelig tilgang til åpen kildekode-modellene Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro og DeepSeek V4 Flash.",
  "go.faq.q4": "Hva koster Go?",
  "go.faq.a4.p1.beforePricing": "Go koster",
  "go.faq.a4.p1.pricingLink": "$5 første måned",
@@ -354,7 +354,7 @@ export const dict = {

  "go.faq.q9": "Hva er forskjellen mellom gratis modeller og Go?",
  "go.faq.a9":
-    "Gratis modeller inkluderer Big Pickle pluss kampanjemodeller tilgjengelig på det tidspunktet, med en kvote på 200 forespørsler/dag. Go inkluderer Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash og Hy3 med høyere kvoter håndhevet over rullerende vinduer (5 timer, ukentlig og månedlig), omtrent tilsvarende $12 per 5 timer, $30 per uke og $60 per måned (faktiske forespørselsantall varierer etter modell og bruk).",
+    "Gratis modeller inkluderer Big Pickle pluss kampanjemodeller tilgjengelig på det tidspunktet, med en kvote på 200 forespørsler/dag. Go inkluderer Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro og DeepSeek V4 Flash med høyere kvoter håndhevet over rullerende vinduer (5 timer, ukentlig og månedlig), omtrent tilsvarende $12 per 5 timer, $30 per uke og $60 per måned (faktiske forespørselsantall varierer etter modell og bruk).",

  "zen.api.error.rateLimitExceeded": "Rate limit overskredet. Vennligst prøv igjen senere.",
  "zen.api.error.modelNotSupported": "Modell {{model}} støttes ikke",
@@ -257,7 +257,7 @@ export const dict = {
  "go.title": "OpenCode Go | Niskokosztowe modele do kodowania dla każdego",
  "go.banner.text": "Kimi K3 oferuje 2x wyższe limity użycia przez ograniczony czas",
  "go.meta.description":
-    "Go zaczyna się od $5 za pierwszy miesiąc, potem $10/miesiąc, z hojnymi 5-godzinnymi limitami zapytań dla Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash i Hy3.",
+    "Go zaczyna się od $5 za pierwszy miesiąc, potem $10/miesiąc, z hojnymi 5-godzinnymi limitami zapytań dla Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro i DeepSeek V4 Flash.",
  "go.hero.title": "Niskokosztowe modele do kodowania dla każdego",
  "go.hero.body":
    "Go udostępnia programowanie z agentami programistom na całym świecie. Oferuje hojne limity i niezawodny dostęp do najzdolniejszych modeli open source, dzięki czemu możesz budować za pomocą potężnych agentów, nie martwiąc się o koszty czy dostępność.",
@@ -305,7 +305,7 @@ export const dict = {
  "go.problem.item2": "Hojne limity i niezawodny dostęp",
  "go.problem.item3": "Stworzony dla jak największej liczby programistów",
  "go.problem.item4":
-    "Zawiera Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash i Hy3",
+    "Zawiera Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro i DeepSeek V4 Flash",
  "go.how.title": "Jak działa Go",
  "go.how.body":
    "Go zaczyna się od $5 za pierwszy miesiąc, potem $10/miesiąc. Możesz go używać z OpenCode lub dowolnym agentem.",
@@ -331,7 +331,7 @@ export const dict = {
  "go.faq.a2": "Go obejmuje poniższe modele z wysokimi limitami i niezawodnym dostępem.",
  "go.faq.q3": "Czy Go to to samo co Zen?",
  "go.faq.a3":
-    "Nie. Zen to model płatności za użycie, podczas gdy Go zaczyna się od $5 za pierwszy miesiąc, potem $10/miesiąc, z hojnymi limitami i niezawodnym dostępem do modeli open source Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash i Hy3.",
+    "Nie. Zen to model płatności za użycie, podczas gdy Go zaczyna się od $5 za pierwszy miesiąc, potem $10/miesiąc, z hojnymi limitami i niezawodnym dostępem do modeli open source Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro i DeepSeek V4 Flash.",
  "go.faq.q4": "Ile kosztuje Go?",
  "go.faq.a4.p1.beforePricing": "Go kosztuje",
  "go.faq.a4.p1.pricingLink": "$5 za pierwszy miesiąc",
@@ -355,7 +355,7 @@ export const dict = {

  "go.faq.q9": "Jaka jest różnica między darmowymi modelami a Go?",
  "go.faq.a9":
-    "Darmowe modele obejmują Big Pickle oraz modele promocyjne dostępne w danym momencie, z limitem 200 zapytań/dzień. Go zawiera Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash i Hy3 z wyższymi limitami zapytań egzekwowanymi w oknach kroczących (5-godzinnych, tygodniowych i miesięcznych), w przybliżeniu równoważnymi $12 na 5 godzin, $30 tygodniowo i $60 miesięcznie (rzeczywista liczba zapytań zależy od modelu i użycia).",
+    "Darmowe modele obejmują Big Pickle oraz modele promocyjne dostępne w danym momencie, z limitem 200 zapytań/dzień. Go zawiera Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro i DeepSeek V4 Flash z wyższymi limitami zapytań egzekwowanymi w oknach kroczących (5-godzinnych, tygodniowych i miesięcznych), w przybliżeniu równoważnymi $12 na 5 godzin, $30 tygodniowo i $60 miesięcznie (rzeczywista liczba zapytań zależy od modelu i użycia).",

  "zen.api.error.rateLimitExceeded": "Przekroczono limit zapytań. Spróbuj ponownie później.",
  "zen.api.error.modelNotSupported": "Model {{model}} nie jest obsługiwany",
@@ -260,7 +260,7 @@ export const dict = {
  "go.title": "OpenCode Go | Недорогие модели для кодинга для всех",
  "go.banner.text": "Kimi K3 получает 2x лимиты использования на ограниченное время",
  "go.meta.description":
-    "Go начинается с $5 за первый месяц, затем $10/месяц, с щедрыми лимитами запросов за 5 часов для Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash и Hy3.",
+    "Go начинается с $5 за первый месяц, затем $10/месяц, с щедрыми лимитами запросов за 5 часов для Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro и DeepSeek V4 Flash.",
  "go.hero.title": "Недорогие модели для кодинга для всех",
  "go.hero.body":
    "Go открывает доступ к агентам-программистам разработчикам по всему миру. Предлагая щедрые лимиты и надежный доступ к наиболее способным моделям с открытым исходным кодом, вы можете создавать проекты с мощными агентами, не беспокоясь о затратах или доступности.",
@@ -309,7 +309,7 @@ export const dict = {
  "go.problem.item2": "Щедрые лимиты и надежный доступ",
  "go.problem.item3": "Создан для максимального числа программистов",
  "go.problem.item4":
-    "Включает Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash и Hy3",
+    "Включает Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro и DeepSeek V4 Flash",
  "go.how.title": "Как работает Go",
  "go.how.body":
    "Go начинается с $5 за первый месяц, затем $10/месяц. Вы можете использовать его с OpenCode или любым агентом.",
@@ -335,7 +335,7 @@ export const dict = {
  "go.faq.a2": "Go включает перечисленные ниже модели с щедрыми лимитами и надежным доступом.",
  "go.faq.q3": "Go — это то же самое, что и Zen?",
  "go.faq.a3":
-    "Нет. Zen - это оплата по мере использования, в то время как Go начинается с $5 за первый месяц, затем $10/месяц, с щедрыми лимитами и надежным доступом к моделям с открытым исходным кодом Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash и Hy3.",
+    "Нет. Zen - это оплата по мере использования, в то время как Go начинается с $5 за первый месяц, затем $10/месяц, с щедрыми лимитами и надежным доступом к моделям с открытым исходным кодом Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro и DeepSeek V4 Flash.",
  "go.faq.q4": "Сколько стоит Go?",
  "go.faq.a4.p1.beforePricing": "Go стоит",
  "go.faq.a4.p1.pricingLink": "$5 за первый месяц",
@@ -359,7 +359,7 @@ export const dict = {

  "go.faq.q9": "В чем разница между бесплатными моделями и Go?",
  "go.faq.a9":
-    "Бесплатные модели включают Big Pickle плюс промо-модели, доступные на данный момент, с квотой 200 запросов/день. Go включает Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash и Hy3 с более высокими квотами запросов, применяемыми в скользящих окнах (5 часов, неделя и месяц), что примерно эквивалентно $12 за 5 часов, $30 в неделю и $60 в месяц (фактическое количество запросов зависит от модели и использования).",
+    "Бесплатные модели включают Big Pickle плюс промо-модели, доступные на данный момент, с квотой 200 запросов/день. Go включает Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro и DeepSeek V4 Flash с более высокими квотами запросов, применяемыми в скользящих окнах (5 часов, неделя и месяц), что примерно эквивалентно $12 за 5 часов, $30 в неделю и $60 в месяц (фактическое количество запросов зависит от модели и использования).",

  "zen.api.error.rateLimitExceeded": "Превышен лимит запросов. Пожалуйста, попробуйте позже.",
  "zen.api.error.modelNotSupported": "Модель {{model}} не поддерживается",
@@ -255,7 +255,7 @@ export const dict = {
  "go.title": "OpenCode Go | โมเดลเขียนโค้ดราคาประหยัดสำหรับทุกคน",
  "go.banner.text": "Kimi K3 เพิ่มโควตาการใช้งานเป็น 2 เท่าในช่วงเวลาจำกัด",
  "go.meta.description":
-    "Go เริ่มต้นที่ $5 สำหรับเดือนแรก จากนั้น $10/เดือน พร้อมขีดจำกัดคำขอ 5 ชั่วโมงที่เอื้อเฟื้อสำหรับ Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash และ Hy3",
+    "Go เริ่มต้นที่ $5 สำหรับเดือนแรก จากนั้น $10/เดือน พร้อมขีดจำกัดคำขอ 5 ชั่วโมงที่เอื้อเฟื้อสำหรับ Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro และ DeepSeek V4 Flash",
  "go.hero.title": "โมเดลเขียนโค้ดราคาประหยัดสำหรับทุกคน",
  "go.hero.body":
    "Go นำการเขียนโค้ดแบบเอเจนต์มาสู่นักเขียนโปรแกรมทั่วโลก เสนอขีดจำกัดที่กว้างขวางและการเข้าถึงโมเดลโอเพนซอร์สที่มีความสามารถสูงสุดได้อย่างน่าเชื่อถือ เพื่อให้คุณสามารถสร้างสรรค์ด้วยเอเจนต์ที่ทรงพลังโดยไม่ต้องกังวลเรื่องค่าใช้จ่ายหรือความพร้อมใช้งาน",
@@ -302,7 +302,7 @@ export const dict = {
  "go.problem.item2": "ขีดจำกัดที่กว้างขวางและการเข้าถึงที่เชื่อถือได้",
  "go.problem.item3": "สร้างขึ้นเพื่อโปรแกรมเมอร์จำนวนมากที่สุดเท่าที่จะเป็นไปได้",
  "go.problem.item4":
-    "รวมถึง Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash และ Hy3",
+    "รวมถึง Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro และ DeepSeek V4 Flash",
  "go.how.title": "Go ทำงานอย่างไร",
  "go.how.body": "Go เริ่มต้นที่ $5 สำหรับเดือนแรก จากนั้น $10/เดือน คุณสามารถใช้กับ OpenCode หรือเอเจนต์ใดก็ได้",
  "go.how.step1.title": "สร้างบัญชี",
@@ -327,7 +327,7 @@ export const dict = {
  "go.faq.a2": "Go รวมโมเดลด้านล่างนี้ พร้อมขีดจำกัดที่มากและการเข้าถึงที่เชื่อถือได้",
  "go.faq.q3": "Go เหมือนกับ Zen หรือไม่?",
  "go.faq.a3":
-    "ไม่ Zen เป็นแบบจ่ายตามการใช้งาน ในขณะที่ Go เริ่มต้นที่ $5 สำหรับเดือนแรก จากนั้น $10/เดือน พร้อมขีดจำกัดที่เอื้อเฟื้อและการเข้าถึงโมเดลโอเพนซอร์ส Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash และ Hy3 อย่างเชื่อถือได้",
+    "ไม่ Zen เป็นแบบจ่ายตามการใช้งาน ในขณะที่ Go เริ่มต้นที่ $5 สำหรับเดือนแรก จากนั้น $10/เดือน พร้อมขีดจำกัดที่เอื้อเฟื้อและการเข้าถึงโมเดลโอเพนซอร์ส Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro และ DeepSeek V4 Flash อย่างเชื่อถือได้",
  "go.faq.q4": "Go ราคาเท่าไหร่?",
  "go.faq.a4.p1.beforePricing": "Go ราคา",
  "go.faq.a4.p1.pricingLink": "$5 เดือนแรก",
@@ -350,7 +350,7 @@ export const dict = {

  "go.faq.q9": "ความแตกต่างระหว่างโมเดลฟรีและ Go คืออะไร?",
  "go.faq.a9":
-    "โมเดลฟรีรวมถึง Big Pickle บวกกับโมเดลโปรโมชั่นที่มีให้ในขณะนั้น ด้วยโควต้า 200 คำขอ/วัน Go รวมถึง Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash และ Hy3 ที่มีโควต้าคำขอสูงกว่า ซึ่งบังคับใช้ผ่านช่วงเวลาหมุนเวียน (5 ชั่วโมง, รายสัปดาห์ และรายเดือน) เทียบเท่าประมาณ $12 ต่อ 5 ชั่วโมง, $30 ต่อสัปดาห์ และ $60 ต่อเดือน (จำนวนคำขอจริงจะแตกต่างกันไปตามโมเดลและการใช้งาน)",
+    "โมเดลฟรีรวมถึง Big Pickle บวกกับโมเดลโปรโมชั่นที่มีให้ในขณะนั้น ด้วยโควต้า 200 คำขอ/วัน Go รวมถึง Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro และ DeepSeek V4 Flash ที่มีโควต้าคำขอสูงกว่า ซึ่งบังคับใช้ผ่านช่วงเวลาหมุนเวียน (5 ชั่วโมง, รายสัปดาห์ และรายเดือน) เทียบเท่าประมาณ $12 ต่อ 5 ชั่วโมง, $30 ต่อสัปดาห์ และ $60 ต่อเดือน (จำนวนคำขอจริงจะแตกต่างกันไปตามโมเดลและการใช้งาน)",

  "zen.api.error.rateLimitExceeded": "เกินขีดจำกัดอัตราการใช้งาน กรุณาลองใหม่ในภายหลัง",
  "zen.api.error.modelNotSupported": "ไม่รองรับโมเดล {{model}}",
@@ -258,7 +258,7 @@ export const dict = {
  "go.title": "OpenCode Go | Herkes için düşük maliyetli kodlama modelleri",
  "go.banner.text": "Kimi K3 sınırlı bir süre için 2x kullanım limiti sunuyor",
  "go.meta.description":
-    "Go ilk ay $5, sonrasında ayda 10$ fiyatıyla başlar; Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash ve Hy3 için cömert 5 saatlik istek limitleri sunar.",
+    "Go ilk ay $5, sonrasında ayda 10$ fiyatıyla başlar; Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro ve DeepSeek V4 Flash için cömert 5 saatlik istek limitleri sunar.",
  "go.hero.title": "Herkes için düşük maliyetli kodlama modelleri",
  "go.hero.body":
    "Go, dünya çapındaki programcılara ajan tabanlı kodlama getiriyor. En yetenekli açık kaynaklı modellere cömert limitler ve güvenilir erişim sunarak, maliyet veya erişilebilirlik konusunda endişelenmeden güçlü ajanlarla geliştirme yapmanızı sağlar.",
@@ -307,7 +307,7 @@ export const dict = {
  "go.problem.item2": "Cömert limitler ve güvenilir erişim",
  "go.problem.item3": "Mümkün olduğunca çok programcı için geliştirildi",
  "go.problem.item4":
-    "Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash ve Hy3 içerir",
+    "Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro ve DeepSeek V4 Flash içerir",
  "go.how.title": "Go nasıl çalışır?",
  "go.how.body":
    "Go ilk ay $5, sonrasında ayda 10$ fiyatıyla başlar. OpenCode veya herhangi bir ajanla kullanabilirsiniz.",
@@ -333,7 +333,7 @@ export const dict = {
  "go.faq.a2": "Go, aşağıda listelenen modelleri cömert limitler ve güvenilir erişimle sunar.",
  "go.faq.q3": "Go, Zen ile aynı mı?",
  "go.faq.a3":
-    "Hayır. Zen kullandıkça öde modelidir, Go ise ilk ay $5, sonrasında ayda 10$ fiyatıyla başlar; Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash ve Hy3 açık kaynak modellerine cömert limitler ve güvenilir erişim sunar.",
+    "Hayır. Zen kullandıkça öde modelidir, Go ise ilk ay $5, sonrasında ayda 10$ fiyatıyla başlar; Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro ve DeepSeek V4 Flash açık kaynak modellerine cömert limitler ve güvenilir erişim sunar.",
  "go.faq.q4": "Go ne kadar?",
  "go.faq.a4.p1.beforePricing": "Go'nun maliyeti",
  "go.faq.a4.p1.pricingLink": "İlk ay $5",
@@ -357,7 +357,7 @@ export const dict = {

  "go.faq.q9": "Ücretsiz modeller ve Go arasındaki fark nedir?",
  "go.faq.a9":
-    "Ücretsiz modeller, günlük 200 istek kotası ile Big Pickle ve o sırada mevcut olan promosyonel modelleri içerir. Go ise Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash ve Hy3 modellerini; yuvarlanan pencereler (5 saatlik, haftalık ve aylık) üzerinden uygulanan daha yüksek istek kotalarıyla içerir. Bu kotalar kabaca her 5 saatte 12$, haftada 30$ ve ayda 60$ değerine eşdeğerdir (gerçek istek sayıları modele ve kullanıma göre değişir).",
+    "Ücretsiz modeller, günlük 200 istek kotası ile Big Pickle ve o sırada mevcut olan promosyonel modelleri içerir. Go ise Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro ve DeepSeek V4 Flash modellerini; yuvarlanan pencereler (5 saatlik, haftalık ve aylık) üzerinden uygulanan daha yüksek istek kotalarıyla içerir. Bu kotalar kabaca her 5 saatte 12$, haftada 30$ ve ayda 60$ değerine eşdeğerdir (gerçek istek sayıları modele ve kullanıma göre değişir).",

  "zen.api.error.rateLimitExceeded": "İstek limiti aşıldı. Lütfen daha sonra tekrar deneyin.",
  "zen.api.error.modelNotSupported": "{{model}} modeli desteklenmiyor",
@@ -257,7 +257,7 @@ export const dict = {
  "go.title": "OpenCode Go | Недорогі моделі кодування для всіх",
  "go.banner.text": "Kimi K3 отримує 2x ліміти використання протягом обмеженого часу",
  "go.meta.description":
-    "Go починається від $5 за перший місяць, потім $10/місяць, зі щедрими 5-годинними лімітами запитів для Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash та Hy3.",
+    "Go починається від $5 за перший місяць, потім $10/місяць, зі щедрими 5-годинними лімітами запитів для Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro та DeepSeek V4 Flash.",
  "go.hero.title": "Недорогі моделі кодування для всіх",
  "go.hero.body":
    "Go надає агентне програмування програмістам у всьому світі, пропонуючи щедрі ліміти та надійний доступ до найкращих моделей з відкритим кодом.",
@@ -305,7 +305,7 @@ export const dict = {
  "go.problem.item2": "Щедрі ліміти та надійний доступ",
  "go.problem.item3": "Створено для якомога більшої кількості програмістів",
  "go.problem.item4":
-    "Включає Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash та Hy3",
+    "Включає Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro та DeepSeek V4 Flash",
  "go.how.title": "Як працює Go",
  "go.how.body":
    "Go починається від $5 за перший місяць, потім $10/місяць. Використовуйте з OpenCode або будь-яким агентом.",
@@ -331,7 +331,7 @@ export const dict = {
  "go.faq.a2": "Go включає моделі, перелічені нижче, із щедрими лімітами та надійним доступом.",
  "go.faq.q3": "Чи Go те саме, що Zen?",
  "go.faq.a3":
-    "Ні. Zen — це плата за використання, тоді як Go починається від $5 за перший місяць, потім $10/місяць, із щедрими лімітами та надійним доступом до моделей з відкритим кодом Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash та Hy3.",
+    "Ні. Zen — це плата за використання, тоді як Go починається від $5 за перший місяць, потім $10/місяць, із щедрими лімітами та надійним доступом до моделей з відкритим кодом Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro та DeepSeek V4 Flash.",
  "go.faq.q4": "Скільки коштує Go?",
  "go.faq.a4.p1.beforePricing": "Go коштує",
  "go.faq.a4.p1.pricingLink": "$5 за перший місяць",
@@ -354,7 +354,7 @@ export const dict = {

  "go.faq.q9": "Яка різниця між безкоштовними моделями та Go?",
  "go.faq.a9":
-    "Безкоштовні моделі включають Big Pickle та акційні моделі з лімітом 200 запитів/день. Go включає Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro, DeepSeek V4 Flash та Hy3 із вищими лімітами.",
+    "Безкоштовні моделі включають Big Pickle та акційні моделі з лімітом 200 запитів/день. Go включає Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code, Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7, MiniMax M3, DeepSeek V4 Pro та DeepSeek V4 Flash із вищими лімітами.",

  "zen.api.error.rateLimitExceeded": "Перевищено ліміт запитів. Спробуйте пізніше.",
  "zen.api.error.modelNotSupported": "Модель {{model}} не підтримується",
@@ -246,7 +246,7 @@ export const dict = {
  "go.title": "OpenCode Go | 人人可用的低成本编程模型",
  "go.banner.text": "Kimi K3 限时享受 2 倍使用额度",
  "go.meta.description":
-    "Go 首月 $5，之后 $10/月，提供对 Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flash 和 Hy3 的 5 小时充裕请求额度。",
+    "Go 首月 $5，之后 $10/月，提供对 Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro 和 DeepSeek V4 Flash 的 5 小时充裕请求额度。",
  "go.hero.title": "人人可用的低成本编程模型",
  "go.hero.body":
    "Go 将代理编程带给全世界的程序员。提供充裕的限额和对最强大的开源模型的可靠访问，让您可以利用强大的代理进行构建，而无需担心成本或可用性。",
@@ -293,7 +293,7 @@ export const dict = {
  "go.problem.item2": "充裕的限额和可靠的访问",
  "go.problem.item3": "为尽可能多的程序员打造",
  "go.problem.item4":
-    "包含 Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code、Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flash 和 Hy3",
+    "包含 Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code、Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro 和 DeepSeek V4 Flash",
  "go.how.title": "Go 如何工作",
  "go.how.body": "Go 起价为首月 $5，之后 $10/月。您可以将其与 OpenCode 或任何代理搭配使用。",
  "go.how.step1.title": "创建账户",
@@ -315,7 +315,7 @@ export const dict = {
  "go.faq.a2": "Go 包含下方列出的模型，提供充足的限额和可靠的访问。",
  "go.faq.q3": "Go 和 Zen 一样吗？",
  "go.faq.a3":
-    "不。Zen 是按量付费，而 Go 首月 $5，之后 $10/月，提供充裕的额度，并可可靠地访问 Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flash 和 Hy3 等开源模型。",
+    "不。Zen 是按量付费，而 Go 首月 $5，之后 $10/月，提供充裕的额度，并可可靠地访问 Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro 和 DeepSeek V4 Flash 等开源模型。",
  "go.faq.q4": "Go 多少钱？",
  "go.faq.a4.p1.beforePricing": "Go 费用为",
  "go.faq.a4.p1.pricingLink": "首月 $5",
@@ -337,7 +337,7 @@ export const dict = {

  "go.faq.q9": "免费模型和 Go 之间的区别是什么？",
  "go.faq.a9":
-    "免费模型包含 Big Pickle 加上当时可用的促销模型，每天有 200 次请求的配额。Go 包含 Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code、Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flash 和 Hy3，并在滚动窗口（5 小时、每周和每月）内执行更高的请求配额，大致相当于每 5 小时 $12、每周 $30 和每月 $60（实际请求计数因模型和使用情况而异）。",
+    "免费模型包含 Big Pickle 加上当时可用的促销模型，每天有 200 次请求的配额。Go 包含 Grok 4.5, GLM-5.2, GLM-5.1, Kimi K3, Kimi K2.7 Code、Kimi K2.6, MiMo-V2.5-Pro, MiMo-V2.5, Qwen3.7 Max, Qwen3.7 Plus, Qwen3.6 Plus, MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro 和 DeepSeek V4 Flash，并在滚动窗口（5 小时、每周和每月）内执行更高的请求配额，大致相当于每 5 小时 $12、每周 $30 和每月 $60（实际请求计数因模型和使用情况而异）。",

  "zen.api.error.rateLimitExceeded": "超出速率限制。请稍后重试。",
  "zen.api.error.modelNotSupported": "不支持模型 {{model}}",
@@ -246,7 +246,7 @@ export const dict = {
  "go.title": "OpenCode Go | 低成本全民編碼模型",
  "go.banner.text": "Kimi K3 限時享有 2 倍使用額度",
  "go.meta.description":
-    "Go 首月 $5，之後 $10/月，提供對 Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flash 和 Hy3 的 5 小時充裕請求額度。",
+    "Go 首月 $5，之後 $10/月，提供對 Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro 和 DeepSeek V4 Flash 的 5 小時充裕請求額度。",
  "go.hero.title": "低成本全民編碼模型",
  "go.hero.body":
    "Go 將代理編碼帶給全世界的程式設計師。提供寬裕的限額以及對最強大開源模型的穩定存取，讓你可以使用強大的代理進行構建，而無需擔心成本或可用性。",
@@ -293,7 +293,7 @@ export const dict = {
  "go.problem.item2": "寬裕的限額與穩定存取",
  "go.problem.item3": "專為盡可能多的程式設計師打造",
  "go.problem.item4":
-    "包含 Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flash 與 Hy3",
+    "包含 Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro 與 DeepSeek V4 Flash",
  "go.how.title": "Go 如何運作",
  "go.how.body": "Go 起價為首月 $5，之後 $10/月。您可以將其與 OpenCode 或任何代理搭配使用。",
  "go.how.step1.title": "建立帳號",
@@ -315,7 +315,7 @@ export const dict = {
  "go.faq.a2": "Go 包含下方列出的模型，提供充足的額度與穩定的存取。",
  "go.faq.q3": "Go 與 Zen 一樣嗎？",
  "go.faq.a3":
-    "不。Zen 是按量付費，而 Go 首月 $5，之後 $10/月，提供充裕的額度，並可可靠地存取 Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flash 和 Hy3 等開源模型。",
+    "不。Zen 是按量付費，而 Go 首月 $5，之後 $10/月，提供充裕的額度，並可可靠地存取 Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro 和 DeepSeek V4 Flash 等開源模型。",
  "go.faq.q4": "Go 費用是多少？",
  "go.faq.a4.p1.beforePricing": "Go 費用為",
  "go.faq.a4.p1.pricingLink": "首月 $5",
@@ -337,7 +337,7 @@ export const dict = {

  "go.faq.q9": "免費模型與 Go 有什麼區別？",
  "go.faq.a9":
-    "免費模型包括 Big Pickle 以及當時可用的促銷模型，配額為 200 次請求/天。Go 包括 Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro、DeepSeek V4 Flash 與 Hy3，並在滾動視窗（5 小時、每週和每月）內執行更高的請求配額，大約相當於每 5 小時 $12、每週 $30 和每月 $60（實際請求數因模型和使用情況而異）。",
+    "免費模型包括 Big Pickle 以及當時可用的促銷模型，配額為 200 次請求/天。Go 包括 Grok 4.5、GLM-5.2、GLM-5.1、Kimi K3、Kimi K2.7 Code、Kimi K2.6、MiMo-V2.5-Pro、MiMo-V2.5、Qwen3.7 Max、Qwen3.7 Plus、Qwen3.6 Plus、MiniMax M2.7、MiniMax M3、DeepSeek V4 Pro 與 DeepSeek V4 Flash，並在滾動視窗（5 小時、每週和每月）內執行更高的請求配額，大約相當於每 5 小時 $12、每週 $30 和每月 $60（實際請求數因模型和使用情況而異）。",

  "zen.api.error.rateLimitExceeded": "超出頻率限制。請稍後再試。",
  "zen.api.error.modelNotSupported": "不支援模型 {{model}}",
@@ -38,7 +38,6 @@ const models = [
  "MiniMax M2.7",
  "DeepSeek V4 Pro",
  "DeepSeek V4 Flash",
-  "Hy3",
 ]

 function LimitsGraph(props: { href: string }) {
@@ -73,7 +72,6 @@ function LimitsGraph(props: { href: string }) {
    { id: "mimo-v2.5-pro", name: "MiMo-V2.5-Pro", req: 3250, d: "240ms" },
    { id: "deepseek-v4-pro", name: "DeepSeek V4 Pro", req: 3450, d: "270ms" },
    { id: "qwen3.7-plus", name: "Qwen3.7 Plus", req: 4300, d: "300ms" },
-    { id: "hy3", name: "Hy3", req: 4300, d: "320ms" },
    { id: "mimo-v2.5", name: "MiMo-V2.5", req: 30100, d: "340ms" },
    { id: "deepseek-v4-flash", name: "DeepSeek V4 Flash", req: 31650, d: "340ms" },
  ]
@@ -321,7 +321,6 @@ export function LiteSection(props: { lite: LiteSubscription | undefined }) {
            <li>DeepSeek V4 Flash</li>
            <li>MiMo-V2.5</li>
            <li>MiMo-V2.5-Pro</li>
-            <li>Hy3</li>
          </ul>
          <p data-slot="promo-description">{i18n.t("workspace.lite.promo.footer")}</p>
          <div data-slot="subscribe-actions">
@@ -344,12 +344,7 @@ function modelFromLanguage(info: ModelV2.Info, language: LanguageModelV3) {
    prepareTransport: (body) => Effect.succeed(body),
    streamPrepared: (prepared) => streamLanguage(language, prepared as LanguageModelV3CallOptions),
  }
-  return Model.make({
-    id: info.modelID ?? info.id,
-    provider: info.providerID,
-    route,
-    compatibility: info.compatibility,
-  })
+  return Model.make({ id: info.modelID ?? info.id, provider: info.providerID, route })
 }

 function gatewayProviderOptions(modelID: ModelV2.ID, settings: Readonly<Record<string, unknown>>) {
--- a/Show More
+++ b/Show More