@opencode/ai 2.0.17 → 2.0.19

package/dist/protocols/google-speech.js

@@ -49,9 +49,15 @@ const step = Effect.fn("GoogleSpeech.step")(function* (state, frame) {
         return yield* blocked;
     const audio = (chunk.candidates?.[0]?.content?.parts ?? []).flatMap((part) => part.inlineData === undefined ? [] : [part.inlineData]);
     const next = { ...GeminiGenerateContent.track(state, chunk), mimeType: state.mimeType ?? audio[0]?.mimeType };
-    return [next, audio.flatMap((part) => SpeechStream.delta(next, part.data)[1])];
+    const events = audio.flatMap((part) => SpeechStream.delta(next, part.data)[1]);
+    const withheld = next.chunks.length === 0 ? GeminiGenerateContent.withheld(route.name, chunk, frame) : undefined;
+    if (withheld !== undefined)
+        return yield* withheld;
+    return [next, events];
 });
 const finish = (state, context) => {
+    if (state.finishReason === undefined)
+        return Effect.fail(route.incomplete());
     const sampleRate = SpeechStream.sampleRate(state.mimeType) ?? DEFAULT_SAMPLE_RATE;
     const output = state.mimeType?.split(";")[0]?.toLowerCase() === "audio/wav"
         ? SpeechStream.container("wav", sampleRate)
@@ -61,8 +67,9 @@ const finish = (state, context) => {
     return SpeechStream.finish(route, state, {
         ...output,
         usage: GeminiGenerateContent.usage(state.usage),
+        notices: GeminiGenerateContent.notices(route.name, state),
         providerMetadata: GeminiGenerateContent.providerMetadata(state),
-        detail: state.finishReason === undefined ? undefined : `finish reason: ${state.finishReason}`,
+        detail: `finish reason: ${state.finishReason}`,
     });
 };
 // ---------------------------------------------------------------------------

package/dist/protocols/google-transcription.js

@@ -85,6 +85,9 @@ const step = Effect.fn("GoogleTranscription.step")(function* (state, frame) {
         .filter((item) => item.length > 0)
         .join(" ");
     const delta = text.length === 0 || state.text.length === 0 ? text : ` ${text}`;
+    const withheld = state.text.length + delta.length === 0 ? GeminiGenerateContent.withheld(route.name, chunk, frame) : undefined;
+    if (withheld !== undefined)
+        return yield* withheld;
     const events = [
         ...(delta.length === 0 ? [] : [TranscriptionTextDeltaEvent.make({ delta })]),
         ...segments.map((segment) => TranscriptionSegmentEvent.make({ segment })),
@@ -100,6 +103,7 @@ const finish = (state) => {
             segments: state.segments.length === 0 ? undefined : state.segments,
             words: state.words.length === 0 ? undefined : state.words,
             usage: GeminiGenerateContent.usage(state.usage),
+            notices: GeminiGenerateContent.notices(route.name, state),
             providerMetadata: GeminiGenerateContent.providerMetadata(state),
         }),
     ]);

package/dist/protocols/google-video.js

@@ -17,7 +17,7 @@ export const Token = Schema.Struct({ operation: Schema.String });
 const StartResponse = Schema.Struct({ name: Schema.String });
 const Operation = Schema.Struct({
     done: Schema.optional(Schema.Boolean),
-    error: Schema.optional(Schema.Struct({ message: Schema.optional(Schema.String) })),
+    error: Schema.optional(Schema.Struct({ code: Schema.optional(Schema.Number), message: Schema.optional(Schema.String) })),
     response: Schema.optional(Schema.Struct({
         generateVideoResponse: Schema.optional(Schema.Struct({
             generatedSamples: optionalArray(Schema.Struct({
@@ -32,6 +32,15 @@ const Operation = Schema.Struct({
     })),
     metadata: Schema.optional(Schema.Unknown),
 });
+// Operation errors are `google.rpc.Status`; unlisted codes (INTERNAL, UNAVAILABLE, ...) are provider-side.
+const FAILURE = {
+    3: "InvalidRequest", // INVALID_ARGUMENT
+    7: "Authentication", // PERMISSION_DENIED
+    8: "RateLimit", // RESOURCE_EXHAUSTED
+    9: "InvalidRequest", // FAILED_PRECONDITION
+    11: "InvalidRequest", // OUT_OF_RANGE
+    16: "Authentication", // UNAUTHENTICATED
+};
 // ---------------------------------------------------------------------------
 // 5. Request body construction
 // ---------------------------------------------------------------------------
@@ -92,7 +101,7 @@ const decodeResult = Effect.fn("GoogleVideo.decodeResult")(function* (response,
     if (status === "running")
         return yield* output.pending(context.token.operation);
     if (status === "failed")
-        return yield* output.ended("failed", `${route.name} operation failed${operation.error?.message === undefined ? "" : `: ${operation.error.message}`}`);
+        return yield* output.ended("failed", `${route.name} operation failed${operation.error?.message === undefined ? "" : `: ${operation.error.message}`}`, MediaProtocol.failure(FAILURE, operation.error?.code));
     const generated = operation.response?.generateVideoResponse;
     // Downloads require the same API key as the poll; the asset carries it transiently and follows the redirect.
     const videos = yield* Effect.forEach((generated?.generatedSamples ?? []).flatMap((sample) => sample.video?.uri === undefined ? [] : [{ uri: sample.video.uri, mimeType: sample.video.mimeType }]), (video) => MediaProtocol.expiringUrl(video.uri, FILE_RETENTION, {

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

@@ -12,6 +12,11 @@ declare const OpenAIChatCacheControl: Schema.Struct<{
     readonly type: Schema.Literal<"ephemeral">;
     readonly ttl: Schema.optional<Schema.String>;
 }>;
+declare const ExtraContent: Schema.Struct<{
+    readonly google: Schema.Struct<{
+        readonly thought_signature: Schema.String;
+    }>;
+}>;
 declare const ReasoningDetail: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
     readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
     readonly format: Schema.optional<Schema.String>;
@@ -97,6 +102,11 @@ export declare const bodyFields: {
                 readonly name: Schema.String;
                 readonly arguments: Schema.String;
             }>;
+            readonly extra_content: Schema.optional<Schema.Struct<{
+                readonly google: Schema.Struct<{
+                    readonly thought_signature: Schema.String;
+                }>;
+            }>>;
         }>>>;
         readonly reasoning_content: Schema.optional<Schema.String>;
         readonly reasoning: Schema.optional<Schema.String>;
@@ -205,6 +215,11 @@ declare const OpenAIChatBody: Schema.Struct<{
                 readonly name: Schema.String;
                 readonly arguments: Schema.String;
             }>;
+            readonly extra_content: Schema.optional<Schema.Struct<{
+                readonly google: Schema.Struct<{
+                    readonly thought_signature: Schema.String;
+                }>;
+            }>>;
         }>>>;
         readonly reasoning_content: Schema.optional<Schema.String>;
         readonly reasoning: Schema.optional<Schema.String>;
@@ -276,6 +291,7 @@ export declare const OpenAIChatEvent: Schema.StructWithRest<Schema.Struct<{
                     readonly name: Schema.optional<Schema.NullOr<Schema.String>>;
                     readonly arguments: Schema.optional<Schema.NullOr<Schema.String>>;
                 }>>>;
+                readonly extra_content: Schema.optional<Schema.NullOr<Schema.Unknown>>;
             }>>>>;
         }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
         readonly finish_reason: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -323,6 +339,7 @@ interface PendingToolDelta {
     readonly id?: string;
     readonly name?: string;
     readonly input: string;
+    readonly extraContent?: Schema.Schema.Type<typeof ExtraContent>;
 }
 export interface ParserState {
     readonly providerMetadataKey: string;
@@ -418,12 +435,17 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
@@ -527,12 +549,17 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
@@ -629,12 +656,17 @@ export declare const protocol: Protocol<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
@@ -725,6 +757,7 @@ export declare const protocol: Protocol<{
                 } | null | undefined;
                 readonly id?: string | null | undefined;
                 readonly index?: number | null | undefined;
+                readonly extra_content?: unknown;
             }[] | null | undefined;
             readonly reasoning_details?: unknown;
         } | null | undefined;
@@ -808,12 +841,17 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
@@ -919,12 +957,17 @@ export declare const route: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {

package/dist/protocols/openai-chat.js

@@ -41,6 +41,13 @@ const OpenAIChatTool = Schema.Struct({
     }),
     cache_control: Schema.optional(OpenAIChatCacheControl),
 });
+// Gemini's OpenAI-compatible surface carries thought signatures in tool call
+// `extra_content` and rejects replayed parallel calls without them:
+// https://ai.google.dev/gemini-api/docs/thinking#signatures
+const ExtraContent = Schema.Struct({
+    google: Schema.Struct({ thought_signature: Schema.String }),
+});
+const decodeExtraContent = (value) => Option.getOrUndefined(Schema.decodeUnknownOption(ExtraContent)(value));
 const OpenAIChatAssistantToolCall = Schema.Struct({
     id: Schema.String,
     type: Schema.tag("function"),
@@ -48,6 +55,7 @@ const OpenAIChatAssistantToolCall = Schema.Struct({
         name: Schema.String,
         arguments: Schema.String,
     }),
+    extra_content: Schema.optional(ExtraContent),
 });
 // `reasoning_details` carries two dialects. OpenRouter's `reasoning.*` entries
 // must be replayed unmodified (`index` included), so they keep every field they
@@ -75,11 +83,6 @@ const ReasoningDetail = Schema.Union([
 ]);
 const decodeReasoningDetail = Schema.decodeUnknownOption(ReasoningDetail);
 const knownReasoningDetails = (details) => details.flatMap((detail) => Option.toArray(decodeReasoningDetail(detail)));
-// Intentionally omit Gemini's provider-specific `extra_content.google.thought_signature`
-// extension until direct Google OpenAI-compatible routing is supported here:
-// https://github.com/vercel/ai/issues/11590
-// https://github.com/vercel/ai/pull/11745
-// https://ai.google.dev/gemini-api/docs/thought-signatures#openai
 const OpenAIChatUserContent = Schema.Union([
     Schema.Struct({
         type: Schema.Literal("text"),
@@ -180,6 +183,7 @@ const OpenAIChatToolCallDelta = Schema.Struct({
     index: optionalNull(Schema.Number),
     id: optionalNull(Schema.String),
     function: optionalNull(OpenAIChatToolCallDeltaFunction),
+    extra_content: optionalNull(Schema.Unknown),
 });
 const OpenAIChatDelta = Schema.StructWithRest(Schema.Struct({
     content: optionalNull(Schema.String),
@@ -231,6 +235,7 @@ const lowerToolCall = (part, options) => ({
         name: part.name,
         arguments: ProviderShared.encodeJson(part.input === undefined ? {} : part.input),
     },
+    extra_content: decodeExtraContent(part.providerMetadata?.[options.providerMetadataKey]?.extraContent),
 });
 const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part) {
     // Chat Completions accepts PDFs, and no other documents, as inline `file` parts; file URLs are not supported.
@@ -566,7 +571,9 @@ const detectSupportsStore = (provider, baseURL) => {
     const isVercelAiGateway = p === "vercel-ai-gateway" || url.includes("ai-gateway.vercel.sh") || url.includes("vercel.sh");
     const isAntLing = p === "ant-ling" || url.includes("api.ant-ling.com");
     const isOpencode = p === "opencode" || url.includes("opencode.ai");
-    const isNonStandard = isNvidia ||
+    const isGemini = url.includes("generativelanguage.googleapis.com");
+    const isNonStandard = isGemini ||
+        isNvidia ||
         isCerebras ||
         isXai ||
         isTogether ||
@@ -908,12 +915,13 @@ const step = (state, event) => Effect.gen(function* () {
         const id = current?.id ?? pending?.id ?? (tool.id || undefined);
         const name = current?.name ?? pending?.name ?? (tool.function?.name || undefined);
         const text = `${pending?.input ?? ""}${tool.function?.arguments ?? ""}`;
+        const extraContent = pending?.extraContent ?? decodeExtraContent(tool.extra_content);
         latestToolIndex = index;
         nextToolIndex = Math.max(nextToolIndex, index + 1);
         if (!current && (!id || !name)) {
             pendingTools = {
                 ...pendingTools,
-                [index]: { id: id || undefined, name: name || undefined, input: text },
+                [index]: { id: id || undefined, name: name || undefined, input: text, extraContent },
             };
             continue;
         }
@@ -921,7 +929,12 @@ const step = (state, event) => Effect.gen(function* () {
             pendingTools = { ...pendingTools };
             delete pendingTools[index];
         }
-        const result = ToolStream.appendOrStart(ADAPTER, tools, index, { id: id || undefined, name: name || undefined, text }, "OpenAI Chat tool call delta is missing id or name");
+        const result = ToolStream.appendOrStart(ADAPTER, tools, index, {
+            id: id || undefined,
+            name: name || undefined,
+            text,
+            providerMetadata: extraContent && { [state.providerMetadataKey]: { extraContent } },
+        }, "OpenAI Chat tool call delta is missing id or name");
         if (ToolStream.isError(result))
             return yield* new AIError({
                 reason: AIErrorReason.make({

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

@@ -63,12 +63,17 @@ export declare const route: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {

package/dist/protocols/openai-speech.js

@@ -30,10 +30,13 @@ const decodeEvent = route.decodeFrame(SpeechStreamEvent);
 // ---------------------------------------------------------------------------
 // `sse` is not supported for `tts-1` or `tts-1-hd`; those models stream the raw audio body instead.
 const supportsSse = (model) => !/^tts-1(-hd)?(-|$)/.test(model);
+const FORMATS = new Set(["mp3", "opus", "aac", "flac", "wav", "pcm"]);
 const fromRequest = Effect.fn("OpenAISpeech.fromRequest")(function* (request) {
     // Not in `unsupported`: that list would also reject `timestamps: false`, which asks for nothing.
     if (request.timestamps === true)
         return yield* route.unsupported("media.timestamps", `${route.name} does not return timestamps`);
+    if (request.format !== undefined && !FORMATS.has(request.format))
+        return yield* route.unsupported("media.format", `${route.name} supports the mp3, opus, aac, flac, wav, and pcm formats, not "${request.format}"`);
     return MediaProtocol.json(mergeJsonRecords({
         model: request.model.id,
         input: request.text,
@@ -73,7 +76,9 @@ const onEvent = Effect.fn("OpenAISpeech.onEvent")(function* (state, frame) {
 const finish = (state, context) => {
     if (isSse(context.body) && !state.done)
         return Effect.fail(route.incomplete());
-    const format = context.request.format ?? "mp3";
+    // The sent body reflects `providerOptions` and `http.body` overrides of `format`.
+    const sent = context.body.type === "json" ? context.body.value.response_format : undefined;
+    const format = typeof sent === "string" ? sent : "mp3";
     return SpeechStream.finish(route, state, {
         ...(format === "pcm" ? SpeechStream.pcm("pcm_s16le", PCM_SAMPLE_RATE) : SpeechStream.container(format)),
         usage: state.usage,

package/dist/protocols/openai-transcription.js

@@ -118,7 +118,7 @@ const fromRequest = Effect.fn("OpenAITranscription.fromRequest")(function* (requ
     }, {
         overlay: mergeJsonRecords(request.providerOptions, request.http?.body),
         reserved: RESERVED_FORM_FIELDS,
-        repeatArrays: true,
+        repeatArrays: "key[]",
     });
     return MediaProtocol.multipart(form);
 });

package/dist/protocols/runway-video.js

@@ -89,7 +89,8 @@ const decodeResult = Effect.fn("RunwayVideo.decodeResult")(function* (response,
         // Runway failure codes are dotted paths; every moderation outcome carries a SAFETY segment.
         if (code !== undefined && /(^|\.)SAFETY(\.|$)/.test(code))
             return yield* output.contentPolicy(message);
-        return yield* output.ended("failed", message);
+        // ASSET.INVALID rejects the caller's input media; Runway documents it as not retryable.
+        return yield* output.ended("failed", message, code !== undefined && /^ASSET\.INVALID(\.|$)/.test(code) ? "InvalidRequest" : "ProviderInternal");
     }
     if (status === "cancelled")
         return yield* output.ended("cancelled", `${route.name} task ${context.token.taskID} was cancelled`);

package/dist/protocols/utils/gemini-generate-content.d.ts

@@ -47,6 +47,12 @@ export interface Metadata {
 }
 export declare const track: <State extends Metadata>(state: State, chunk: Chunk) => State;
 export declare const blocked: (name: string, chunk: Chunk, frame: string) => AIError | undefined;
+/** Finish reasons for which Gemini stops output on safety or policy grounds. */
+export declare const contentFiltered: (finishReason: string | undefined) => boolean;
+/** Callers check that the response produced no output: a policy stop after output is a partial result instead. */
+export declare const withheld: (name: string, chunk: Chunk, frame: string) => AIError | undefined;
+/** Any finish reason other than `STOP` means the output may be cut short, so it is surfaced rather than dropped. */
+export declare const notices: (name: string, state: Metadata) => ReadonlyArray<Media.Notice> | undefined;
 export declare const usage: (usage: UsageMetadata | undefined) => MediaUsage | undefined;
 export declare const providerMetadata: (state: Metadata) => ProviderMetadata;
 export declare const path: (model: string, mode: MediaProtocol.Mode) => string;

package/dist/protocols/utils/gemini-generate-content.js

@@ -40,6 +40,39 @@ export const blocked = (name, chunk, frame) => {
         }),
     });
 };
+const CONTENT_FILTER_REASONS = new Set([
+    "IMAGE_SAFETY",
+    "RECITATION",
+    "SAFETY",
+    "BLOCKLIST",
+    "PROHIBITED_CONTENT",
+    "SPII",
+    "MODEL_ARMOR",
+    "IMAGE_PROHIBITED_CONTENT",
+    "IMAGE_RECITATION",
+    "LANGUAGE",
+]);
+/** Finish reasons for which Gemini stops output on safety or policy grounds. */
+export const contentFiltered = (finishReason) => finishReason !== undefined && CONTENT_FILTER_REASONS.has(finishReason);
+/** Callers check that the response produced no output: a policy stop after output is a partial result instead. */
+export const withheld = (name, chunk, frame) => {
+    const finishReason = chunk.candidates?.[0]?.finishReason;
+    if (!contentFiltered(finishReason))
+        return undefined;
+    return new AIError({
+        reason: new ContentPolicyError({ message: `${name} withheld its output (${finishReason})`, body: frame }),
+    });
+};
+/** Any finish reason other than `STOP` means the output may be cut short, so it is surfaced rather than dropped. */
+export const notices = (name, state) => state.finishReason === undefined || state.finishReason === "STOP"
+    ? undefined
+    : [
+        {
+            type: contentFiltered(state.finishReason) ? "filtered" : "other",
+            message: `${name} finished with ${state.finishReason}`,
+            providerMetadata: { google: { finishReason: state.finishReason } },
+        },
+    ];
 export const usage = (usage) => usage === undefined
     ? undefined
     : {

package/dist/protocols/utils/media-input.d.ts

@@ -21,12 +21,13 @@ export declare const imageOutput: (invalid: (message: string, cause?: unknown) =
     readonly url?: string | null;
 }, mediaType: string | undefined, options?: Media.AssetOptions) => Effect.Effect<Media.Asset, AIError, never>;
 /**
- * Append multipart text fields: strings as-is, other values as JSON, or arrays as repeated `key[]` parts with
- * `repeatArrays`. `overlay` keys in `reserved` are dropped so `http.body` cannot replace route-owned fields.
+ * Append multipart text fields: strings as-is, other values as JSON, or scalar arrays as one part per item with
+ * `repeatArrays`, named `key[]` or `key`. `overlay` keys in `reserved` are dropped so `http.body` cannot replace
+ * route-owned fields.
  */
 export declare const appendFields: (form: FormData, fields: Record<string, unknown>, options: {
     readonly overlay?: Record<string, unknown>;
     readonly reserved: ReadonlySet<string>;
-    readonly repeatArrays?: true;
+    readonly repeatArrays?: "key[]" | "key";
 }) => void;
 export * as MediaInput from "./media-input.js";

package/dist/protocols/utils/media-input.js

@@ -43,14 +43,15 @@ export const imageOutput = (invalid, label, item, mediaType, options) => {
     return Effect.fail(invalid(`${label} has neither image data nor a URL`));
 };
 /**
- * Append multipart text fields: strings as-is, other values as JSON, or arrays as repeated `key[]` parts with
- * `repeatArrays`. `overlay` keys in `reserved` are dropped so `http.body` cannot replace route-owned fields.
+ * Append multipart text fields: strings as-is, other values as JSON, or scalar arrays as one part per item with
+ * `repeatArrays`, named `key[]` or `key`. `overlay` keys in `reserved` are dropped so `http.body` cannot replace
+ * route-owned fields.
  */
 export const appendFields = (form, fields, options) => {
     const overlay = Object.entries(options.overlay ?? {}).filter(([key]) => !options.reserved.has(key));
     Object.entries(mergeJsonRecords(fields, Object.fromEntries(overlay)) ?? {}).forEach(([key, value]) => {
-        if (Array.isArray(value) && options.repeatArrays)
-            return value.forEach((item) => form.append(`${key}[]`, String(item)));
+        if (Array.isArray(value) && value.every(isScalar) && options.repeatArrays !== undefined)
+            return value.forEach((item) => form.append(options.repeatArrays === "key[]" ? `${key}[]` : key, String(item)));
         form.append(key, typeof value === "string" ? value : encodeJson(value));
     });
 };

package/dist/protocols/utils/speaker-turns.d.ts

@@ -0,0 +1,3 @@
+/** Split an ordered token list into runs of consecutive tokens with the same speaker. */
+export declare const group: <Item>(items: ReadonlyArray<Item>, speaker: (item: Item) => unknown) => Item[][];
+export * as SpeakerTurns from "./speaker-turns.js";

package/dist/protocols/utils/speaker-turns.js

@@ -0,0 +1,9 @@
+/** Split an ordered token list into runs of consecutive tokens with the same speaker. */
+export const group = (items, speaker) => items.reduce((turns, item) => {
+    const last = turns.at(-1);
+    if (last === undefined || speaker(last[0]) !== speaker(item))
+        return [...turns, [item]];
+    last.push(item);
+    return turns;
+}, []);
+export * as SpeakerTurns from "./speaker-turns.js";

package/dist/protocols/utils/speech-stream.d.ts

@@ -42,6 +42,7 @@ export declare const finish: (route: MediaProtocol.Identity, state: Audio, outpu
     readonly mediaType: string | undefined;
     readonly info?: Media.Info;
     readonly usage?: MediaUsage;
+    readonly notices?: ReadonlyArray<Media.Notice>;
     readonly providerMetadata?: ProviderMetadata;
     readonly detail?: string;
 }) => Effect.Effect<ReadonlyArray<SpeechEvent>, AIError>;

package/dist/protocols/utils/speech-stream.js

@@ -51,6 +51,7 @@ export const finish = (route, state, output) => {
         SpeechFinishEvent.make({
             audio: Media.bytes(concatBytes(state.chunks), output.mediaType, { info: output.info }),
             usage: output.usage,
+            notices: output.notices,
             providerMetadata: output.providerMetadata,
         }),
     ]);

package/dist/protocols/utils/tool-stream.d.ts

@@ -52,6 +52,7 @@ export declare const appendOrStart: <K extends StreamKey>(route: string, tools:
     readonly id?: string;
     readonly name?: string;
     readonly text: string;
+    readonly providerMetadata?: ProviderMetadata;
 }, missingToolMessage: string) => AppendOutcome<K> | AIError;
 /**
  * Append argument text to a started tool. Returns `undefined` when no tool is

package/dist/protocols/utils/tool-stream.js

@@ -87,7 +87,7 @@ export const appendOrStart = (route, tools, key, delta, missingToolMessage) => {
         namespace: current?.namespace,
         input: `${current?.input ?? ""}${delta.text}`,
         providerExecuted: current?.providerExecuted,
-        providerMetadata: current?.providerMetadata,
+        providerMetadata: current?.providerMetadata ?? delta.providerMetadata,
     };
     if (current && delta.text.length === 0 && current.id === id && current.name === name)
         return { tools, tool: current, events: [] };

package/dist/protocols/xai-video.js

@@ -36,6 +36,12 @@ const STATUS = {
     failed: "failed",
     expired: "expired",
 };
+// Documented video error codes; `service_unavailable`, `internal_error`, and unknown codes are provider-side.
+const FAILURE = {
+    invalid_argument: "InvalidRequest",
+    failed_precondition: "InvalidRequest",
+    permission_denied: "Authentication",
+};
 // ---------------------------------------------------------------------------
 // 5. Request body construction
 // ---------------------------------------------------------------------------
@@ -88,7 +94,7 @@ const decodeResult = Effect.fn("XAIVideo.decodeResult")(function* (response, con
     if (status === "failed") {
         const code = decoded.error?.code ?? undefined;
         const message = decoded.error?.message ?? undefined;
-        return yield* output.ended("failed", `${route.name} generation failed${code === undefined ? "" : ` (${code})`}${message === undefined ? "" : `: ${message}`}`);
+        return yield* output.ended("failed", `${route.name} generation failed${code === undefined ? "" : ` (${code})`}${message === undefined ? "" : `: ${message}`}`, MediaProtocol.failure(FAILURE, code));
     }
     if (status !== "completed")
         return yield* output.ended("expired", `${route.name} request ${context.token.requestID} expired`);

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

@@ -79,12 +79,17 @@ export declare const protocol: Protocol<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
@@ -185,6 +190,7 @@ export declare const protocol: Protocol<{
                 } | null | undefined;
                 readonly id?: string | null | undefined;
                 readonly index?: number | null | undefined;
+                readonly extra_content?: unknown;
             }[] | null | undefined;
             readonly reasoning_details?: unknown;
         } | null | undefined;

package/dist/provider-error.d.ts

@@ -2,6 +2,11 @@ import { AIError, type HttpContext, type HttpRateLimitDetails } from "./schema/i
 export declare const isContextOverflow: (message: string) => boolean;
 export declare const isPayloadTooLarge: (message: string) => boolean;
 export declare const isContextOverflowFailure: (failure: unknown) => boolean;
+/**
+ * Whether a failed call may succeed when sent again: rate limits, provider-side failures, transport failures that did
+ * not deliver an accepted write, and unrecognized failures. Callers decide which calls are safe to repeat.
+ */
+export declare const isRetryable: (error: AIError) => boolean;
 export interface ProviderFailure {
     readonly message: string;
     readonly status?: number | undefined;