fix: clamp the output-token reservation against the context window

packages/opencode/src/provider/provider.ts

@@ -58,6 +58,9 @@ import { createGitLab, VERSION as GITLAB_PROVIDER_VERSION } from "gitlab-ai-prov
 import { fromNodeProviderChain } from "@aws-sdk/credential-providers"
 import { GoogleAuth } from "google-auth-library"
 import { ProviderTransform } from "./transform"
+// altimate_change start — make provider/model headers obey HTTP's case-insensitive precedence
+import { mergeRequestHeaders } from "./output-token-budget"
+// altimate_change end
 // altimate_change start — provider fetch timeout errors use typed ProviderError classes
 import { ProviderError } from "./error"
 // altimate_change end
@@ -1817,11 +1820,11 @@ export namespace Provider {
 
       if (baseURL !== undefined) options["baseURL"] = baseURL
       if (options["apiKey"] === undefined && provider.key) options["apiKey"] = provider.key
-      if (model.headers)
-        options["headers"] = {
-          ...options["headers"],
-          ...model.headers,
-        }
+      // altimate_change start — canonical names ensure later per-request headers replace provider defaults
+      if (options["headers"] !== undefined || model.headers) {
+        options["headers"] = mergeRequestHeaders(options["headers"], model.headers)
+      }
+      // altimate_change end
 
       const key = Hash.fast(JSON.stringify({ providerID: model.providerID, npm: model.api.npm, options }))
       const existing = s.sdk.get(key)

packages/opencode/src/provider/transform.ts

@@ -334,21 +334,26 @@ export namespace ProviderTransform {
 
         // Check for empty base64 image data
         if (part.type === "image") {
-          const imageStr = part.image.toString()
-          if (imageStr.startsWith("data:")) {
-            const match = imageStr.match(/^data:([^;]+);base64,(.*)$/)
+          // altimate_change start — support every valid image payload form and case
+          const imageStr =
+            typeof part.image === "string" ? part.image : part.image instanceof URL ? part.image.href : undefined
+          if (imageStr && /^data:/i.test(imageStr)) {
+            const match = imageStr.match(/^data:([^;]+);base64,(.*)$/i)
             if (match && (!match[2] || match[2].length === 0)) {
               return {
                 type: "text" as const,
                 text: "ERROR: Image file is empty or corrupted. Please provide a valid image.",
               }
             }
           }
+          // altimate_change end
         }
 
-        const mime = part.type === "image" ? part.image.toString().split(";")[0].replace("data:", "") : part.mediaType
+        // altimate_change start — classify semantic images independently of their payload representation
         const filename = part.type === "file" ? part.filename : undefined
-        const modality = mimeToModality(mime)
+        const modality =
+          part.type === "image" ? "image" : mimeToModality(part.mediaType.split(";", 1)[0]!.trim().toLowerCase())
+        // altimate_change end
         if (!modality) return part
         if (model.capabilities.input[modality]) return part
 
@@ -363,6 +368,30 @@ export namespace ProviderTransform {
     })
   }
 
+  // altimate_change start — expose the pure request projection used before input-budget estimation
+  export function messagesForInputEstimate(msgs: ModelMessage[], model: Provider.Model): ModelMessage[] {
+    const projected = unsupportedParts(msgs, model)
+    const mistral =
+      model.providerID === "mistral" ||
+      model.api.id.toLowerCase().includes("mistral") ||
+      model.api.id.toLowerCase().includes("devstral")
+    if (!mistral) return projected
+
+    // normalizeMessages inserts this bridge before transport because Mistral rejects a tool
+    // message followed directly by a user message. Estimate the same synthetic messages without
+    // mutating the history that the real transform will process later.
+    const result: ModelMessage[] = []
+    for (let index = 0; index < projected.length; index++) {
+      const message = projected[index]
+      result.push(message)
+      if (message.role === "tool" && projected[index + 1]?.role === "user") {
+        result.push({ role: "assistant", content: [{ type: "text", text: "Done." }] })
+      }
+    }
+    return result
+  }
+  // altimate_change end
+
   // altimate_change start — shared providerOptions transform used before request signing
   function mapProviderOptions(
     msgs: ModelMessage[],

packages/opencode/src/session/llm.ts

@@ -13,6 +13,15 @@ import {
 } from "ai"
 import { mergeDeep, pipe } from "remeda"
 import { ProviderTransform } from "@/provider/transform"
+// altimate_change start — size and clamp the finalized provider request
+import {
+  clampOutputTokens,
+  clampReasoningBudget,
+  effectiveContextWindow,
+  estimateInputTokens,
+  mergeRequestHeaders,
+} from "@/provider/output-token-budget"
+// altimate_change end
 // altimate_change start — tool retrieval
 import { Retrieval } from "@/tool/retrieval"
 // altimate_change end
@@ -73,7 +82,9 @@ export namespace LLM {
     ])
     const isCodex = provider.id === "openai" && auth?.type === "oauth"
 
-    const system = []
+    // altimate_change start — keep the request-budget input typed before the first push
+    const system: string[] = []
+    // altimate_change end
     system.push(
       [
         // use agent prompt otherwise provider prompt
@@ -164,6 +175,25 @@ export namespace LLM {
       },
     )
 
+    // altimate_change start — canonicalize the exact outgoing header precedence before budgeting
+    const requestHeaders = mergeRequestHeaders(
+      input.model.providerID.startsWith("opencode")
+        ? {
+            "x-opencode-project": Instance.project.id,
+            "x-opencode-session": input.sessionID,
+            "x-opencode-request": input.user.id,
+            "x-opencode-client": Flag.OPENCODE_CLIENT,
+          }
+        : input.model.providerID !== "anthropic"
+          ? {
+              "User-Agent": `altimate-code/${Installation.VERSION}`,
+            }
+          : undefined,
+      input.model.headers,
+      headers,
+    )
+    // altimate_change end
+
     const tools = await resolveTools(input)
 
     // altimate_change start — ensure tool definitions exist for all tool_use blocks in history
@@ -199,6 +229,30 @@ export namespace LLM {
     }
     // altimate_change end
 
+    // altimate_change start — clamp after every context-affecting request field is finalized.
+    // Tool schemas and provider instructions consume the shared context window, while encoded
+    // media bytes do not count as literal text. The estimator runs lazily so providers that omit
+    // maxOutputTokens pay no serialization cost. Known context beta headers widen the catalog
+    // limit before the clamp. Fixed reasoning budgets are reconciled with the final reservation.
+    const maxOutputTokens = clampOutputTokens({
+      model: input.model,
+      requested: params.maxOutputTokens,
+      context: effectiveContextWindow({
+        model: input.model,
+        // Provider defaults are lower precedence than the exact case-normalized outgoing record.
+        headerSources: [provider.options, requestHeaders],
+      }),
+      inputTokens: () =>
+        estimateInputTokens({
+          system,
+          messages: ProviderTransform.messagesForInputEstimate(input.messages, input.model),
+          tools,
+          instructions: params.options.instructions,
+        }),
+    })
+    const requestOptions = clampReasoningBudget(params.options, maxOutputTokens)
+    // altimate_change end
+
     return streamText({
       onError(error) {
         l.error("stream error", {
@@ -233,32 +287,19 @@ export namespace LLM {
       temperature: params.temperature,
       topP: params.topP,
       topK: params.topK,
-      providerOptions: ProviderTransform.providerOptions(input.model, params.options),
+      // altimate_change start — use the reasoning options reconciled with the final output reservation
+      providerOptions: ProviderTransform.providerOptions(input.model, requestOptions),
+      // altimate_change end
       activeTools: Object.keys(tools).filter((x) => x !== "invalid"),
       tools,
       toolChoice: input.toolChoice,
-      // altimate_change start — read maxOutputTokens from params (now plumbed through chat.params hook)
-      maxOutputTokens: params.maxOutputTokens,
+      // altimate_change start — use the plugin-selected reservation after context clamping
+      maxOutputTokens,
       // altimate_change end
       abortSignal: input.abort,
-      headers: {
-        ...(input.model.providerID.startsWith("opencode")
-          ? {
-              "x-opencode-project": Instance.project.id,
-              "x-opencode-session": input.sessionID,
-              "x-opencode-request": input.user.id,
-              "x-opencode-client": Flag.OPENCODE_CLIENT,
-            }
-          : input.model.providerID !== "anthropic"
-            ? {
-                // altimate_change start — upstream_fix: UA brand
-                "User-Agent": `altimate-code/${Installation.VERSION}`,
-                // altimate_change end
-              }
-            : undefined),
-        ...input.model.headers,
-        ...headers,
-      },
+      // altimate_change start — send the canonical headers used by the budget estimator
+      headers: requestHeaders,
+      // altimate_change end
       maxRetries: input.retries ?? 0,
       messages: [
         ...system.map(
@@ -276,8 +317,10 @@ export namespace LLM {
             specificationVersion: "v3",
             async transformParams(args) {
               if (args.type === "stream") {
+                // altimate_change start — transform messages with the reconciled reasoning options
                 // @ts-expect-error
-                args.params.prompt = ProviderTransform.message(args.params.prompt, input.model, options)
+                args.params.prompt = ProviderTransform.message(args.params.prompt, input.model, requestOptions)
+                // altimate_change end
               }
               return args.params
             },

packages/opencode/src/session/llm/native-request.ts

@@ -11,6 +11,9 @@ import {
 } from "@opencode-ai/llm/providers"
 import type { ModelMessage } from "ai"
 import type { Provider } from "@/provider/provider"
+// altimate_change start — preserve canonical header precedence through the native route adapter
+import { mergeRequestHeaders } from "@/provider/output-token-budget"
+// altimate_change end
 import { isRecord } from "@/util/record"
 
 type ToolInput = {
@@ -153,10 +156,15 @@ const requireBaseURL = (model: Provider.Model, url: string | undefined) => {
 export const model = (input: Provider.Model | RequestInput, headers?: Record<string, string>) => {
   const model = "model" in input ? input.model : input
   const url = baseURL(input)
+  // altimate_change start — avoid recreating differently-cased duplicates after request canonicalization
+  const requestHeaders = mergeRequestHeaders(model.headers, headers)
+  // altimate_change end
   const options = {
     ...("model" in input && input.apiKey ? { apiKey: input.apiKey } : {}),
     ...(url ? { baseURL: url } : {}),
-    headers: Object.keys({ ...model.headers, ...headers }).length === 0 ? undefined : { ...model.headers, ...headers },
+    // altimate_change start — the later request value wins case-insensitively at the final native boundary
+    headers: Object.keys(requestHeaders).length === 0 ? undefined : requestHeaders,
+    // altimate_change end
     limits: {
       context: model.limit.context,
       output: model.limit.output,

packages/opencode/src/session/llm/native-runtime.ts

@@ -1,8 +1,10 @@
 import type { Auth } from "@/auth"
 import type { Provider } from "@/provider/provider"
 import { ProviderTransform } from "@/provider/transform"
+// altimate_change start — share case-insensitive provider-to-request header precedence
+import { mergeRequestHeaders } from "@/provider/output-token-budget"
+// altimate_change end
 import { errorMessage } from "@/util/error"
-import { isRecord } from "@/util/record"
 import { asSchema, type ModelMessage, type Tool } from "ai"
 import { Cause, Effect, FiberSet, Queue } from "effect"
 import * as Stream from "effect/Stream"
@@ -98,7 +100,9 @@ export function stream(input: StreamInput): StreamResult {
     topK: input.topK,
     maxOutputTokens: input.maxOutputTokens,
     providerOptions: ProviderTransform.providerOptions(input.model, input.providerOptions ?? {}),
-    headers: { ...providerHeaders(input.provider.options.headers), ...input.headers },
+    // altimate_change start — canonical names keep request headers authoritative regardless of casing
+    headers: mergeRequestHeaders(input.provider.options.headers, input.headers),
+    // altimate_change end
   })
   const stream = Stream.scoped(
     Stream.unwrap(
@@ -152,13 +156,6 @@ function providerFetch(input: Pick<StreamInput, "provider" | "auth">): typeof gl
   return value as typeof globalThis.fetch
 }
 
-function providerHeaders(value: unknown): Record<string, string> | undefined {
-  if (!isRecord(value)) return undefined
-  return Object.fromEntries(
-    Object.entries(value).filter((entry): entry is [string, string] => typeof entry[1] === "string"),
-  )
-}
-
 function nativeSchema(value: unknown): JsonSchema {
   if (!value || typeof value !== "object") return { type: "object", properties: {} }
   if ("jsonSchema" in value && value.jsonSchema && typeof value.jsonSchema === "object")

packages/opencode/src/session/llm/request.ts

@@ -8,6 +8,15 @@ import type { Agent } from "@/agent/agent"
 import type { MessageV2 } from "../message-v2"
 import type { Provider } from "@/provider/provider"
 import { ProviderTransform } from "@/provider/transform"
+// altimate_change start — size and clamp the finalized provider request
+import {
+  clampOutputTokens,
+  clampReasoningBudget,
+  effectiveContextWindow,
+  estimateInputTokens,
+  mergeRequestHeaders,
+} from "@/provider/output-token-budget"
+// altimate_change end
 import { SystemPrompt } from "../system"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { Effect, Record } from "effect"
@@ -168,30 +177,66 @@ export const prepare = Effect.fn("LLMRequestPrep.prepare")(function* (input: Pre
     ? (yield* InstanceState.context).project.id
     : undefined
 
+  // altimate_change start — canonicalize the exact outgoing header precedence before budgeting
+  const requestHeaders = mergeRequestHeaders(
+    input.model.providerID.startsWith("opencode")
+      ? {
+          ...(opencodeProjectID ? { "x-opencode-project": opencodeProjectID } : {}),
+          "x-opencode-session": input.sessionID,
+          "x-opencode-request": input.user.id,
+          "x-opencode-client": input.flags.client,
+          "User-Agent": USER_AGENT,
+        }
+      : {
+          "x-session-affinity": input.sessionID,
+          "X-Session-Id": input.sessionID,
+          ...(input.parentSessionID ? { "x-parent-session-id": input.parentSessionID } : {}),
+          "User-Agent": USER_AGENT,
+        },
+    input.model.headers,
+    headers,
+  )
+  // altimate_change end
+
+  // altimate_change start — clamp after tools, headers, and plugin options are finalized.
+  const sortedTools = Object.fromEntries(Object.entries(tools).toSorted(([a], [b]) => a.localeCompare(b)))
+  const maxOutputTokens = clampOutputTokens({
+    model: input.model,
+    requested: params.maxOutputTokens,
+    context: effectiveContextWindow({
+      model: input.model,
+      // Provider defaults are lower precedence than the exact case-normalized outgoing record.
+      headerSources: [input.provider.options, requestHeaders],
+    }),
+    inputTokens: () =>
+      estimateInputTokens({
+        // OAuth carries this prompt in instructions; workflows deliberately omit it. Count the
+        // generated system prompt only when this request prepends it to the outgoing messages.
+        system: isOpenaiOauth || input.isWorkflow ? [] : system,
+        messages: ProviderTransform.messagesForInputEstimate(input.messages, input.model),
+        tools: sortedTools,
+        instructions: params.options.instructions,
+      }),
+  })
+  const requestOptions = clampReasoningBudget(params.options, maxOutputTokens)
+  const clampedParams = {
+    ...params,
+    maxOutputTokens,
+    options: requestOptions,
+  }
+  // altimate_change end
+
   return {
     system,
     messages,
-    tools: Object.fromEntries(Object.entries(tools).toSorted(([a], [b]) => a.localeCompare(b))),
-    params,
-    messageTransformOptions: options,
-    headers: {
-      ...(input.model.providerID.startsWith("opencode")
-        ? {
-            ...(opencodeProjectID ? { "x-opencode-project": opencodeProjectID } : {}),
-            "x-opencode-session": input.sessionID,
-            "x-opencode-request": input.user.id,
-            "x-opencode-client": input.flags.client,
-            "User-Agent": USER_AGENT,
-          }
-        : {
-            "x-session-affinity": input.sessionID,
-            "X-Session-Id": input.sessionID,
-            ...(input.parentSessionID ? { "x-parent-session-id": input.parentSessionID } : {}),
-            "User-Agent": USER_AGENT,
-          }),
-      ...input.model.headers,
-      ...headers,
-    },
+    // altimate_change start — return the finalized tools and context-window-clamped request values
+    tools: sortedTools,
+    params: clampedParams,
+    messageTransformOptions: requestOptions,
+    // altimate_change end
+    // altimate_change start — return the canonical headers used by the budget estimator
+    headers: requestHeaders,
+    // altimate_change end
   }
 })