@opencode/ai 2.0.18 → 2.0.20

package/dist/protocols/deepgram-speech.js

@@ -50,23 +50,25 @@ const fromRequest = Effect.fn("DeepgramSpeech.fromRequest")(function* (request)
 // ---------------------------------------------------------------------------
 // 6. Stream parsing
 // ---------------------------------------------------------------------------
+/** Deepgram wraps raw encodings in WAV unless `container` is `none`, and defaults their sample rate per encoding. */
 const HEADERLESS_ENCODINGS = {
-    linear16: "pcm_s16le",
-    mulaw: "pcm_mulaw",
-    alaw: "pcm_alaw",
+    linear16: { encoding: "pcm_s16le", sampleRate: 24000 },
+    mulaw: { encoding: "pcm_mulaw", sampleRate: 8000 },
+    alaw: { encoding: "pcm_alaw", sampleRate: 8000 },
 };
 const finish = (state, context) => {
     const headers = context.http.headers;
     const mediaType = headers["content-type"];
     const format = audioFormat(context.request);
-    const encoding = HEADERLESS_ENCODINGS[format.encoding ?? ""];
+    const headerless = HEADERLESS_ENCODINGS[format.encoding ?? ""];
+    const container = format.container ?? (headerless === undefined ? undefined : "wav");
     const requestID = headers["dg-request-id"];
     const modelName = headers["dg-model-name"];
     return SpeechStream.finish(route, state, {
-        ...(format.container === "none" && encoding !== undefined
-            ? SpeechStream.pcm(encoding, SpeechStream.sampleRate(mediaType), mediaType)
+        ...(container === "none" && headerless !== undefined
+            ? SpeechStream.pcm(headerless.encoding, SpeechStream.sampleRate(mediaType) ?? context.request.providerOptions?.sampleRate ?? headerless.sampleRate, mediaType)
             : // Deepgram's default encoding is MP3; WAV is a container around any encoding.
-                { mediaType, info: { format: format.container === "wav" ? "wav" : (format.encoding ?? "mp3") } }),
+                { mediaType, info: { format: container === "wav" ? "wav" : (format.encoding ?? "mp3") } }),
         usage: SpeechStream.headerUsage("characters", headers["dg-char-count"]),
         providerMetadata: requestID === undefined && modelName === undefined
             ? undefined

package/dist/protocols/deepgram-transcription.js

@@ -5,6 +5,7 @@ import { mergeJsonRecords } from "../schema/index.js";
 import { TranscriptionModel, TranscriptionResponse } from "../transcription.js";
 import { ProviderShared } from "./shared.js";
 import { MediaInput } from "./utils/media-input.js";
+import { SpeakerTurns } from "./utils/speaker-turns.js";
 const route = MediaProtocol.identity({ id: "deepgram-transcription", name: "Deepgram", provider: "deepgram" });
 export const DEFAULT_BASE_URL = "https://api.deepgram.com";
 export const PATH = "/v1/listen";
@@ -63,15 +64,6 @@ const fromRequest = Effect.fn("DeepgramTranscription.fromRequest")(function* (re
 const decodeListen = route.decodeJson(ListenResponse);
 const speaker = (value) => (value === undefined ? undefined : String(value));
 const wordText = (word) => word.punctuated_word ?? word.word;
-// Utterances split on pauses, not speakers: the v2 diarizer labels a whole utterance with one speaker even when its
-// words change speaker, so segments split each utterance at speaker changes.
-const speakerTurns = (words) => words.reduce((turns, word) => {
-    const last = turns.at(-1);
-    if (last === undefined || last[0].speaker !== word.speaker)
-        return [...turns, [word]];
-    last.push(word);
-    return turns;
-}, []);
 const decodeResponse = Effect.fn("DeepgramTranscription.decodeResponse")(function* (response) {
     const output = yield* decodeListen(response);
     const channel = output.value.results.channels[0];
@@ -82,6 +74,8 @@ const decodeResponse = Effect.fn("DeepgramTranscription.decodeResponse")(functio
     const requestID = output.value.metadata?.request_id;
     return new TranscriptionResponse({
         text: alternative.transcript,
+        // Utterances split on pauses, not speakers: the v2 diarizer labels a whole utterance with one speaker even when
+        // its words change speaker, so segments split each utterance at speaker changes.
         segments: output.value.results.utterances?.flatMap((utterance) => utterance.words === undefined || utterance.words.length === 0
             ? [
                 {
@@ -91,7 +85,7 @@ const decodeResponse = Effect.fn("DeepgramTranscription.decodeResponse")(functio
                     speaker: speaker(utterance.speaker),
                 },
             ]
-            : speakerTurns(utterance.words).map((turn) => ({
+            : SpeakerTurns.group(utterance.words, (word) => word.speaker).map((turn) => ({
                 text: turn.map(wordText).join(" "),
                 startSeconds: turn[0].start,
                 endSeconds: turn[turn.length - 1].end,

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

@@ -0,0 +1,28 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
+import { TranscriptionModel, TranscriptionResponse, type TranscriptionRequestFor } from "../transcription.js";
+export declare const DEFAULT_BASE_URL = "https://api.elevenlabs.io";
+export declare const PATH = "/v1/speech-to-text";
+export type ElevenLabsTranscriptionOptions = {
+    readonly tag_audio_events?: boolean;
+    readonly timestamps_granularity?: OpenString<"none" | "word" | "character">;
+    readonly diarization_threshold?: number;
+    readonly file_format?: OpenString<"pcm_s16le_16" | "other">;
+    readonly temperature?: number;
+    readonly seed?: number;
+    readonly keyterms?: ReadonlyArray<string>;
+    readonly no_verbatim?: boolean;
+    readonly detect_speaker_roles?: boolean;
+    readonly use_speaker_library?: boolean;
+    readonly entity_detection?: string | ReadonlyArray<string>;
+    readonly entity_redaction?: string | ReadonlyArray<string>;
+    readonly entity_redaction_mode?: OpenString<"redacted" | "entity_type" | "enumerated_entity_type">;
+} & Record<string, unknown>;
+export type Request = TranscriptionRequestFor<ElevenLabsTranscriptionOptions>;
+export declare const protocol: MediaProtocol.Inline<Request, TranscriptionResponse>;
+export declare const model: (input: MediaRoute.ModelInput) => TranscriptionModel<ElevenLabsTranscriptionOptions>;
+export declare const ElevenLabsTranscription: {
+    readonly protocol: MediaProtocol.Inline<Request, TranscriptionResponse>;
+    readonly model: (input: MediaRoute.ModelInput) => TranscriptionModel<ElevenLabsTranscriptionOptions>;
+};

package/dist/protocols/elevenlabs-transcription.js

@@ -0,0 +1,137 @@
+import { Effect, Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { mergeJsonRecords } from "../schema/index.js";
+import { TranscriptionModel, TranscriptionResponse } from "../transcription.js";
+import { mediaTypeExtension } from "../utils/media-type.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+import { MediaInput } from "./utils/media-input.js";
+import { SpeakerTurns } from "./utils/speaker-turns.js";
+const route = MediaProtocol.identity({
+    id: "elevenlabs-transcription",
+    name: "ElevenLabs Transcription",
+    provider: "elevenlabs",
+});
+export const DEFAULT_BASE_URL = "https://api.elevenlabs.io";
+export const PATH = "/v1/speech-to-text";
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------
+/** `type` is `word`, `spacing` (the whitespace between words), or `audio_event` (`(laughter)`). */
+const Token = Schema.Struct({
+    text: Schema.String,
+    type: Schema.String,
+    start: optionalNull(Schema.Number),
+    end: optionalNull(Schema.Number),
+    speaker_id: optionalNull(Schema.String),
+    logprob: optionalNull(Schema.Number),
+});
+const Transcript = Schema.Struct({
+    language_code: optionalNull(Schema.String),
+    text: Schema.String,
+    words: optionalNull(Schema.Array(Token)),
+    transcription_id: optionalNull(Schema.String),
+    audio_duration_secs: optionalNull(Schema.Number),
+});
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+/** Speaker turns are the only segments ElevenLabs can produce, and `num_speakers` only applies to diarization. */
+const diarizes = (request) => request.diarize === true || request.timestamps === "segment" || request.speakers !== undefined;
+const RESERVED_FORM_FIELDS = new Set([
+    "file",
+    "cloud_storage_url",
+    "source_url",
+    "model_id",
+    "language_code",
+    "diarize",
+    "num_speakers",
+]);
+const validate = (request, overlay) => {
+    // Webhook requests return 202 with no transcript; the result arrives at a configured webhook instead.
+    if (overlay.webhook === true)
+        return Effect.fail(route.unsupported("transcription.webhook", `${route.name} does not deliver to webhooks`));
+    // Separate multichannel output replaces the transcript with one transcript per channel.
+    if (overlay.use_multi_channel === true && overlay.multichannel_output_style !== "combined")
+        return Effect.fail(route.unsupported("transcription.multichannel", `${route.name} returns a single transcript; set multichannel_output_style: "combined" to merge channels`));
+    if (overlay.timestamps_granularity === "none" && (request.timestamps === "word" || diarizes(request)))
+        return Effect.fail(route.unsupported("media.timestamps", `${route.name} cannot return word timestamps or speaker turns with timestamps_granularity: "none"`));
+    return Effect.void;
+};
+const fromRequest = Effect.fn("ElevenLabsTranscription.fromRequest")(function* (request) {
+    const overlay = mergeJsonRecords(request.providerOptions, request.http?.body) ?? {};
+    yield* validate(request, overlay);
+    const form = new FormData();
+    const url = ProviderShared.mediaUrl(request.audio);
+    if (url === undefined) {
+        const extension = mediaTypeExtension(request.audio.mediaType);
+        const audio = yield* MediaInput.inlineBytes(route.id, request.audio);
+        form.append("file", MediaInput.blob(audio, request.audio.mediaType), extension === undefined ? "audio" : `audio.${extension}`);
+    }
+    MediaInput.appendFields(form, {
+        model_id: request.model.id,
+        // `cloud_storage_url` is deprecated in favor of `source_url`, which accepts any hosted audio or video URL.
+        source_url: url,
+        language_code: request.language,
+        diarize: diarizes(request) ? true : undefined,
+        num_speakers: request.speakers,
+    }, { overlay, reserved: RESERVED_FORM_FIELDS, repeatArrays: "key" });
+    return MediaProtocol.multipart(form);
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeTranscript = route.decodeJson(Transcript);
+const isTimedWord = (token) => token.type === "word" && typeof token.start === "number" && typeof token.end === "number";
+/** Turn text keeps the provider's own spacing tokens, so languages written without spaces are not re-spaced. */
+const speakerTurns = (tokens) => SpeakerTurns.group(tokens.filter((token) => token.type === "word" || token.type === "spacing"), (token) => token.speaker_id).flatMap((turn) => {
+    const words = turn.filter(isTimedWord);
+    if (words.length === 0)
+        return [];
+    return [
+        {
+            text: turn
+                .map((token) => token.text)
+                .join("")
+                .trim(),
+            startSeconds: words[0].start,
+            endSeconds: words[words.length - 1].end,
+            speaker: turn[0].speaker_id ?? undefined,
+        },
+    ];
+});
+const decodeResponse = Effect.fn("ElevenLabsTranscription.decodeResponse")(function* (response, context) {
+    const output = yield* decodeTranscript(response);
+    const transcript = output.value;
+    const tokens = transcript.words ?? [];
+    const duration = transcript.audio_duration_secs ?? undefined;
+    const transcriptionID = transcript.transcription_id ?? undefined;
+    return new TranscriptionResponse({
+        text: transcript.text,
+        segments: diarizes(context.request) ? speakerTurns(tokens) : undefined,
+        words: tokens.filter(isTimedWord).map((word) => ({
+            text: word.text,
+            startSeconds: word.start,
+            endSeconds: word.end,
+            speaker: word.speaker_id ?? undefined,
+            confidence: typeof word.logprob === "number" ? Math.exp(word.logprob) : undefined,
+        })),
+        language: transcript.language_code?.toLowerCase(),
+        durationSeconds: duration,
+        usage: duration === undefined ? undefined : { type: "seconds", seconds: duration },
+        providerMetadata: transcriptionID === undefined ? undefined : { elevenlabs: { transcriptionId: transcriptionID } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.inline(route, {
+    unsupported: ["prompt"],
+    body: { from: fromRequest },
+    response: { decode: decodeResponse },
+});
+export const model = (input) => TranscriptionModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const ElevenLabsTranscription = {
+    protocol,
+    model,
+};

package/dist/protocols/gemini.js

@@ -435,16 +435,7 @@ const mapFinishReason = (finishReason, hasToolCalls) => {
         return hasToolCalls ? "tool-calls" : "stop";
     if (finishReason === "MAX_TOKENS")
         return "length";
-    if (finishReason === "IMAGE_SAFETY" ||
-        finishReason === "RECITATION" ||
-        finishReason === "SAFETY" ||
-        finishReason === "BLOCKLIST" ||
-        finishReason === "PROHIBITED_CONTENT" ||
-        finishReason === "SPII" ||
-        finishReason === "MODEL_ARMOR" ||
-        finishReason === "IMAGE_PROHIBITED_CONTENT" ||
-        finishReason === "IMAGE_RECITATION" ||
-        finishReason === "LANGUAGE")
+    if (GeminiGenerateContent.contentFiltered(finishReason))
         return "content-filter";
     if (finishReason === "MALFORMED_FUNCTION_CALL" ||
         finishReason === "UNEXPECTED_TOOL_CALL" ||

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/meta-messages.d.ts

@@ -203,11 +203,15 @@ export declare const protocol: Protocol<{
             readonly timezone?: string | undefined;
         } | undefined;
     } | {
-        readonly name: string;
         readonly description: string;
+        readonly name: string;
         readonly input_schema: {
             readonly [x: string]: unknown;
         };
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: "1h" | "5m" | undefined;
+        } | undefined;
     })[] | undefined;
     readonly system?: readonly {
         readonly type: "text";

package/dist/protocols/meta-messages.js

@@ -8,12 +8,19 @@ const WebSearch = Schema.Struct({
     name: Schema.Literal("web_search"),
     user_location: MetaResponses.WebSearch.fields.user_location,
 });
+const MetaCacheControl = Schema.Struct({
+    type: Schema.tag("ephemeral"),
+    ttl: Schema.optional(Schema.Literals(["5m", "1h"])),
+});
+const FunctionTool = Schema.Struct({
+    name: Schema.String,
+    description: Schema.String,
+    input_schema: JsonObject,
+    cache_control: Schema.optional(MetaCacheControl),
+});
 const Body = Schema.Struct({
     ...AnthropicMessages.AnthropicMessagesBody.fields,
-    tools: optionalArray(Schema.Union([
-        Schema.Struct({ name: Schema.String, description: Schema.String, input_schema: JsonObject }),
-        WebSearch,
-    ])),
+    tools: optionalArray(Schema.Union([FunctionTool, WebSearch])),
 });
 const fromRequest = Effect.fn("MetaMessages.fromRequest")(function* (request) {
     const projected = ProviderShared.flattenToolRequest(request);

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

@@ -92,8 +92,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -129,8 +129,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -219,21 +219,10 @@ export declare const protocol: Protocol<{
     readonly [x: string]: unknown;
     readonly type: string;
     readonly status?: unknown;
-    readonly code?: unknown;
     readonly message?: unknown;
+    readonly code?: unknown;
     readonly text?: string | undefined;
     readonly error?: unknown;
-    readonly item?: {
-        readonly [x: string]: unknown;
-        readonly type: string;
-        readonly id?: string | undefined;
-        readonly name?: string | undefined;
-        readonly namespace?: string | undefined;
-        readonly arguments?: string | undefined;
-        readonly encrypted_content?: string | null | undefined;
-        readonly call_id?: string | undefined;
-    } | null | undefined;
-    readonly delta?: string | undefined;
     readonly response?: {
         readonly [x: string]: unknown;
         readonly id?: string | undefined;
@@ -265,6 +254,17 @@ export declare const protocol: Protocol<{
             readonly reason?: string | undefined;
         } | null | undefined;
     } | undefined;
+    readonly item?: {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id?: string | undefined;
+        readonly name?: string | undefined;
+        readonly namespace?: string | undefined;
+        readonly arguments?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+        readonly call_id?: string | undefined;
+    } | null | undefined;
+    readonly delta?: string | undefined;
     readonly arguments?: string | undefined;
     readonly item_id?: string | undefined;
     readonly output_index?: number | undefined;
@@ -338,8 +338,8 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -375,8 +375,8 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";

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

@@ -8,6 +8,11 @@ import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolStream } from "./utils/tool-stream.js";
 export declare const DEFAULT_BASE_URL = "https://api.mistral.ai/v1";
 export declare const PATH = "/chat/completions";
+declare const MistralThinkingUnit: Schema.StructWithRest<Schema.Struct<{
+    readonly type: Schema.optional<Schema.String>;
+    readonly text: Schema.optional<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+type MistralThinkingUnit = Schema.Schema.Type<typeof MistralThinkingUnit>;
 declare const MistralThinkingContent: Schema.StructWithRest<Schema.Struct<{
     readonly type: Schema.Literal<"thinking">;
     readonly thinking: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
@@ -212,6 +217,7 @@ interface ActiveContent {
     readonly type: "text" | "reasoning";
     readonly id: string;
     readonly thinking?: MistralThinkingContent;
+    readonly thinkingUnits?: MistralThinkingUnit[];
 }
 export interface ParserState {
     readonly tools: ToolStream.State<ToolKey>;

package/dist/protocols/mistral-chat.js

@@ -365,7 +365,7 @@ const closeActive = (state, events) => {
         return state;
     const lifecycle = state.active.type === "text"
         ? Lifecycle.textEnd(state.lifecycle, events, state.active.id)
-        : Lifecycle.reasoningEnd(state.lifecycle, events, state.active.id, thinkingMetadata(state.active.thinking ?? { type: "thinking", thinking: [] }), thinkingText(state.active.thinking?.thinking ?? []));
+        : Lifecycle.reasoningEnd(state.lifecycle, events, state.active.id, thinkingMetadata({ ...state.active.thinking, type: "thinking", thinking: state.active.thinkingUnits ?? [] }), thinkingText(state.active.thinkingUnits ?? []));
     return { ...state, lifecycle, active: undefined };
 };
 const appendText = (state, events, text) => {
@@ -384,19 +384,22 @@ const appendThinking = (state, events, part) => {
     const current = state.active?.type === "reasoning" ? state : closeActive(state, events);
     const units = thinkingUnits(part.thinking);
     const active = current.active ?? { type: "reasoning", id: `reasoning-${current.nextContent}` };
+    // Keep native units out of streamed events until the block is complete.
+    const accumulated = active.thinkingUnits ?? [];
+    accumulated.push(...units);
     const thinking = {
         ...active.thinking,
         ...part,
         type: "thinking",
-        thinking: [...(active.thinking?.thinking ?? []), ...units],
+        thinking: [],
     };
     const text = thinkingText(units);
     return {
         ...current,
         lifecycle: text.length > 0
-            ? Lifecycle.reasoningDelta(current.lifecycle, events, active.id, text, thinkingMetadata(thinking))
-            : Lifecycle.reasoningStart(current.lifecycle, events, active.id, thinkingMetadata(thinking)),
-        active: { ...active, thinking },
+            ? Lifecycle.reasoningDelta(current.lifecycle, events, active.id, text)
+            : Lifecycle.reasoningStart(current.lifecycle, events, active.id),
+        active: { ...active, thinking, thinkingUnits: accumulated },
         nextContent: current.active ? current.nextContent : current.nextContent + 1,
     };
 };