@opencode-ai/ai 0.0.0-beta-18311 → 0.0.0-beta-18371

package/dist/protocols/anthropic-messages.d.ts

@@ -603,6 +603,7 @@ export declare const protocol: Protocol<{
     } | undefined;
     readonly content_block?: unknown;
 }, {
+    providerMetadataKey: string;
     tools: Partial<Record<number, ToolStream.PendingTool>>;
     reasoningSignatures: {};
     lifecycle: Lifecycle.State;

package/dist/protocols/anthropic-messages.js

@@ -313,18 +313,18 @@ const cacheControl = (breakpoints, cache) => {
     breakpoints.remaining -= 1;
     return Cache.ttlBucket(cache.ttlSeconds) === "1h" ? EPHEMERAL_1H : EPHEMERAL_5M;
 };
-const anthropicMetadata = (metadata) => ({ anthropic: metadata });
-const signatureFromMetadata = (metadata) => {
-    const anthropic = metadata?.anthropic;
-    if (!ProviderShared.isRecord(anthropic))
+const providerMetadata = (key, metadata) => ({ [key]: metadata });
+const signatureFromMetadata = (metadata, key) => {
+    const provider = metadata?.[key];
+    if (!ProviderShared.isRecord(provider))
         return undefined;
-    return typeof anthropic.signature === "string" ? anthropic.signature : undefined;
+    return typeof provider.signature === "string" ? provider.signature : undefined;
 };
-const redactedDataFromMetadata = (metadata) => {
-    const anthropic = metadata?.anthropic;
-    if (!ProviderShared.isRecord(anthropic))
+const redactedDataFromMetadata = (metadata, key) => {
+    const provider = metadata?.[key];
+    if (!ProviderShared.isRecord(provider))
         return undefined;
-    return typeof anthropic.redactedData === "string" ? anthropic.redactedData : undefined;
+    return typeof provider.redactedData === "string" ? provider.redactedData : undefined;
 };
 const lowerTool = (breakpoints, tool, inputSchema) => ({
     name: tool.name,
@@ -379,13 +379,13 @@ const serverToolResultType = (name) => {
         return "web_fetch_tool_result";
     return undefined;
 };
-const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult")(function* (part) {
+const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult")(function* (part, providerMetadataKey) {
     const wireType = serverToolResultType(part.name);
     if (!wireType)
         return yield* invalid(`Anthropic Messages does not know how to round-trip server tool result for ${part.name}`);
     // Prefer the provider-owned replay payload; fall back to the result value for
     // histories constructed directly from provider events.
-    const payload = part.providerMetadata?.anthropic?.["result"] ?? part.result.value;
+    const payload = part.providerMetadata?.[providerMetadataKey]?.["result"] ?? part.result.value;
     return {
         type: wireType,
         tool_use_id: scrubToolCallID(part.id),
@@ -658,6 +658,7 @@ const lowerNativeSystemUpdate = Effect.fn("AnthropicMessages.lowerNativeSystemUp
 });
 const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (request, breakpoints) {
     const messages = [];
+    const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider);
     for (const [index, message] of request.messages.entries()) {
         if (message.role === "system") {
             if (splitsLocalToolResults(request.messages, index))
@@ -701,8 +702,8 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
                 if (part.type === "reasoning") {
                     // A signature marks visible thinking; only signature-less parts carrying
                     // redactedData round-trip as opaque redacted_thinking blocks.
-                    const signature = part.encrypted ?? signatureFromMetadata(part.providerMetadata);
-                    const redactedData = redactedDataFromMetadata(part.providerMetadata);
+                    const signature = part.encrypted ?? signatureFromMetadata(part.providerMetadata, providerMetadataKey);
+                    const redactedData = redactedDataFromMetadata(part.providerMetadata, providerMetadataKey);
                     if (signature === undefined && redactedData !== undefined) {
                         content.push({ type: "redacted_thinking", data: redactedData });
                         continue;
@@ -732,7 +733,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
                     continue;
                 }
                 if (part.type === "tool-result" && part.providerExecuted) {
-                    content.push(yield* lowerServerToolResult(part));
+                    content.push(yield* lowerServerToolResult(part, providerMetadataKey));
                     continue;
                 }
                 return yield* invalid(`Anthropic Messages assistant messages only support text, reasoning, and tool-call content for now`);
@@ -897,7 +898,7 @@ const mapFinishReason = (reason) => {
 // inclusive `inputTokens` the rest of the contract expects. Extended
 // thinking tokens are included in `output_tokens`; newer responses also
 // expose that subset through `output_tokens_details.thinking_tokens`.
-const mapUsage = (usage) => {
+const mapUsage = (usage, providerMetadataKey) => {
     if (!usage)
         return undefined;
     const nonCached = usage.input_tokens ?? undefined;
@@ -912,7 +913,7 @@ const mapUsage = (usage) => {
         cacheWriteInputTokens: cacheWrite,
         reasoningTokens: usage.output_tokens_details?.thinking_tokens,
         totalTokens: ProviderShared.totalTokens(inputTokens, usage.output_tokens, undefined),
-        providerMetadata: { anthropic: usage },
+        providerMetadata: { [providerMetadataKey]: usage },
     });
 };
 // Anthropic emits usage on `message_start` and again on `message_delta` — the
@@ -920,7 +921,7 @@ const mapUsage = (usage) => {
 // field prefers `right` when defined, falls back to `left`. `inputTokens` is
 // recomputed from the merged breakdown so the inclusive total stays
 // consistent with `nonCached + cacheRead + cacheWrite`.
-const mergeUsage = (left, right) => {
+const mergeUsage = (left, right, providerMetadataKey) => {
     if (!left)
         return right;
     if (!right)
@@ -940,7 +941,8 @@ const mergeUsage = (left, right) => {
         reasoningTokens,
         totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
         providerMetadata: {
-            anthropic: mergeJsonRecords(left.providerMetadata?.["anthropic"], right.providerMetadata?.["anthropic"]) ?? {},
+            [providerMetadataKey]: mergeJsonRecords(left.providerMetadata?.[providerMetadataKey], right.providerMetadata?.[providerMetadataKey]) ??
+                {},
         },
     });
 };
@@ -955,7 +957,7 @@ const SERVER_TOOL_RESULT_NAMES = {
     web_fetch_tool_result: "web_fetch",
 };
 const isServerToolResultType = (type) => type in SERVER_TOOL_RESULT_NAMES;
-const serverToolResultEvent = (block) => {
+const serverToolResultEvent = (block, providerMetadataKey) => {
     if (!block.type || !isServerToolResultType(block.type))
         return undefined;
     const errorPayload = typeof block.content === "object" && block.content !== null && "type" in block.content
@@ -969,13 +971,13 @@ const serverToolResultEvent = (block) => {
         providerExecuted: true,
         // The complete payload is irreducible provider replay state: subsequent
         // stateless requests must round-trip the typed result block verbatim.
-        providerMetadata: anthropicMetadata({ blockType: block.type, result: block.content }),
+        providerMetadata: providerMetadata(providerMetadataKey, { blockType: block.type, result: block.content }),
     });
 };
 const NO_EVENTS = [];
 const onMessageStart = (state, event) => {
-    const usage = mapUsage(event.message?.usage);
-    return [usage ? { ...state, usage: mergeUsage(state.usage, usage) } : state, NO_EVENTS];
+    const usage = mapUsage(event.message?.usage, state.providerMetadataKey);
+    return [usage ? { ...state, usage: mergeUsage(state.usage, usage, state.providerMetadataKey) } : state, NO_EVENTS];
 };
 const onContentBlockStart = (state, event) => {
     const block = event.content_block;
@@ -1021,13 +1023,15 @@ const onContentBlockStart = (state, event) => {
     if (block.type === "thinking" && block.thinking !== undefined) {
         const events = [];
         const id = `reasoning-${event.index ?? 0}`;
-        const providerMetadata = block.signature === undefined ? undefined : anthropicMetadata({ signature: block.signature });
-        const lifecycle = Lifecycle.reasoningStart(state.lifecycle, events, id, providerMetadata);
+        const metadata = block.signature === undefined
+            ? undefined
+            : providerMetadata(state.providerMetadataKey, { signature: block.signature });
+        const lifecycle = Lifecycle.reasoningStart(state.lifecycle, events, id, metadata);
         return [
             {
                 ...state,
                 lifecycle: block.thinking
-                    ? Lifecycle.reasoningDelta(lifecycle, events, id, block.thinking, providerMetadata)
+                    ? Lifecycle.reasoningDelta(lifecycle, events, id, block.thinking, metadata)
                     : lifecycle,
                 reasoningSignatures: event.index === undefined || block.signature === undefined
                     ? state.reasoningSignatures
@@ -1044,12 +1048,12 @@ const onContentBlockStart = (state, event) => {
         return [
             {
                 ...state,
-                lifecycle: Lifecycle.reasoningStart(state.lifecycle, events, `reasoning-${event.index ?? 0}`, anthropicMetadata({ redactedData: block.data })),
+                lifecycle: Lifecycle.reasoningStart(state.lifecycle, events, `reasoning-${event.index ?? 0}`, providerMetadata(state.providerMetadataKey, { redactedData: block.data })),
             },
             events,
         ];
     }
-    const result = serverToolResultEvent(block);
+    const result = serverToolResultEvent(block, state.providerMetadataKey);
     if (!result)
         return [state, NO_EVENTS];
     const events = [];
@@ -1114,14 +1118,14 @@ const onContentBlockStop = Effect.fn("AnthropicMessages.onContentBlockStop")(fun
     const signature = state.reasoningSignatures[event.index];
     const lifecycle = resultEvents.length
         ? Lifecycle.stepStart(state.lifecycle, events)
-        : Lifecycle.reasoningEnd(Lifecycle.textEnd(state.lifecycle, events, `text-${event.index}`), events, `reasoning-${event.index}`, signature === undefined ? undefined : anthropicMetadata({ signature }));
+        : Lifecycle.reasoningEnd(Lifecycle.textEnd(state.lifecycle, events, `text-${event.index}`), events, `reasoning-${event.index}`, signature === undefined ? undefined : providerMetadata(state.providerMetadataKey, { signature }));
     events.push(...resultEvents);
     const reasoningSignatures = { ...state.reasoningSignatures };
     delete reasoningSignatures[event.index];
     return [{ ...state, lifecycle, tools: result.tools, reasoningSignatures }, events];
 });
 const onMessageDelta = (state, event) => {
-    const usage = mergeUsage(state.usage, mapUsage(event.usage));
+    const usage = mergeUsage(state.usage, mapUsage(event.usage, state.providerMetadataKey), state.providerMetadataKey);
     return [
         {
             ...state,
@@ -1133,7 +1137,7 @@ const onMessageDelta = (state, event) => {
                 },
                 providerMetadata: event.delta?.stop_sequence === null || event.delta?.stop_sequence === undefined
                     ? undefined
-                    : anthropicMetadata({ stopSequence: event.delta.stop_sequence }),
+                    : providerMetadata(state.providerMetadataKey, { stopSequence: event.delta.stop_sequence }),
             },
         },
         NO_EVENTS,
@@ -1246,7 +1250,8 @@ export const protocol = Protocol.make({
     },
     stream: {
         event: Protocol.jsonEvent(AnthropicEvent),
-        initial: () => ({
+        initial: (request) => ({
+            providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
             tools: ToolStream.empty(),
             reasoningSignatures: {},
             lifecycle: Lifecycle.initial(),

package/dist/protocols/bedrock-converse.d.ts

@@ -127,6 +127,7 @@ declare const BedrockConverseBody: Schema.Struct<{
 }>;
 export type BedrockConverseBody = Schema.Schema.Type<typeof BedrockConverseBody>;
 interface ParserState {
+    readonly providerMetadataKey: string;
     readonly tools: ToolStream.State<number>;
     readonly pendingFinish: {
         readonly reason: FinishReasonDetails;

package/dist/protocols/bedrock-converse.js

@@ -181,15 +181,17 @@ const lowerToolChoice = (toolChoice) => ProviderShared.matchToolChoice("Bedrock
     required: () => ({ any: {} }),
     tool: (name) => ({ tool: { name } }),
 });
-const bedrockMetadata = (metadata) => ({ bedrock: metadata });
-const reasoningSignature = (part) => {
-    const bedrock = part.providerMetadata?.bedrock;
+const providerMetadata = (key, metadata) => ({ [key]: metadata });
+const reasoningSignature = (part, providerMetadataKey) => {
+    const metadata = part.providerMetadata?.[providerMetadataKey];
     return (part.encrypted ??
-        (ProviderShared.isRecord(bedrock) && typeof bedrock.signature === "string" ? bedrock.signature : undefined));
+        (ProviderShared.isRecord(metadata) && typeof metadata.signature === "string" ? metadata.signature : undefined));
 };
-const reasoningRedactedData = (part) => {
-    const bedrock = part.providerMetadata?.bedrock;
-    return ProviderShared.isRecord(bedrock) && typeof bedrock.redactedData === "string" ? bedrock.redactedData : undefined;
+const reasoningRedactedData = (part, providerMetadataKey) => {
+    const metadata = part.providerMetadata?.[providerMetadataKey];
+    return ProviderShared.isRecord(metadata) && typeof metadata.redactedData === "string"
+        ? metadata.redactedData
+        : undefined;
 };
 const lowerToolCall = (part) => ({
     toolUse: {
@@ -230,6 +232,7 @@ const lowerToolResult = Effect.fn("BedrockConverse.lowerToolResult")(function* (
 });
 const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (request, breakpoints) {
     const messages = [];
+    const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider);
     for (const message of request.messages) {
         if (message.role === "system") {
             const part = yield* ProviderShared.wrappedSystemUpdate("Bedrock Converse", message);
@@ -276,8 +279,8 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (requ
                     continue;
                 }
                 if (part.type === "reasoning") {
-                    const signature = reasoningSignature(part);
-                    const redactedData = reasoningRedactedData(part);
+                    const signature = reasoningSignature(part, providerMetadataKey);
+                    const redactedData = reasoningRedactedData(part, providerMetadataKey);
                     if (signature === undefined && redactedData !== undefined) {
                         content.push({ reasoningContent: { redactedContent: redactedData } });
                         continue;
@@ -371,7 +374,7 @@ const mapFinishReason = (reason) => {
 };
 // AWS reports inputTokens separately from cache reads and writes.
 // Bedrock does not break reasoning out of outputTokens for current models.
-const mapUsage = (usage) => {
+const mapUsage = (usage, providerMetadataKey) => {
     if (!usage)
         return undefined;
     const inputTokens = ProviderShared.sumTokens(usage.inputTokens, usage.cacheReadInputTokens, usage.cacheWriteInputTokens);
@@ -382,7 +385,7 @@ const mapUsage = (usage) => {
         cacheReadInputTokens: usage.cacheReadInputTokens,
         cacheWriteInputTokens: usage.cacheWriteInputTokens,
         totalTokens: ProviderShared.totalTokens(inputTokens, usage.outputTokens, usage.totalTokens),
-        providerMetadata: { bedrock: usage },
+        providerMetadata: { [providerMetadataKey]: usage },
     });
 };
 const step = (state, event) => Effect.gen(function* () {
@@ -423,13 +426,13 @@ const step = (state, event) => Effect.gen(function* () {
         const reasoning = event.contentBlockDelta.delta.reasoningContent;
         const events = [];
         const redactedData = reasoning.redactedContent ?? reasoning.data;
-        const providerMetadata = reasoning.signature
-            ? bedrockMetadata({ signature: reasoning.signature })
+        const metadata = reasoning.signature
+            ? providerMetadata(state.providerMetadataKey, { signature: reasoning.signature })
             : redactedData !== undefined
-                ? bedrockMetadata({ redactedData })
+                ? providerMetadata(state.providerMetadataKey, { redactedData })
                 : undefined;
-        const lifecycle = reasoning.text !== undefined || providerMetadata !== undefined
-            ? Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${index}`, reasoning.text ?? "", providerMetadata)
+        const lifecycle = reasoning.text !== undefined || metadata !== undefined
+            ? Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${index}`, reasoning.text ?? "", metadata)
             : state.lifecycle;
         return [
             {
@@ -460,7 +463,7 @@ const step = (state, event) => Effect.gen(function* () {
         const lifecycle = resultEvents.length
             ? Lifecycle.stepStart(state.lifecycle, events)
             : Lifecycle.reasoningEnd(Lifecycle.textEnd(state.lifecycle, events, `text-${index}`), events, `reasoning-${index}`, state.reasoningSignatures[index]
-                ? bedrockMetadata({ signature: state.reasoningSignatures[index] })
+                ? providerMetadata(state.providerMetadataKey, { signature: state.reasoningSignatures[index] })
                 : undefined);
         events.push(...resultEvents);
         return [
@@ -491,7 +494,7 @@ const step = (state, event) => Effect.gen(function* () {
         ];
     }
     if (event.metadata) {
-        const usage = mapUsage(event.metadata.usage) ?? state.pendingFinish?.usage;
+        const usage = mapUsage(event.metadata.usage, state.providerMetadataKey) ?? state.pendingFinish?.usage;
         return [
             {
                 ...state,
@@ -548,7 +551,8 @@ export const protocol = Protocol.make({
     },
     stream: {
         event: BedrockEvent,
-        initial: () => ({
+        initial: (request) => ({
+            providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
             tools: ToolStream.empty(),
             pendingFinish: undefined,
             hasToolCalls: false,

package/dist/protocols/gemini.d.ts

@@ -197,6 +197,7 @@ export declare const protocol: Protocol<{
     } | null | undefined;
 }, {
     route: string;
+    providerMetadataKey: string;
     hasToolCalls: boolean;
     lifecycle: Lifecycle.State;
 }>;

package/dist/protocols/gemini.js

@@ -197,19 +197,20 @@ const lowerUserPart = Effect.fn("Gemini.lowerUserPart")(function* (part) {
     const media = ProviderShared.normalizeMedia(part);
     return { inlineData: { mimeType: media.mime, data: media.base64 } };
 });
-const googleMetadata = (metadata) => ({ google: metadata });
-const thoughtSignature = (providerMetadata) => {
-    const google = providerMetadata?.google;
-    return ProviderShared.isRecord(google) && typeof google.thoughtSignature === "string"
-        ? google.thoughtSignature
+const providerMetadata = (key, metadata) => ({ [key]: metadata });
+const thoughtSignature = (metadata, key) => {
+    const value = metadata?.[key];
+    return ProviderShared.isRecord(value) && typeof value.thoughtSignature === "string"
+        ? value.thoughtSignature
         : undefined;
 };
-const lowerToolCall = (part, omitIds) => ({
+const lowerToolCall = (part, omitIds, metadataKey) => ({
     functionCall: { ...(omitIds ? {} : { id: part.id }), name: part.name, args: part.input },
-    thoughtSignature: thoughtSignature(part.providerMetadata),
+    thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey),
 });
 const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
     const contents = [];
+    const metadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider);
     const omitCallIds = omitsFunctionCallIds(request.model.id);
     const legacyToolMedia = routesLegacyToolMedia(request.model.id);
     let pendingMedia;
@@ -251,15 +252,19 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
                 if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call"]))
                     return yield* ProviderShared.unsupportedContent("Gemini", "assistant", ["text", "reasoning", "tool-call"]);
                 if (part.type === "text") {
-                    parts.push({ text: part.text, thoughtSignature: thoughtSignature(part.providerMetadata) });
+                    parts.push({ text: part.text, thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey) });
                     continue;
                 }
                 if (part.type === "reasoning") {
-                    parts.push({ text: part.text, thought: true, thoughtSignature: thoughtSignature(part.providerMetadata) });
+                    parts.push({
+                        text: part.text,
+                        thought: true,
+                        thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey),
+                    });
                     continue;
                 }
                 if (part.type === "tool-call") {
-                    const lowered = lowerToolCall(part, omitCallIds);
+                    const lowered = lowerToolCall(part, omitCallIds, metadataKey);
                     const signature = lowered.thoughtSignature;
                     parts.push({
                         ...lowered,
@@ -396,7 +401,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request) {
 // `cachedContentTokenCount` subset. `candidatesTokenCount` is *exclusive*
 // of `thoughtsTokenCount` — visible-only, not a total — so we sum the two
 // to produce the inclusive `outputTokens` the rest of the contract expects.
-const mapUsage = (usage) => {
+const mapUsage = (usage, metadataKey) => {
     if (!usage)
         return undefined;
     // Explicit provider nulls decode as `null`; normalize to `undefined` so the
@@ -418,7 +423,7 @@ const mapUsage = (usage) => {
         cacheReadInputTokens: cached,
         reasoningTokens: thoughts,
         totalTokens: ProviderShared.totalTokens(promptTokens, outputTokens, usage.totalTokenCount ?? undefined),
-        providerMetadata: { google: usage },
+        providerMetadata: providerMetadata(metadataKey, usage),
     });
 };
 const mapFinishReason = (finishReason, hasToolCalls) => {
@@ -458,16 +463,18 @@ const finish = (state) => {
     const events = [];
     let lifecycle = state.lifecycle;
     if (state.reasoningSignature !== undefined)
-        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", googleMetadata({ thoughtSignature: state.reasoningSignature }));
+        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", providerMetadata(state.providerMetadataKey, { thoughtSignature: state.reasoningSignature }));
     if (state.textSignature !== undefined)
-        lifecycle = Lifecycle.textEnd(lifecycle, events, "text-0", googleMetadata({ thoughtSignature: state.textSignature }));
+        lifecycle = Lifecycle.textEnd(lifecycle, events, "text-0", providerMetadata(state.providerMetadataKey, { thoughtSignature: state.textSignature }));
     Lifecycle.finish(lifecycle, events, {
         reason: {
             normalized: promptBlockReason === undefined ? mapFinishReason(finishReason, state.hasToolCalls) : "content-filter",
             raw: finishReason,
         },
         usage: state.usage,
-        providerMetadata: state.promptFeedback === undefined ? undefined : googleMetadata({ promptFeedback: state.promptFeedback }),
+        providerMetadata: state.promptFeedback === undefined
+            ? undefined
+            : providerMetadata(state.providerMetadataKey, { promptFeedback: state.promptFeedback }),
     });
     return events;
 };
@@ -475,7 +482,9 @@ const step = (state, event) => {
     const nextState = {
         ...state,
         promptFeedback: event.promptFeedback ?? state.promptFeedback,
-        usage: event.usageMetadata ? (mapUsage(event.usageMetadata) ?? state.usage) : state.usage,
+        usage: event.usageMetadata
+            ? (mapUsage(event.usageMetadata, state.providerMetadataKey) ?? state.usage)
+            : state.usage,
     };
     const candidate = event.candidates?.[0];
     if (!candidate?.content)
@@ -510,11 +519,13 @@ const step = (state, event) => {
             textSignature = signature;
         if ("text" in part && part.text.length > 0) {
             if (part.thought) {
-                lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", part.text, signature ? googleMetadata({ thoughtSignature: signature }) : undefined);
+                lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", part.text, signature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: signature }) : undefined);
                 continue;
             }
-            lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined);
-            lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", part.text, textSignature ? googleMetadata({ thoughtSignature: textSignature }) : undefined);
+            lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningSignature
+                ? providerMetadata(state.providerMetadataKey, { thoughtSignature: reasoningSignature })
+                : undefined);
+            lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", part.text, textSignature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: textSignature }) : undefined);
             textSignature = undefined;
             continue;
         }
@@ -529,14 +540,16 @@ const step = (state, event) => {
             if (supplied !== undefined)
                 seenCallIds.add(supplied);
             const id = supplied !== undefined && !duplicate ? supplied : `tool_${crypto.randomUUID().replaceAll("-", "")}`;
-            lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined);
+            lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningSignature
+                ? providerMetadata(state.providerMetadataKey, { thoughtSignature: reasoningSignature })
+                : undefined);
             lifecycle = Lifecycle.stepStart(lifecycle, events);
             events.push(LLMEvent.toolCall({
                 id,
                 name: part.functionCall.name,
                 input,
                 providerMetadata: part.thoughtSignature
-                    ? googleMetadata({ thoughtSignature: part.thoughtSignature })
+                    ? providerMetadata(state.providerMetadataKey, { thoughtSignature: part.thoughtSignature })
                     : undefined,
             }));
             hasToolCalls = true;
@@ -572,6 +585,7 @@ export const protocol = Protocol.make({
         event: Protocol.jsonEvent(GeminiEvent),
         initial: (request) => ({
             route: `${request.model.provider}/${request.model.route.id}`,
+            providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
             hasToolCalls: false,
             lifecycle: Lifecycle.initial(),
         }),

package/dist/protocols/open-responses.d.ts

@@ -495,14 +495,14 @@ export declare const Event: Schema.StructWithRest<Schema.Struct<{
     readonly item_id: Schema.optional<Schema.String>;
     readonly output_index: Schema.optional<Schema.Number>;
     readonly summary_index: Schema.optional<Schema.Number>;
-    readonly item: Schema.optional<Schema.StructWithRest<Schema.Struct<{
+    readonly item: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
         readonly type: Schema.String;
         readonly id: Schema.optional<Schema.String>;
         readonly call_id: Schema.optional<Schema.String>;
         readonly name: Schema.optional<Schema.String>;
         readonly arguments: Schema.optional<Schema.String>;
         readonly encrypted_content: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
     readonly response: Schema.optional<Schema.StructWithRest<Schema.Struct<{
         readonly id: Schema.optional<Schema.String>;
         readonly service_tier: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -1165,7 +1165,7 @@ export declare const protocol: Protocol<{
         readonly arguments?: string | undefined;
         readonly encrypted_content?: string | null | undefined;
         readonly call_id?: string | undefined;
-    } | undefined;
+    } | null | undefined;
     readonly delta?: string | undefined;
     readonly response?: {
         readonly [x: string]: unknown;

package/dist/protocols/open-responses.js

@@ -242,7 +242,8 @@ export const Event = Schema.StructWithRest(Schema.Struct({
     item_id: Schema.optional(Schema.String),
     output_index: Schema.optional(Schema.Number),
     summary_index: Schema.optional(Schema.Number),
-    item: Schema.optional(StreamItem),
+    // OutputItemAdded/Done permit a null item in the Open Responses OpenAPI schema.
+    item: optionalNull(StreamItem),
     response: Schema.optional(Schema.StructWithRest(Schema.Struct({
         id: Schema.optional(Schema.String),
         service_tier: optionalNull(Schema.String),
@@ -598,7 +599,7 @@ const mapFinishReason = (event, hasFunctionCall) => {
 export const providerMetadata = (state, metadata) => ({
     [state.providerMetadataKey]: metadata,
 });
-const isReasoningItem = (item) => item.type === "reasoning" && typeof item.id === "string" && item.id.length > 0;
+const isReasoningItem = (item) => item.type === "reasoning" && typeof item.id === "string";
 const NO_EVENTS = [];
 // `response.completed` / `response.incomplete` are clean finishes that emit a
 // `finish` event; `response.failed` and `error` are hard failures. All four end
@@ -669,7 +670,7 @@ const reasoningMetadata = (state, item) => providerMetadata(state, { itemId: ite
 // best-effort, not guaranteed.
 const onOutputItemAdded = (state, event) => {
     const item = event.item;
-    if (item?.type === "message" && item.id) {
+    if (item?.type === "message" && item.id !== undefined) {
         const phase = messagePhase(item.phase);
         return [
             {
@@ -701,7 +702,7 @@ const onOutputItemAdded = (state, event) => {
     if (item?.type !== "function_call" || !item.call_id)
         return [state, NO_EVENTS];
     const id = item.id ?? item.call_id;
-    const metadata = item.id ? providerMetadata(state, { itemId: item.id }) : undefined;
+    const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined;
     const events = [];
     const lifecycle = Lifecycle.stepStart(state.lifecycle, events);
     return [
@@ -719,7 +720,7 @@ const onOutputItemAdded = (state, event) => {
     ];
 };
 const onReasoningSummaryPartAdded = (state, event) => {
-    if (!event.item_id || event.summary_index === undefined)
+    if (event.item_id === undefined || event.summary_index === undefined)
         return [state, NO_EVENTS];
     const item = state.reasoningItems[event.item_id];
     if (!item)
@@ -749,7 +750,7 @@ const onReasoningSummaryPartAdded = (state, event) => {
     ];
 };
 const onReasoningSummaryPartDone = (state, event) => {
-    if (!event.item_id || event.summary_index === undefined)
+    if (event.item_id === undefined || event.summary_index === undefined)
         return [state, NO_EVENTS];
     const item = state.reasoningItems[event.item_id];
     if (!item)
@@ -772,7 +773,7 @@ const onReasoningSummaryPartDone = (state, event) => {
     ];
 };
 const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgumentsDelta")(function* (state, event) {
-    if (!event.item_id)
+    if (event.item_id === undefined)
         return [state, NO_EVENTS];
     const tool = state.tools[event.item_id];
     if (!tool)
@@ -800,7 +801,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     const item = event.item;
     if (!item)
         return [state, NO_EVENTS];
-    if (item.type === "message" && item.id) {
+    if (item.type === "message" && item.id !== undefined) {
         const itemPhase = messagePhase(item.phase);
         const phase = itemPhase === undefined ? state.messagePhases[item.id] : itemPhase;
         const events = [];
@@ -826,7 +827,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
             : ToolStream.start(state.tools, id, {
                 id: item.call_id,
                 name: item.name,
-                providerMetadata: item.id ? providerMetadata(state, { itemId: item.id }) : undefined,
+                providerMetadata: item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined,
             });
         const result = item.arguments === undefined
             ? yield* ToolStream.finish(state.id, tools, id)
@@ -874,7 +875,7 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
     const reconciled = event.type === "response.completed"
         ? yield* Effect.reduce(event.response?.output ?? [], () => [state, NO_EVENTS], ([current, events], item) => {
             const id = item.id ?? (item.type === "function_call" ? item.call_id : undefined);
-            if (!id ||
+            if (id === undefined ||
                 ((item.type !== "function_call" || !current.tools[id]) &&
                     (item.type !== "reasoning" || !current.reasoningItems[id])))
                 return Effect.succeed([current, events]);
@@ -945,11 +946,12 @@ export const providerFailure = (id, event, fallback) => {
 };
 const providerError = (state, event, fallback) => providerFailure(state.id, event, fallback);
 export const step = (state, input) => {
-    const event = input.item_id && outputItemID(state, input) !== input.item_id
+    // The OpenAPI requires string IDs but imposes no minLength; empty is not missing.
+    const event = input.item_id !== undefined && outputItemID(state, input) !== input.item_id
         ? { ...input, item_id: outputItemID(state, input) }
         : input;
     if (event.type === "response.output_text.delta" || event.type === "response.output_text.done") {
-        if (!event.item_id)
+        if (event.item_id === undefined)
             return ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
         return Effect.succeed(event.type === "response.output_text.delta"
             ? onOutputTextDelta(state, event, event.item_id)
@@ -957,46 +959,46 @@ export const step = (state, input) => {
     }
     if (event.type === "response.refusal.delta" || event.type === "response.refusal.done") {
         const value = event.type === "response.refusal.delta" ? event.delta : event.refusal;
-        if (!event.item_id || typeof value !== "string")
+        if (event.item_id === undefined || typeof value !== "string")
             return ProviderShared.eventError(state.id, `${event.type} is malformed`);
         return Effect.succeed(event.type === "response.refusal.delta"
             ? onOutputTextDelta(state, event, event.item_id)
             : onOutputTextDone(state, { ...event, text: value }, event.item_id));
     }
     if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta") {
-        if (!event.item_id)
+        if (event.item_id === undefined)
             return ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
         return Effect.succeed(onReasoningDelta(state, event, event.item_id));
     }
     if (event.type === "response.reasoning.done" ||
         event.type === "response.reasoning_summary_text.done" ||
         event.type === "response.reasoning_text.done") {
-        if (!event.item_id)
+        if (event.item_id === undefined)
             return ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
         return Effect.succeed(onReasoningDone(state, event, event.item_id));
     }
     if (event.type === "response.reasoning_summary_part.added")
-        return event.item_id
+        return event.item_id !== undefined
             ? Effect.succeed(onReasoningSummaryPartAdded(state, event))
             : ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
     if (event.type === "response.reasoning_summary_part.done")
-        return event.item_id
+        return event.item_id !== undefined
             ? Effect.succeed(onReasoningSummaryPartDone(state, event))
             : ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
     if (event.type === "response.output_item.added") {
-        if (event.item?.type === "message" && !event.item.id)
+        if (event.item?.type === "message" && event.item.id === undefined)
             return ProviderShared.eventError(state.id, `${event.type} message is missing id`);
         const id = event.item?.id ?? (event.item?.type === "function_call" ? event.item.call_id : undefined);
-        return Effect.succeed(onOutputItemAdded(event.output_index !== undefined && id
+        return Effect.succeed(onOutputItemAdded(event.output_index !== undefined && id !== undefined
             ? { ...state, outputItems: { ...state.outputItems, [event.output_index]: id } }
             : state, event));
     }
     if (event.type === "response.function_call_arguments.delta" || event.type === "response.function_call_arguments.done")
-        return event.item_id
+        return event.item_id !== undefined
             ? onFunctionCallArgumentsDelta(state, event)
             : ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
     if (event.type === "response.output_item.done") {
-        if (event.item?.type === "message" && !event.item.id)
+        if (event.item?.type === "message" && event.item.id === undefined)
             return ProviderShared.eventError(state.id, `${event.type} message is missing id`);
         return onOutputItemDone(state, event);
     }

package/dist/protocols/openai-chat.d.ts

@@ -269,6 +269,7 @@ interface PendingToolDelta {
     readonly input: string;
 }
 export interface ParserState {
+    readonly providerMetadataKey: string;
     readonly tools: ToolStream.State<number>;
     readonly pendingTools: Partial<Record<number, PendingToolDelta>>;
     readonly toolCallEvents: ReadonlyArray<LLMEvent>;

package/dist/protocols/openai-chat.js

@@ -207,16 +207,16 @@ const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part) {
     return { type: "image_url", image_url: { url: media.dataUrl } };
 });
 const openAICompatibleReasoningContent = (native) => isRecord(native) && typeof native.reasoning_content === "string" ? native.reasoning_content : undefined;
-const reasoningField = (part) => {
-    const field = part.providerMetadata?.openai?.reasoningField;
+const reasoningField = (part, providerMetadataKey) => {
+    const field = part.providerMetadata?.[providerMetadataKey]?.reasoningField;
     return typeof field === "string" ? field : undefined;
 };
-const reasoningDetails = (parts, native) => {
+const reasoningDetails = (parts, native, providerMetadataKey) => {
     const observed = parts.flatMap((part) => {
-        const details = part.providerMetadata?.openai?.reasoningDetails;
+        const details = part.providerMetadata?.[providerMetadataKey]?.reasoningDetails;
         return Array.isArray(details) ? details : [];
     });
-    if (parts.some((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails)))
+    if (parts.some((part) => Array.isArray(part.providerMetadata?.[providerMetadataKey]?.reasoningDetails)))
         return observed;
     if (isRecord(native) && Array.isArray(native.reasoning_details))
         return native.reasoning_details;
@@ -262,10 +262,12 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
         }
     }
     const text = reasoning.map((part) => part.text).join("");
-    const details = reasoningDetails(reasoning, message.native?.openaiCompatible);
-    const observedField = reasoning.map(reasoningField).find((value) => value !== undefined);
+    const details = reasoningDetails(reasoning, message.native?.openaiCompatible, options.providerMetadataKey);
+    const observedField = reasoning
+        .map((part) => reasoningField(part, options.providerMetadataKey))
+        .find((value) => value !== undefined);
     const nativeReasoning = openAICompatibleReasoningContent(message.native?.openaiCompatible);
-    const fullyStructured = reasoning.every((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails));
+    const fullyStructured = reasoning.every((part) => Array.isArray(part.providerMetadata?.[options.providerMetadataKey]?.reasoningDetails));
     const field = (() => {
         if (configuredField !== undefined && (requireReasoning || reasoning.length > 0 || nativeReasoning !== undefined))
             return configuredField;
@@ -359,6 +361,7 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request,
     const mistral = ["mistral", "devstral", "codestral", "pixtral", "mixtral"].some((family) => modelID.includes(family));
     const lowering = {
         ...options,
+        providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
         toolCallID: (id) => {
             if (mistral)
                 return id
@@ -644,7 +647,7 @@ const mapFinishReason = Effect.fn("OpenAIChat.mapFinishReason")(function* (event
 // Providers differ on cache-hit location: OpenAI uses
 // `prompt_tokens_details.cached_tokens`, DeepSeek uses
 // `prompt_cache_hit_tokens`, and Zai uses top-level `cached_tokens`.
-const mapUsage = (usage) => {
+const mapUsage = (usage, providerMetadataKey) => {
     if (!usage)
         return undefined;
     const input = usage.prompt_tokens ?? undefined;
@@ -664,7 +667,7 @@ const mapUsage = (usage) => {
         cacheWriteInputTokens: cacheWrite,
         reasoningTokens: reasoning,
         totalTokens: ProviderShared.totalTokens(input, output, usage.total_tokens ?? undefined),
-        providerMetadata: { openai: usage },
+        providerMetadata: { [providerMetadataKey]: usage },
     });
 };
 const toolIndexByID = (tools, pendingTools, id) => {
@@ -725,8 +728,8 @@ const conflictingReasoningTextDetails = (previous, current) => conflictingDetail
     conflictingDetailValue(previous.format, current.format) ||
     (Boolean(previous.signature) && Boolean(current.signature) && previous.signature !== current.signature);
 const conflictingDetailValue = (previous, current) => previous !== undefined && previous !== null && current !== undefined && current !== null && previous !== current;
-const reasoningMetadata = (field, details) => ({
-    openai: {
+const reasoningMetadata = (providerMetadataKey, field, details) => ({
+    [providerMetadataKey]: {
         ...(field ? { reasoningField: field } : {}),
         ...(details ? { reasoningDetails: details } : {}),
     },
@@ -751,7 +754,9 @@ const step = (state, event) => Effect.gen(function* () {
     // Moonshot (and a few other OpenAI-compatible providers) attach usage to
     // `choice.usage` instead of the top-level `usage` field.
     const choiceUsage = choice?.usage;
-    const usage = mapUsage(event.usage) ?? (choiceUsage ? mapUsage(choiceUsage) : undefined) ?? state.usage;
+    const usage = mapUsage(event.usage, state.providerMetadataKey) ??
+        (choiceUsage ? mapUsage(choiceUsage, state.providerMetadataKey) : undefined) ??
+        state.usage;
     const rawFinishReason = choice?.finish_reason;
     const finishReason = rawFinishReason
         ? {
@@ -782,7 +787,7 @@ const step = (state, event) => Effect.gen(function* () {
     if (detailDelta !== undefined)
         appendReasoningDetails(state.reasoningDetails, detailDelta);
     const reasoningDetailsObserved = state.reasoningDetailsObserved || detailDelta !== undefined;
-    const deltaMetadata = reasoningMetadata(reasoningField);
+    const deltaMetadata = reasoningMetadata(state.providerMetadataKey, reasoningField);
     const text = detailDelta?.length ? (detailText(detailDelta) ?? reasoning?.text) : reasoning?.text;
     if (text !== undefined)
         lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", text, deltaMetadata);
@@ -792,11 +797,11 @@ const step = (state, event) => Effect.gen(function* () {
         lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata);
     const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0");
     if (delta?.content) {
-        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined));
+        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningMetadata(state.providerMetadataKey, reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined));
         lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content);
     }
     if (delta?.refusal) {
-        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined));
+        lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0", reasoningMetadata(state.providerMetadataKey, reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined));
         lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.refusal);
     }
     // Compatible providers may omit indexes. Prefer durable identity, then use
@@ -841,6 +846,7 @@ const step = (state, event) => Effect.gen(function* () {
         : undefined;
     return [
         {
+            providerMetadataKey: state.providerMetadataKey,
             tools: finished?.tools ?? tools,
             pendingTools,
             toolCallEvents: finished?.events ?? state.toolCallEvents,
@@ -880,9 +886,9 @@ const finishEvents = Effect.fn("OpenAIChat.finishEvents")(function* (state) {
             normalized: state.finishReason.normalized === "stop" && hasToolCalls ? "tool-calls" : state.finishReason.normalized,
         }
         : { normalized: hasToolCalls ? "tool-calls" : "stop" };
-    const metadata = reasoningMetadata(state.reasoningField, state.reasoningDetailsObserved ? state.reasoningDetails : undefined);
+    const metadata = reasoningMetadata(state.providerMetadataKey, state.reasoningField, state.reasoningDetailsObserved ? state.reasoningDetails : undefined);
     const started = state.reasoningDetailsObserved && !state.reasoningEmitted
-        ? Lifecycle.reasoningStart(state.lifecycle, events, "reasoning-0", reasoningMetadata(state.reasoningField))
+        ? Lifecycle.reasoningStart(state.lifecycle, events, "reasoning-0", reasoningMetadata(state.providerMetadataKey, state.reasoningField))
         : state.lifecycle;
     const ended = Lifecycle.reasoningEnd(started, events, "reasoning-0", metadata);
     const lifecycle = toolCallEvents.length ? Lifecycle.stepStart(ended, events) : ended;
@@ -908,6 +914,7 @@ export const protocol = Protocol.make({
     stream: {
         event: Protocol.jsonEvent(OpenAIChatEvent),
         initial: (request) => ({
+            providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
             tools: ToolStream.empty(),
             pendingTools: {},
             toolCallEvents: [],

package/dist/protocols/openai-responses.d.ts

@@ -386,7 +386,7 @@ export declare const protocol: Protocol<{
         readonly arguments?: string | undefined;
         readonly encrypted_content?: string | null | undefined;
         readonly call_id?: string | undefined;
-    } | undefined;
+    } | null | undefined;
     readonly delta?: string | undefined;
     readonly response?: {
         readonly [x: string]: unknown;

package/dist/protocols/openai-responses.js

@@ -147,7 +147,7 @@ const HOSTED_TOOLS = {
 };
 const step = (state, event) => {
     if (event.type === "response.reasoning_text.delta")
-        return event.item_id
+        return event.item_id !== undefined
             ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, OpenResponses.outputItemID(state, event) ?? event.item_id))
             : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`);
     if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))

package/dist/protocols/xai-responses.d.ts

@@ -187,7 +187,7 @@ export declare const protocol: Protocol<{
         readonly arguments?: string | undefined;
         readonly encrypted_content?: string | null | undefined;
         readonly call_id?: string | undefined;
-    } | undefined;
+    } | null | undefined;
     readonly delta?: string | undefined;
     readonly response?: {
         readonly [x: string]: unknown;

package/dist/providers/amazon-bedrock/mantle.d.ts

@@ -1,2 +1,2 @@
-export { chatModel as model } from "../amazon-bedrock-mantle.js";
+export { responsesModel as model } from "../amazon-bedrock-mantle.js";
 export type { Settings } from "../amazon-bedrock-mantle.js";

package/dist/providers/amazon-bedrock/mantle.js

@@ -1 +1 @@
-export { chatModel as model } from "../amazon-bedrock-mantle.js";
+export { responsesModel as model } from "../amazon-bedrock-mantle.js";

package/dist/providers/amazon-bedrock-mantle.d.ts

@@ -17,6 +17,7 @@ export interface Settings extends ProviderPackage.Settings {
     readonly baseURL?: string;
     readonly credentials?: Credentials;
     readonly region?: string;
+    readonly topP?: number;
     readonly providerOptions?: OpenAIProviderOptionsInput;
 }
 export declare const routes: (Route<{

package/dist/providers/amazon-bedrock-mantle.js

@@ -9,7 +9,7 @@ export const id = ProviderID.make("amazon-bedrock");
 const responsesRoute = Route.make({
     id: "bedrock-mantle-responses",
     provider: id,
-    providerMetadataKey: OpenAIResponses.route.providerMetadataKey,
+    providerMetadataKey: "mantle",
     protocol: OpenAIResponses.protocol,
     endpoint: OpenAIResponses.route.endpoint,
     auth: OpenAIResponses.route.auth,
@@ -19,6 +19,7 @@ const responsesRoute = Route.make({
 const chatRoute = OpenAIChat.route.with({
     id: "bedrock-mantle-chat",
     provider: id,
+    providerMetadataKey: "mantle",
 });
 export const routes = [responsesRoute, chatRoute];
 const configuredRoute = (route, input) => {
@@ -47,7 +48,7 @@ export const configure = (input = {}) => {
         .model({ id: modelID });
     return {
         id,
-        model: chat,
+        model: responses,
         chat,
         responses,
         configure,
@@ -63,6 +64,7 @@ const config = (settings) => {
         apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
         baseURL: settings.baseURL,
         credentials: settings.credentials,
+        generation: settings.topP === undefined ? undefined : { topP: settings.topP },
         headers: settings.headers === undefined ? undefined : { ...settings.headers },
         http: settings.body === undefined ? undefined : { body: { ...settings.body } },
         providerOptions: settings.providerOptions,
@@ -71,4 +73,4 @@ const config = (settings) => {
 };
 export const chatModel = (modelID, settings) => configure(config(settings)).chat(modelID);
 export const responsesModel = (modelID, settings) => configure(config(settings)).responses(modelID);
-export const model = chatModel;
+export const model = responsesModel;

package/dist/providers/amazon-bedrock.js

@@ -10,6 +10,7 @@ const configuredRoute = (input) => {
     return BedrockConverse.route.with({
         ...rest,
         provider: id,
+        providerMetadataKey: "bedrock",
         endpoint: { baseURL: baseURL ?? bedrockBaseURL(resolvedRegion) },
         auth: apiKey === undefined ? BedrockConverse.sigV4Auth(credentials) : Auth.bearer(apiKey),
     });

package/dist/providers/google-vertex-chat.js

@@ -5,6 +5,7 @@ export const id = ProviderID.make("google-vertex");
 const route = OpenAICompatibleChat.route.with({
     id: "google-vertex-chat",
     provider: id,
+    providerMetadataKey: "vertex",
 });
 export const routes = [route];
 const configuredRoute = (input) => {

package/dist/providers/google-vertex-responses.js

@@ -5,6 +5,7 @@ export const id = ProviderID.make("google-vertex");
 const route = OpenAICompatibleResponses.route.with({
     id: "google-vertex-responses",
     provider: id,
+    providerMetadataKey: "vertex",
     providerOptions: { store: false },
 });
 export const routes = [route];

package/dist/providers/google-vertex.js

@@ -38,7 +38,7 @@ const protocol = {
 const route = Route.make({
     id: "google-vertex-gemini",
     provider: id,
-    providerMetadataKey: "google",
+    providerMetadataKey: "vertex",
     protocol,
     endpoint: Endpoint.path(({ request }) => {
         const model = String(request.model.id);

package/dist/providers/openrouter.js

@@ -84,6 +84,7 @@ const bodyOptions = (input) => {
 export const route = Route.make({
     id: ADAPTER,
     provider: profile.provider,
+    providerMetadataKey: "openrouter",
     protocol,
     endpoint: Endpoint.path("/chat/completions", { baseURL: profile.baseURL }),
     framing: Framing.sse,

package/dist/route/client.d.ts

@@ -49,6 +49,7 @@ export interface RouteDefaultsInput {
 export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
     readonly id?: string;
     readonly provider?: string | ProviderID;
+    readonly providerMetadataKey?: string;
     readonly auth?: Auth.Definition;
     readonly transport?: Transport<Body, Prepared, unknown>;
     readonly endpoint?: EndpointPatch<Body>;

package/dist/route/client.js

@@ -98,11 +98,15 @@ function makeFromTransport(input) {
             defaults: routeInput.defaults ?? {},
             body: protocol.body,
             with: (patch) => {
-                const { id, provider, auth, transport, endpoint, ...defaults } = patch;
+                const { id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch;
                 return build({
                     ...routeInput,
                     id: id ?? routeInput.id,
                     provider: provider ?? routeInput.provider,
+                    providerMetadataKey: providerMetadataKey ??
+                        (provider !== undefined && String(provider) !== String(routeInput.provider)
+                            ? String(provider)
+                            : routeInput.providerMetadataKey),
                     auth: auth ?? routeInput.auth,
                     endpoint: endpoint ? Endpoint.merge(routeInput.endpoint, endpoint) : routeInput.endpoint,
                     transport: transport ?? routeInput.transport,

package/dist/route/executor.js

@@ -6,14 +6,6 @@ export class Service extends Context.Service()("@opencode/AI/RequestExecutor") {
 }
 const headerDetails = (headers) => Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, String(value)]));
 const normalizedHeaders = (headers) => Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
-const requestId = (headers) => {
-    return (headers["x-request-id"] ??
-        headers["request-id"] ??
-        headers["x-amzn-requestid"] ??
-        headers["x-amz-request-id"] ??
-        headers["x-goog-request-id"] ??
-        headers["cf-ray"]);
-};
 const retryAfterMs = (headers) => {
     const millis = Number(headers["retry-after-ms"]);
     if (Number.isFinite(millis))
@@ -95,7 +87,6 @@ const responseHttp = (input) => new HttpContext({
     request: requestDetails(input.request),
     response: responseDetails(input.response),
     ...input.body,
-    requestId: input.requestId,
     rateLimit: input.rateLimit,
 });
 const statusError = (request) => (response) => Effect.gen(function* () {
@@ -118,7 +109,6 @@ const statusError = (request) => (response) => Effect.gen(function* () {
                 request,
                 response,
                 body: details,
-                requestId: requestId(headers),
                 rateLimit,
             }),
         }),
@@ -146,7 +136,6 @@ export const classifyHttpFailure = (input) => {
                 ? undefined
                 : new HttpResponseDetails({ status: input.status, headers: headerDetails(Headers.fromInput(headers)) }),
             ...details,
-            requestId: requestId(headers),
             rateLimit,
         }),
     });

package/dist/schema/errors.d.ts

@@ -28,7 +28,6 @@ declare const HttpContext_base: Schema.Class<HttpContext, Schema.Struct<{
     readonly response: Schema.optional<typeof HttpResponseDetails>;
     readonly body: Schema.optional<Schema.String>;
     readonly bodyTruncated: Schema.optional<Schema.Boolean>;
-    readonly requestId: Schema.optional<Schema.String>;
     readonly rateLimit: Schema.optional<typeof HttpRateLimitDetails>;
 }>, {}>;
 export declare class HttpContext extends HttpContext_base {

package/dist/schema/errors.js

@@ -26,7 +26,6 @@ export class HttpContext extends Schema.Class("AI.HttpContext")({
     response: Schema.optional(HttpResponseDetails),
     body: Schema.optional(Schema.String),
     bodyTruncated: Schema.optional(Schema.Boolean),
-    requestId: Schema.optional(Schema.String),
     rateLimit: Schema.optional(HttpRateLimitDetails),
 }) {
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-beta-18311",
+  "version": "0.0.0-beta-18371",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.111",
-    "@opencode-ai/http-recorder": "0.0.0-beta-18311",
+    "@opencode-ai/http-recorder": "0.0.0-beta-18371",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -39,7 +39,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-beta-18311",
+    "@opencode-ai/schema": "0.0.0-beta-18371",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.111",
     "google-auth-library": "10.5.0"