@opencode/ai 2.1.2 → 2.1.4

package/dist/protocols/bedrock-event-stream.js

@@ -1,6 +1,6 @@
 import { EventStreamCodec } from "@smithy/eventstream-codec";
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
-import { Effect, Stream } from "effect";
+import { Effect, Schema, Stream } from "effect";
 import { Base64 } from "effect/encoding";
 import { AIError, AIErrorReason, InvalidProviderOutputError } from "../schema/index.js";
 import { Framing } from "../route/framing.js";
@@ -12,6 +12,7 @@ import { ProviderShared } from "./shared.js";
 const eventCodec = new EventStreamCodec(toUtf8, fromUtf8);
 const utf8 = new TextDecoder();
 const initialFrameBuffer = { buffer: new Uint8Array(0), offset: 0 };
+export const Frame = Schema.StructWithRest(Schema.Struct({ rawBody: Schema.String }), [ProviderShared.JsonObject]);
 const endOfStream = { _tag: "End" };
 const appendChunk = (state, chunk) => {
     const remaining = state.buffer.length - state.offset;
@@ -71,14 +72,14 @@ const consumeFrames = (route) => (state, input) => Effect.gen(function* () {
         // before handing the object to the chunk schema. JSON decode goes
         // through the shared Schema-driven codec to satisfy the package rule
         // against ad-hoc `JSON.parse` calls.
-        const parsed = (yield* ProviderShared.parseJson(route, payload, "Failed to parse Bedrock Converse event-stream payload").pipe(Effect.mapError((error) => new AIError({
+        const parsed = yield* ProviderShared.parseJson(route, payload, "Failed to parse Bedrock Converse event-stream payload").pipe(Effect.mapError((error) => new AIError({
             reason: AIErrorReason.make({ ...error.reason, message: error.message, cause: error.reason.cause, body }),
-        }))));
-        delete parsed.p;
+        })));
+        if (!ProviderShared.isRecord(parsed))
+            return yield* ProviderShared.eventError(route, "Failed to parse Bedrock Converse event-stream payload", body);
+        const { p: _, ...event } = parsed;
         out.push({
-            ...(messageType === "exception"
-                ? { exception: { type: eventType, details: parsed } }
-                : { [eventType]: parsed }),
+            ...(messageType === "exception" ? { exception: { type: eventType, details: event } } : { [eventType]: event }),
             rawBody: body,
         });
     }
@@ -92,7 +93,7 @@ const consumeFrames = (route) => (state, input) => Effect.gen(function* () {
  */
 export const framing = (route) => ({
     id: "aws-event-stream",
-    body: (frame) => ("rawBody" in frame && typeof frame.rawBody === "string" ? frame.rawBody : undefined),
+    body: (frame) => frame.rawBody,
     frame: (bytes) => bytes.pipe(Stream.map((bytes) => ({ _tag: "Chunk", bytes })), Stream.concat(Stream.succeed(endOfStream)), Stream.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route))),
 });
 export * as BedrockEventStream from "./bedrock-event-stream.js";

package/dist/protocols/cartesia-speech.d.ts

@@ -23,14 +23,6 @@ interface State extends SpeechStream.Audio {
     readonly done: boolean;
 }
 export declare const protocol: MediaProtocol.Streamed<Request, {
-    readonly type: "generation-queued";
-    readonly id: string;
-    readonly position?: number | undefined;
-} | {
-    readonly type: "generation-progress";
-    readonly id: string;
-    readonly progress?: number | undefined;
-} | {
     readonly type: "audio-delta";
     readonly chunk: Uint8Array<ArrayBufferLike>;
 } | {
@@ -40,18 +32,18 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
         readonly startSeconds: number;
         readonly endSeconds: number;
     }[];
+} | {
+    readonly type: "generation-queued";
+    readonly id: string;
+    readonly position?: number | undefined;
+} | {
+    readonly type: "generation-progress";
+    readonly id: string;
+    readonly progress?: number | undefined;
 } | {
     readonly type: "finish";
     readonly audio: import("../media.js").Asset;
     readonly usage?: {
-        readonly type: "tokens";
-        readonly input?: number | undefined;
-        readonly output?: number | undefined;
-        readonly total?: number | undefined;
-        readonly details?: {
-            readonly [x: string]: unknown;
-        } | undefined;
-    } | {
         readonly type: "seconds";
         readonly seconds: number;
     } | {
@@ -63,6 +55,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
     } | {
         readonly type: "compute";
         readonly seconds: number;
+    } | {
+        readonly type: "tokens";
+        readonly input?: number | undefined;
+        readonly output?: number | undefined;
+        readonly total?: number | undefined;
+        readonly details?: {
+            readonly [x: string]: unknown;
+        } | undefined;
     } | undefined;
     readonly notices?: readonly {
         readonly type: "filtered" | "moderated" | "other";
@@ -82,14 +82,6 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<CartesiaSpeechOptions>;
 export declare const CartesiaSpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
-        readonly type: "generation-queued";
-        readonly id: string;
-        readonly position?: number | undefined;
-    } | {
-        readonly type: "generation-progress";
-        readonly id: string;
-        readonly progress?: number | undefined;
-    } | {
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     } | {
@@ -99,18 +91,18 @@ export declare const CartesiaSpeech: {
             readonly startSeconds: number;
             readonly endSeconds: number;
         }[];
+    } | {
+        readonly type: "generation-queued";
+        readonly id: string;
+        readonly position?: number | undefined;
+    } | {
+        readonly type: "generation-progress";
+        readonly id: string;
+        readonly progress?: number | undefined;
     } | {
         readonly type: "finish";
         readonly audio: import("../media.js").Asset;
         readonly usage?: {
-            readonly type: "tokens";
-            readonly input?: number | undefined;
-            readonly output?: number | undefined;
-            readonly total?: number | undefined;
-            readonly details?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
             readonly type: "seconds";
             readonly seconds: number;
         } | {
@@ -122,6 +114,14 @@ export declare const CartesiaSpeech: {
         } | {
             readonly type: "compute";
             readonly seconds: number;
+        } | {
+            readonly type: "tokens";
+            readonly input?: number | undefined;
+            readonly output?: number | undefined;
+            readonly total?: number | undefined;
+            readonly details?: {
+                readonly [x: string]: unknown;
+            } | undefined;
         } | undefined;
         readonly notices?: readonly {
             readonly type: "filtered" | "moderated" | "other";

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

@@ -11,11 +11,6 @@ declare const Options: Schema.Struct<{
     }>>;
 }>;
 export type ProviderOptionsInput = Schema.Schema.Type<typeof Options>;
-type State = {
-    readonly lifecycle: Lifecycle.State;
-    readonly tools: ToolStream.State<number>;
-    readonly finished: boolean;
-};
 export declare const protocol: Protocol<{
     readonly model: string;
     readonly messages: readonly {
@@ -49,7 +44,9 @@ export declare const protocol: Protocol<{
         readonly function: {
             readonly name: string;
             readonly description?: string | undefined;
-            readonly parameters: unknown;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
         };
     }[] | undefined;
     readonly tool_choice?: "NONE" | "REQUIRED" | undefined;
@@ -66,6 +63,8 @@ export declare const protocol: Protocol<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, string, {
+    readonly type: "unknown";
+} | {
     readonly type: "message-start";
 } | {
     readonly type: "content-delta" | "content-start";
@@ -125,9 +124,11 @@ export declare const protocol: Protocol<{
     };
 } | {
     readonly type: "citation-end" | "citation-start";
-} | {
-    readonly type: "unknown";
-}, State>;
+}, {
+    readonly lifecycle: Lifecycle.State;
+    readonly finished: boolean;
+    readonly tools: Partial<Record<number, ToolStream.PendingTool>>;
+}>;
 export declare const route: Route<{
     readonly model: string;
     readonly messages: readonly {
@@ -161,7 +162,9 @@ export declare const route: Route<{
         readonly function: {
             readonly name: string;
             readonly description?: string | undefined;
-            readonly parameters: unknown;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
         };
     }[] | undefined;
     readonly tool_choice?: "NONE" | "REQUIRED" | undefined;

package/dist/protocols/cohere-chat.js

@@ -4,7 +4,7 @@ import { Endpoint } from "../route/endpoint.js";
 import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
 import { LLMEvent, Usage } from "../schema/index.js";
-import { ProviderShared } from "./shared.js";
+import { JsonObject, ProviderShared } from "./shared.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "cohere-chat";
@@ -41,7 +41,7 @@ const Body = Schema.Struct({
         function: Schema.Struct({
             name: Schema.String,
             description: Schema.optional(Schema.String),
-            parameters: Schema.Unknown,
+            parameters: JsonObject,
         }),
     }))),
     tool_choice: Schema.optional(Schema.Literals(["NONE", "REQUIRED"])),

package/dist/protocols/deepgram-speech.d.ts

@@ -16,14 +16,6 @@ export type DeepgramSpeechOptions = {
 } & Record<string, unknown>;
 export type Request = SpeechRequestFor<DeepgramSpeechOptions>;
 export declare const protocol: MediaProtocol.Streamed<Request, {
-    readonly type: "generation-queued";
-    readonly id: string;
-    readonly position?: number | undefined;
-} | {
-    readonly type: "generation-progress";
-    readonly id: string;
-    readonly progress?: number | undefined;
-} | {
     readonly type: "audio-delta";
     readonly chunk: Uint8Array<ArrayBufferLike>;
 } | {
@@ -33,18 +25,18 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
         readonly startSeconds: number;
         readonly endSeconds: number;
     }[];
+} | {
+    readonly type: "generation-queued";
+    readonly id: string;
+    readonly position?: number | undefined;
+} | {
+    readonly type: "generation-progress";
+    readonly id: string;
+    readonly progress?: number | undefined;
 } | {
     readonly type: "finish";
     readonly audio: import("../media.js").Asset;
     readonly usage?: {
-        readonly type: "tokens";
-        readonly input?: number | undefined;
-        readonly output?: number | undefined;
-        readonly total?: number | undefined;
-        readonly details?: {
-            readonly [x: string]: unknown;
-        } | undefined;
-    } | {
         readonly type: "seconds";
         readonly seconds: number;
     } | {
@@ -56,6 +48,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
     } | {
         readonly type: "compute";
         readonly seconds: number;
+    } | {
+        readonly type: "tokens";
+        readonly input?: number | undefined;
+        readonly output?: number | undefined;
+        readonly total?: number | undefined;
+        readonly details?: {
+            readonly [x: string]: unknown;
+        } | undefined;
     } | undefined;
     readonly notices?: readonly {
         readonly type: "filtered" | "moderated" | "other";
@@ -75,14 +75,6 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<DeepgramSpeechOptions>;
 export declare const DeepgramSpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
-        readonly type: "generation-queued";
-        readonly id: string;
-        readonly position?: number | undefined;
-    } | {
-        readonly type: "generation-progress";
-        readonly id: string;
-        readonly progress?: number | undefined;
-    } | {
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     } | {
@@ -92,18 +84,18 @@ export declare const DeepgramSpeech: {
             readonly startSeconds: number;
             readonly endSeconds: number;
         }[];
+    } | {
+        readonly type: "generation-queued";
+        readonly id: string;
+        readonly position?: number | undefined;
+    } | {
+        readonly type: "generation-progress";
+        readonly id: string;
+        readonly progress?: number | undefined;
     } | {
         readonly type: "finish";
         readonly audio: import("../media.js").Asset;
         readonly usage?: {
-            readonly type: "tokens";
-            readonly input?: number | undefined;
-            readonly output?: number | undefined;
-            readonly total?: number | undefined;
-            readonly details?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
             readonly type: "seconds";
             readonly seconds: number;
         } | {
@@ -115,6 +107,14 @@ export declare const DeepgramSpeech: {
         } | {
             readonly type: "compute";
             readonly seconds: number;
+        } | {
+            readonly type: "tokens";
+            readonly input?: number | undefined;
+            readonly output?: number | undefined;
+            readonly total?: number | undefined;
+            readonly details?: {
+                readonly [x: string]: unknown;
+            } | undefined;
         } | undefined;
         readonly notices?: readonly {
             readonly type: "filtered" | "moderated" | "other";

package/dist/protocols/elevenlabs-speech.d.ts

@@ -19,14 +19,6 @@ export type ElevenLabsSpeechOptions = {
 } & Record<string, unknown>;
 export type Request = SpeechRequestFor<ElevenLabsSpeechOptions>;
 export declare const protocol: MediaProtocol.Streamed<Request, {
-    readonly type: "generation-queued";
-    readonly id: string;
-    readonly position?: number | undefined;
-} | {
-    readonly type: "generation-progress";
-    readonly id: string;
-    readonly progress?: number | undefined;
-} | {
     readonly type: "audio-delta";
     readonly chunk: Uint8Array<ArrayBufferLike>;
 } | {
@@ -36,18 +28,18 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
         readonly startSeconds: number;
         readonly endSeconds: number;
     }[];
+} | {
+    readonly type: "generation-queued";
+    readonly id: string;
+    readonly position?: number | undefined;
+} | {
+    readonly type: "generation-progress";
+    readonly id: string;
+    readonly progress?: number | undefined;
 } | {
     readonly type: "finish";
     readonly audio: import("../media.js").Asset;
     readonly usage?: {
-        readonly type: "tokens";
-        readonly input?: number | undefined;
-        readonly output?: number | undefined;
-        readonly total?: number | undefined;
-        readonly details?: {
-            readonly [x: string]: unknown;
-        } | undefined;
-    } | {
         readonly type: "seconds";
         readonly seconds: number;
     } | {
@@ -59,6 +51,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
     } | {
         readonly type: "compute";
         readonly seconds: number;
+    } | {
+        readonly type: "tokens";
+        readonly input?: number | undefined;
+        readonly output?: number | undefined;
+        readonly total?: number | undefined;
+        readonly details?: {
+            readonly [x: string]: unknown;
+        } | undefined;
     } | undefined;
     readonly notices?: readonly {
         readonly type: "filtered" | "moderated" | "other";
@@ -78,14 +78,6 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<ElevenLabsSpeechOptions>;
 export declare const ElevenLabsSpeech: {
     readonly protocol: MediaProtocol.Streamed<Request, {
-        readonly type: "generation-queued";
-        readonly id: string;
-        readonly position?: number | undefined;
-    } | {
-        readonly type: "generation-progress";
-        readonly id: string;
-        readonly progress?: number | undefined;
-    } | {
         readonly type: "audio-delta";
         readonly chunk: Uint8Array<ArrayBufferLike>;
     } | {
@@ -95,18 +87,18 @@ export declare const ElevenLabsSpeech: {
             readonly startSeconds: number;
             readonly endSeconds: number;
         }[];
+    } | {
+        readonly type: "generation-queued";
+        readonly id: string;
+        readonly position?: number | undefined;
+    } | {
+        readonly type: "generation-progress";
+        readonly id: string;
+        readonly progress?: number | undefined;
     } | {
         readonly type: "finish";
         readonly audio: import("../media.js").Asset;
         readonly usage?: {
-            readonly type: "tokens";
-            readonly input?: number | undefined;
-            readonly output?: number | undefined;
-            readonly total?: number | undefined;
-            readonly details?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
             readonly type: "seconds";
             readonly seconds: number;
         } | {
@@ -118,6 +110,14 @@ export declare const ElevenLabsSpeech: {
         } | {
             readonly type: "compute";
             readonly seconds: number;
+        } | {
+            readonly type: "tokens";
+            readonly input?: number | undefined;
+            readonly output?: number | undefined;
+            readonly total?: number | undefined;
+            readonly details?: {
+                readonly [x: string]: unknown;
+            } | undefined;
         } | undefined;
         readonly notices?: readonly {
             readonly type: "filtered" | "moderated" | "other";

package/dist/protocols/gemini.d.ts

@@ -158,27 +158,10 @@ export declare const protocol: Protocol<{
     readonly contents: readonly {
         readonly role?: "model" | "user" | null | undefined;
         readonly parts?: readonly ({
-            readonly inlineData: {
-                readonly mimeType: string;
-                readonly data: string;
-            };
-            readonly thoughtSignature?: string | null | undefined;
-        } | {
-            readonly text: string;
-            readonly thought?: boolean | null | undefined;
-            readonly thoughtSignature?: string | null | undefined;
-        } | {
             readonly fileData: {
                 readonly mimeType: string;
                 readonly fileUri: string;
             };
-        } | {
-            readonly functionCall: {
-                readonly id?: string | null | undefined;
-                readonly name: string;
-                readonly args?: unknown;
-            };
-            readonly thoughtSignature?: string | null | undefined;
         } | {
             readonly functionResponse: {
                 readonly id?: string | undefined;
@@ -192,6 +175,23 @@ export declare const protocol: Protocol<{
                     readonly thoughtSignature?: string | null | undefined;
                 }[] | undefined;
             };
+        } | {
+            readonly text: string;
+            readonly thought?: boolean | null | undefined;
+            readonly thoughtSignature?: string | null | undefined;
+        } | {
+            readonly inlineData: {
+                readonly mimeType: string;
+                readonly data: string;
+            };
+            readonly thoughtSignature?: string | null | undefined;
+        } | {
+            readonly functionCall: {
+                readonly id?: string | null | undefined;
+                readonly name: string;
+                readonly args?: unknown;
+            };
+            readonly thoughtSignature?: string | null | undefined;
         })[] | null | undefined;
     }[];
     readonly labels?: {
@@ -239,7 +239,12 @@ export declare const protocol: Protocol<{
     } | undefined;
     readonly continuationToken?: string | undefined;
 }, NextRequest | {
-    readonly error?: unknown;
+    readonly error?: {
+        readonly [x: string]: unknown;
+        readonly code?: number | undefined;
+        readonly message?: string | undefined;
+        readonly status?: string | undefined;
+    } | undefined;
     readonly candidates?: readonly {
         readonly content?: {
             readonly role?: "model" | "user" | null | undefined;
@@ -261,7 +266,12 @@ export declare const protocol: Protocol<{
         readonly totalTokenCount?: number | null | undefined;
     } | null | undefined;
 }, NextRequest | {
-    readonly error?: unknown;
+    readonly error?: {
+        readonly [x: string]: unknown;
+        readonly code?: number | undefined;
+        readonly message?: string | undefined;
+        readonly status?: string | undefined;
+    } | undefined;
     readonly candidates?: readonly {
         readonly content?: {
             readonly role?: "model" | "user" | null | undefined;
@@ -288,27 +298,10 @@ export declare const route: Route<{
     readonly contents: readonly {
         readonly role?: "model" | "user" | null | undefined;
         readonly parts?: readonly ({
-            readonly inlineData: {
-                readonly mimeType: string;
-                readonly data: string;
-            };
-            readonly thoughtSignature?: string | null | undefined;
-        } | {
-            readonly text: string;
-            readonly thought?: boolean | null | undefined;
-            readonly thoughtSignature?: string | null | undefined;
-        } | {
             readonly fileData: {
                 readonly mimeType: string;
                 readonly fileUri: string;
             };
-        } | {
-            readonly functionCall: {
-                readonly id?: string | null | undefined;
-                readonly name: string;
-                readonly args?: unknown;
-            };
-            readonly thoughtSignature?: string | null | undefined;
         } | {
             readonly functionResponse: {
                 readonly id?: string | undefined;
@@ -322,6 +315,23 @@ export declare const route: Route<{
                     readonly thoughtSignature?: string | null | undefined;
                 }[] | undefined;
             };
+        } | {
+            readonly text: string;
+            readonly thought?: boolean | null | undefined;
+            readonly thoughtSignature?: string | null | undefined;
+        } | {
+            readonly inlineData: {
+                readonly mimeType: string;
+                readonly data: string;
+            };
+            readonly thoughtSignature?: string | null | undefined;
+        } | {
+            readonly functionCall: {
+                readonly id?: string | null | undefined;
+                readonly name: string;
+                readonly args?: unknown;
+            };
+            readonly thoughtSignature?: string | null | undefined;
         })[] | null | undefined;
     }[];
     readonly labels?: {

package/dist/protocols/gemini.js

@@ -182,8 +182,13 @@ const GeminiPromptFeedback = Schema.StructWithRest(Schema.Struct({
     blockReasonMessage: optionalNull(Schema.String),
     safetyRatings: optionalNull(Schema.Unknown),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
+const GeminiError = Schema.StructWithRest(Schema.Struct({
+    code: lenient(Schema.Number),
+    message: lenient(Schema.String),
+    status: lenient(Schema.String),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
 const GeminiEvent = Schema.Struct({
-    error: Schema.optional(Schema.Unknown),
+    error: Schema.optional(GeminiError),
     candidates: optionalNull(Schema.Array(GeminiCandidate)),
     promptFeedback: optionalNull(GeminiPromptFeedback),
     usageMetadata: optionalNull(GeminiUsage),
@@ -211,9 +216,7 @@ const lowerContentPart = Effect.fnUntraced(function* (part) {
 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;
+    return typeof value?.thoughtSignature === "string" ? value.thoughtSignature : undefined;
 };
 const lowerToolCall = (part, omitIds, metadataKey) => ({
     functionCall: { ...(omitIds ? {} : { id: part.id }), name: part.name, args: part.input },
@@ -221,7 +224,7 @@ const lowerToolCall = (part, omitIds, metadataKey) => ({
 });
 const lowerMessages = Effect.fnUntraced(function* (request) {
     const contents = [];
-    const metadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider);
+    const metadataKey = request.model.route.providerMetadataKey ?? request.model.provider;
     const omitCallIds = omitsFunctionCallIds(request.model.id);
     const legacyToolMedia = routesLegacyToolMedia(request.model.id);
     let pendingMedia;
@@ -511,22 +514,16 @@ const step = (state, event) => {
             },
             [],
         ]);
-    if (ProviderShared.isRecord(event.error)) {
+    if (event.error) {
         const body = ProviderShared.encodeJson(event);
         return Effect.fail(new AIError({
             reason: classifyProviderFailure({
-                message: typeof event.error.message === "string" && event.error.message.length > 0
-                    ? event.error.message
-                    : typeof event.error.status === "string" && event.error.status.length > 0
-                        ? event.error.status
-                        : "Gemini provider error",
-                status: typeof event.error.code === "number" ? event.error.code : undefined,
+                message: event.error.message || event.error.status || "Gemini provider error",
+                status: event.error.code,
                 rawBody: body,
             }),
         }));
     }
-    if ("error" in event)
-        return Effect.fail(ProviderShared.eventError(state.route, `Invalid ${state.route} stream event`, ProviderShared.encodeJson(event)));
     const candidate = event.candidates?.[0];
     const nextState = {
         ...state,
@@ -753,7 +750,7 @@ export const protocol = Protocol.make({
         event: Schema.Union([Schema.instanceOf(NextRequest), GeminiEvent]),
         initial: (request) => ({
             route: `${request.model.provider}/${request.model.route.id}`,
-            providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
+            providerMetadataKey: request.model.route.providerMetadataKey ?? request.model.provider,
             hasToolCalls: false,
             lifecycle: Lifecycle.initial(),
             nextReasoningId: 0,