@opencode/ai 2.0.15 → 2.0.17

package/dist/protocols/bedrock-converse.js

@@ -11,8 +11,8 @@ import { BedrockCache } from "./utils/bedrock-cache.js";
 import { BedrockMedia } from "./utils/bedrock-media.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { MistralToolID } from "./utils/mistral-tool-id.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
+import { concatBytes } from "../utils/bytes.js";
 const ADAPTER = "bedrock-converse";
 // =============================================================================
 // Request Body Schema
@@ -155,17 +155,17 @@ const BedrockEvent = Schema.Struct({
 // =============================================================================
 // Request Lowering
 // =============================================================================
-const lowerToolSpec = (tool, inputSchema) => ({
+const lowerToolSpec = (tool) => ({
     toolSpec: {
         name: tool.name,
         ...(tool.description.trim().length > 0 ? { description: tool.description } : {}),
-        inputSchema: { json: inputSchema },
+        inputSchema: { json: tool.inputSchema },
     },
 });
-const lowerTools = (compatibility, breakpoints, tools) => {
+const lowerTools = (breakpoints, tools) => {
     const result = [];
     for (const tool of tools) {
-        result.push(lowerToolSpec(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, compatibility)));
+        result.push(lowerToolSpec(tool));
         const cachePoint = BedrockCache.block(breakpoints, tool.cache);
         if (cachePoint)
             result.push(cachePoint);
@@ -337,10 +337,32 @@ const lowerSystem = (breakpoints, system) => {
         .flatMap((part) => textWithCache(breakpoints, part.text, part.cache));
     return content.length === 0 ? undefined : content;
 };
+// Nova 2 rejects `maxTokens` at high reasoning effort, where its output can exceed the field's maximum. Other models
+// that take `reasoningConfig`, such as Grok on Bedrock, accept it.
+const isNova2 = (model) => /\bamazon\.nova-2-/.test(model.id);
+const isHighReasoningEffort = Schema.is(Schema.Struct({
+    additionalModelRequestFields: Schema.Struct({
+        reasoningConfig: Schema.Struct({ maxReasoningEffort: Schema.Literal("high") }),
+    }),
+}));
+const Options = Schema.Struct({
+    thinking: Schema.optional(Schema.Struct({ type: Schema.Literal("enabled"), budgetTokens: Schema.Number })),
+});
+const decodeOptions = ProviderShared.validateWith(Schema.decodeUnknownEffect(Options));
+// Claude on Bedrock requires the thinking budget below `maxTokens`, with a minimum of 1,024.
+const MIN_THINKING_BUDGET = 1_024;
 const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request) {
     const toolChoice = request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined;
     const flattened = ProviderShared.flattenToolRequest(request);
     const generation = request.generation;
+    const options = yield* decodeOptions(request.providerOptions ?? {});
+    const maxTokens = isNova2(request.model) && isHighReasoningEffort(request.http?.body) ? undefined : generation?.maxTokens;
+    const thinking = options.thinking === undefined
+        ? undefined
+        : {
+            type: "enabled",
+            budget_tokens: ProviderShared.fitThinkingBudget(options.thinking.budgetTokens, maxTokens, MIN_THINKING_BUDGET),
+        };
     // Bedrock-Claude shares Anthropic's 4-breakpoint cap. Spend the budget in
     // tools → system → messages order to favour the highest-impact prefixes.
     const breakpoints = BedrockCache.breakpoints(request.model.id);
@@ -348,7 +370,7 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request)
         if (flattened.tools.length === 0)
             return undefined;
         return {
-            tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, flattened.tools),
+            tools: lowerTools(breakpoints, flattened.tools),
             // Converse has no native "none". Keep definitions stable for prompt
             // caching and omit only the unsupported choice.
             toolChoice,
@@ -360,13 +382,13 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request)
         yield* Effect.logWarning(`Bedrock Converse: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${BedrockCache.BEDROCK_BREAKPOINT_CAP} per request.`);
     }
     const inferenceConfig = (() => {
-        if (generation?.maxTokens === undefined &&
+        if (maxTokens === undefined &&
             generation?.temperature === undefined &&
             generation?.topP === undefined &&
             (generation?.stop === undefined || generation.stop.length === 0))
             return undefined;
         return {
-            maxTokens: generation?.maxTokens,
+            maxTokens,
             temperature: generation?.temperature,
             topP: generation?.topP,
             stopSequences: generation?.stop,
@@ -378,9 +400,14 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request)
         system,
         inferenceConfig,
         toolConfig,
-        // Converse's base inferenceConfig has no topK; Anthropic/Nova accept it
-        // as a model-specific field, so it goes through additionalModelRequestFields.
-        additionalModelRequestFields: generation?.topK === undefined ? undefined : { top_k: generation.topK },
+        // Converse's base inferenceConfig has no topK or thinking; Anthropic/Nova accept them
+        // as model-specific fields, so they go through additionalModelRequestFields.
+        additionalModelRequestFields: generation?.topK === undefined && thinking === undefined
+            ? undefined
+            : {
+                ...(generation?.topK === undefined ? {} : { top_k: generation.topK }),
+                ...(thinking === undefined ? {} : { thinking }),
+            },
     };
 });
 // =============================================================================
@@ -413,14 +440,7 @@ const mapUsage = (usage, providerMetadataKey) => {
         providerMetadata: { [providerMetadataKey]: usage },
     });
 };
-const encodeRedactedContent = (chunks) => {
-    const bytes = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
-    chunks.reduce((offset, chunk) => {
-        bytes.set(chunk, offset);
-        return offset + chunk.length;
-    }, 0);
-    return Encoding.encodeBase64(bytes);
-};
+const encodeRedactedContent = (chunks) => Encoding.encodeBase64(concatBytes(chunks));
 const step = (state, event) => Effect.gen(function* () {
     if (event.contentBlockStart?.start?.toolUse) {
         const index = event.contentBlockStart.contentBlockIndex;

package/dist/protocols/bfl-images.d.ts

@@ -0,0 +1,38 @@
+import { Schema } from "effect";
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+export declare const DEFAULT_BASE_URL = "https://api.bfl.ai";
+export type BlackForestLabsImageOptions = {
+    readonly safety_tolerance?: number;
+    readonly prompt_upsampling?: boolean;
+    readonly disable_pup?: boolean;
+    readonly raw?: boolean;
+    readonly guidance?: number;
+    readonly steps?: number;
+} & Record<string, unknown>;
+export type Request = ImageRequestFor<BlackForestLabsImageOptions>;
+/**
+ * Regional clusters answer on different hosts, so the returned `polling_url` is followed verbatim. BFL reports the
+ * credit cost on submit, so it rides on the token; it is optional so tokens persisted before it existed still decode.
+ */
+export declare const Token: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly pollingURL: Schema.String;
+    readonly cost: Schema.optionalKey<Schema.Number>;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, ImageResponse, {
+    readonly id: string;
+    readonly pollingURL: string;
+    readonly cost?: number | undefined;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<BlackForestLabsImageOptions>;
+export declare const BlackForestLabsImages: {
+    readonly protocol: MediaProtocol.Queued<Request, ImageResponse, {
+        readonly id: string;
+        readonly pollingURL: string;
+        readonly cost?: number | undefined;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<BlackForestLabsImageOptions>;
+};

package/dist/protocols/bfl-images.js

@@ -0,0 +1,153 @@
+import { Effect, Schema } from "effect";
+import { ImageModel, ImageResponse } from "../image.js";
+import { Media } from "../media.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { mergeJsonRecords } from "../schema/index.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+import { MediaInput } from "./utils/media-input.js";
+const route = MediaProtocol.identity({ id: "bfl-images", name: "Black Forest Labs", provider: "black-forest-labs" });
+export const DEFAULT_BASE_URL = "https://api.bfl.ai";
+// ---------------------------------------------------------------------------
+// 2. Token and response schemas
+// ---------------------------------------------------------------------------
+/**
+ * Regional clusters answer on different hosts, so the returned `polling_url` is followed verbatim. BFL reports the
+ * credit cost on submit, so it rides on the token; it is optional so tokens persisted before it existed still decode.
+ */
+export const Token = Schema.Struct({
+    id: Schema.String,
+    pollingURL: Schema.String,
+    cost: Schema.optionalKey(Schema.Number),
+});
+const StartResponse = Schema.Struct({
+    id: Schema.String,
+    polling_url: Schema.String,
+    cost: optionalNull(Schema.Number),
+});
+const Result = Schema.Struct({
+    id: Schema.String,
+    status: Schema.String,
+    result: optionalNull(Schema.StructWithRest(Schema.Struct({ sample: Schema.String, seed: optionalNull(Schema.Number), prompt: optionalNull(Schema.String) }), [Schema.Record(Schema.String, Schema.Unknown)])),
+    cost: optionalNull(Schema.Number),
+});
+const STATUS = {
+    Pending: "running",
+    Reasoning: "running",
+    Generating: "running",
+    Ready: "completed",
+    Error: "failed",
+    // Moderation is terminal; `decodeResult` reports it as a content-policy failure.
+    "Content Moderated": "failed",
+    "Request Moderated": "failed",
+    "Task not found": "expired",
+};
+const isModerated = (status) => status === "Content Moderated" || status === "Request Moderated";
+const capabilities = (model) => {
+    if (model.startsWith("flux-pro-1.0-fill"))
+        return { sizing: "none", imageField: "image", maxImages: 1, mask: true };
+    if (model.startsWith("flux-pro-1.0-expand"))
+        return { sizing: "none", imageField: "image", maxImages: 1, mask: false };
+    if (model.startsWith("flux-kontext"))
+        return { sizing: "aspectRatio", imageField: "input_image", maxImages: 4, mask: false };
+    if (model.startsWith("flux-pro-1.1-ultra"))
+        return { sizing: "aspectRatio", imageField: "image_prompt", maxImages: 1, mask: false };
+    if (model.startsWith("flux-pro-1.1") || model.startsWith("flux-dev"))
+        return { sizing: "dimensions", imageField: "image_prompt", maxImages: 1, mask: false };
+    if (model.startsWith("flux-2-klein"))
+        return { sizing: "dimensions", imageField: "input_image", maxImages: 4, mask: false };
+    return { sizing: "dimensions", imageField: "input_image", maxImages: 8, mask: false };
+};
+const validate = (request, model) => {
+    const id = request.model.id;
+    const images = request.images?.length ?? 0;
+    if (request.n !== undefined && request.n > 1)
+        return Effect.fail(route.unsupported("media.n", `${id} generates one image per request; call it once per image`));
+    if (request.size !== undefined && model.sizing !== "dimensions")
+        return Effect.fail(route.unsupported("media.size", `${id} does not take size (width and height)`));
+    if (request.aspectRatio !== undefined && model.sizing !== "aspectRatio")
+        return Effect.fail(route.unsupported("media.aspectRatio", `${id} does not take aspectRatio`));
+    if (images > model.maxImages)
+        return Effect.fail(route.unsupported("media.images", `${id} takes at most ${model.maxImages} images`));
+    if (request.mask !== undefined && !model.mask)
+        return Effect.fail(route.unsupported("media.mask", `${id} does not inpaint; use flux-pro-1.0-fill`));
+    return Effect.void;
+};
+const imageInput = (asset) => {
+    const value = asset.inline()?.base64 ?? ProviderShared.mediaUrl(asset);
+    if (value === undefined)
+        return Effect.fail(ProviderShared.invalidRequest(`${route.name} accepts inline images or https URLs`));
+    return Effect.succeed(value);
+};
+const fromRequest = Effect.fn("BlackForestLabsImages.fromRequest")(function* (request) {
+    const model = capabilities(request.model.id);
+    yield* validate(request, model);
+    const images = yield* Effect.forEach(request.images ?? [], imageInput);
+    const fields = images.map((image, index) => [
+        index === 0 ? model.imageField : `${model.imageField}_${index + 1}`,
+        image,
+    ]);
+    return MediaProtocol.json(mergeJsonRecords({
+        prompt: request.prompt,
+        ...(request.size === undefined ? {} : MediaInput.dimensions(request.size)),
+        aspect_ratio: request.aspectRatio,
+        seed: request.seed,
+        output_format: request.format,
+        mask: request.mask === undefined ? undefined : yield* imageInput(request.mask),
+        ...Object.fromEntries(fields),
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeStart = route.decodeStarted(StartResponse, (value) => ({
+    token: {
+        id: value.id,
+        pollingURL: value.polling_url,
+        ...(value.cost === undefined || value.cost === null ? {} : { cost: value.cost }),
+    },
+    snapshot: { id: value.id, status: "queued" },
+}));
+const decodeDocument = route.decodeJson(Result);
+const decodeStatus = Effect.fn("BlackForestLabsImages.decodeStatus")(function* (response, context) {
+    const output = yield* decodeDocument(response);
+    return { id: context.token.id, status: yield* MediaProtocol.status(STATUS, output.value.status, output) };
+});
+const decodeResult = Effect.fn("BlackForestLabsImages.decodeResult")(function* (response, context) {
+    const output = yield* decodeDocument(response);
+    const document = output.value;
+    const status = yield* MediaProtocol.status(STATUS, document.status, output);
+    if (isModerated(document.status))
+        return yield* output.contentPolicy(`${route.name} moderated the generation`);
+    if (status === "failed" || status === "expired")
+        return yield* output.ended(status, `${route.name} generation ${context.token.id} ended with ${document.status}`);
+    if (status !== "completed")
+        return yield* output.pending(context.token.id);
+    if (document.result === undefined || document.result === null)
+        return yield* output.invalid(`${route.name} generation ${context.token.id} has no result`);
+    const { sample, seed, prompt, ...rest } = document.result;
+    // A settled `cost` on the result supersedes the submit-time cost carried on the token.
+    const cost = document.cost ?? context.token.cost;
+    return new ImageResponse({
+        // `sample` is a signed URL that expires 10 minutes after the result is ready, so it is downloaded now.
+        images: [yield* context.materialize(Media.url(sample))],
+        usage: cost === undefined ? undefined : { type: "credits", credits: cost },
+        providerMetadata: {
+            bfl: { id: context.token.id, seed: seed ?? undefined, prompt: prompt ?? undefined, ...rest },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.queued(route, {
+    token: Token,
+    start: { body: { from: fromRequest }, decode: decodeStart },
+    status: { path: (token) => token.pollingURL, decode: decodeStatus },
+    result: { path: (token) => token.pollingURL, decode: decodeResult },
+});
+export const model = (input) => ImageModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => `/v1/${request.model.id}` }, input);
+export const BlackForestLabsImages = {
+    protocol,
+    model,
+};

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

@@ -0,0 +1,143 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
+import { SpeechModel, type SpeechRequestFor } from "../speech.js";
+import { SpeechStream } from "./utils/speech-stream.js";
+export declare const DEFAULT_BASE_URL = "https://api.cartesia.ai";
+export declare const API_VERSION = "2026-08-14";
+export declare const BYTES_PATH = "/tts/bytes";
+export declare const SSE_PATH = "/tts/sse";
+export type CartesiaEncoding = SpeechStream.PcmEncoding;
+export type CartesiaSpeechOptions = {
+    readonly sampleRate?: 8000 | 16000 | 22050 | 24000 | 44100 | 48000;
+    readonly bitRate?: 32000 | 64000 | 96000 | 128000 | 192000;
+    readonly encoding?: CartesiaEncoding;
+    readonly generation_config?: {
+        readonly volume?: number;
+        readonly emotion?: OpenString<"neutral" | "calm" | "angry" | "content" | "sad" | "scared">;
+    };
+    readonly pronunciation_dict_id?: string;
+} & Record<string, unknown>;
+export type Request = SpeechRequestFor<CartesiaSpeechOptions>;
+interface State extends SpeechStream.Audio {
+    readonly done: boolean;
+}
+export declare const protocol: MediaProtocol.Streamed<Request, {
+    readonly id: string;
+    readonly type: "generation-queued";
+    readonly position?: number | undefined;
+} | {
+    readonly id: string;
+    readonly type: "generation-progress";
+    readonly progress?: number | undefined;
+} | {
+    readonly type: "audio-delta";
+    readonly chunk: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly type: "timestamps";
+    readonly items: readonly {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+    }[];
+} | {
+    readonly type: "finish";
+    readonly audio: import("../media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+    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;
+    } | {
+        readonly type: "characters";
+        readonly characters: number;
+    } | {
+        readonly type: "credits";
+        readonly credits: number;
+    } | {
+        readonly type: "compute";
+        readonly seconds: number;
+    } | undefined;
+    readonly notices?: readonly {
+        readonly type: "other" | "moderated" | "filtered";
+        readonly message: string;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+    }[] | undefined;
+}, string | Uint8Array<ArrayBufferLike>, State>;
+export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<CartesiaSpeechOptions>;
+export declare const CartesiaSpeech: {
+    readonly protocol: MediaProtocol.Streamed<Request, {
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    } | {
+        readonly type: "audio-delta";
+        readonly chunk: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly type: "timestamps";
+        readonly items: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+        }[];
+    } | {
+        readonly type: "finish";
+        readonly audio: import("../media.js").Asset;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        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;
+        } | {
+            readonly type: "characters";
+            readonly characters: number;
+        } | {
+            readonly type: "credits";
+            readonly credits: number;
+        } | {
+            readonly type: "compute";
+            readonly seconds: number;
+        } | undefined;
+        readonly notices?: readonly {
+            readonly type: "other" | "moderated" | "filtered";
+            readonly message: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        }[] | undefined;
+    }, string | Uint8Array<ArrayBufferLike>, State>;
+    readonly model: (input: MediaRoute.ModelInput) => SpeechModel<CartesiaSpeechOptions>;
+};
+export {};

package/dist/protocols/cartesia-speech.js

@@ -0,0 +1,120 @@
+import { Effect, Schema } from "effect";
+import { classifyProviderFailure } from "../provider-error.js";
+import { Framing } from "../route/framing.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { AIError, mergeJsonRecords } from "../schema/index.js";
+import { SpeechModel } from "../speech.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+import { SpeechStream } from "./utils/speech-stream.js";
+const route = MediaProtocol.identity({ id: "cartesia-speech", name: "Cartesia", provider: "cartesia" });
+export const DEFAULT_BASE_URL = "https://api.cartesia.ai";
+export const API_VERSION = "2026-08-14";
+export const BYTES_PATH = "/tts/bytes";
+export const SSE_PATH = "/tts/sse";
+const DEFAULT_SAMPLE_RATE = 44100;
+const DEFAULT_BIT_RATE = 128000;
+// ---------------------------------------------------------------------------
+// 3. Streaming event schema
+// ---------------------------------------------------------------------------
+/** `phoneme_timestamps` and future record types are ignored. */
+const SseEvent = Schema.Struct({
+    type: Schema.String,
+    data: Schema.optional(Schema.Uint8ArrayFromBase64),
+    word_timestamps: Schema.optional(Schema.Struct({
+        words: Schema.Array(Schema.String),
+        start: Schema.Array(Schema.Number),
+        end: Schema.Array(Schema.Number),
+    })),
+    status_code: Schema.optional(Schema.Number),
+    title: Schema.optional(Schema.String),
+    message: Schema.optional(Schema.String),
+    error_code: optionalNull(Schema.String),
+});
+const decodeEvent = route.decodeFrame(SseEvent);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+/** Timestamps exist only on the SSE endpoint, so a `generate` that asks for them collects an SSE stream. */
+const usesSse = (request) => request.mode === "stream" || request.timestamps === true;
+const CONTAINERS = { pcm: "raw", wav: "wav", mp3: "mp3" };
+const outputFormat = Effect.fn("CartesiaSpeech.outputFormat")(function* (request) {
+    const sse = usesSse(request);
+    const format = request.format ?? (sse ? "pcm" : "mp3");
+    const container = CONTAINERS[format];
+    if (container === undefined)
+        return yield* route.unsupported("media.format", `${route.name} supports the pcm, wav, and mp3 formats, not "${format}"`);
+    if (sse && container !== "raw")
+        return yield* route.unsupported("media.format", `${route.name} streams and timestamps only raw PCM; request format "pcm" instead of "${format}"`);
+    const sampleRate = request.providerOptions?.sampleRate ?? DEFAULT_SAMPLE_RATE;
+    if (container === "mp3")
+        return { container, sample_rate: sampleRate, bit_rate: request.providerOptions?.bitRate ?? DEFAULT_BIT_RATE };
+    return { container, encoding: request.providerOptions?.encoding ?? "pcm_s16le", sample_rate: sampleRate };
+});
+const fromRequest = Effect.fn("CartesiaSpeech.fromRequest")(function* (request) {
+    const voice = SpeechStream.voiceID(request.voice);
+    if (voice === undefined)
+        return yield* ProviderShared.invalidRequest(`${route.name} requires a voice id; pass it as \`voice\``);
+    const { sampleRate: _sampleRate, bitRate: _bitRate, encoding: _encoding, ...native } = request.providerOptions ?? {};
+    return MediaProtocol.json(mergeJsonRecords({
+        model_id: request.model.id,
+        transcript: request.text,
+        voice,
+        output_format: yield* outputFormat(request),
+        language: request.language,
+        generation_config: request.speed === undefined ? undefined : { speed: request.speed },
+        add_timestamps: request.timestamps === true ? true : undefined,
+    }, native, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Stream parsing
+// ---------------------------------------------------------------------------
+const onEvent = Effect.fn("CartesiaSpeech.onEvent")(function* (state, frame) {
+    const event = yield* decodeEvent(frame);
+    if (event.type === "chunk" && event.data !== undefined)
+        return SpeechStream.delta(state, event.data);
+    if (event.type === "timestamps" && event.word_timestamps !== undefined) {
+        const words = event.word_timestamps;
+        return [state, SpeechStream.timestamps(words.words, words.start, words.end)];
+    }
+    if (event.type === "done")
+        return [{ ...state, done: true }, []];
+    if (event.type === "error")
+        return yield* new AIError({
+            reason: classifyProviderFailure({
+                message: `${route.name} stream failed${event.title === undefined ? "" : ` (${event.title})`}: ${event.message ?? "unknown error"}`,
+                status: event.status_code,
+                rawBody: frame,
+            }),
+        });
+    return [state, []];
+});
+const finish = Effect.fn("CartesiaSpeech.finish")(function* (state, context) {
+    if (usesSse(context.request) && !state.done)
+        return yield* route.incomplete();
+    const format = yield* outputFormat(context.request);
+    return yield* SpeechStream.finish(route, state, format.container === "raw"
+        ? SpeechStream.pcm(format.encoding, format.sample_rate)
+        : SpeechStream.container(format.container, format.sample_rate));
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.stream(route, {
+    unsupported: ["instructions"],
+    body: { from: fromRequest },
+    frames: (bytes, context) => (usesSse(context.request) ? Framing.sse.frame(bytes) : bytes),
+    initial: () => ({ chunks: [], done: false }),
+    step: SpeechStream.step(onEvent),
+    finish,
+});
+export const model = (input) => SpeechModel.fromRoute({
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    headers: { "Cartesia-Version": API_VERSION },
+    path: ({ request }) => (usesSse(request) ? SSE_PATH : BYTES_PATH),
+}, input);
+export const CartesiaSpeech = {
+    protocol,
+    model,
+};