@opencode/ai 2.0.15 → 2.0.16

package/dist/protocols/assemblyai-transcription.js

@@ -0,0 +1,138 @@
+import { Effect, Schema } from "effect";
+import { Media } from "../media.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { TranscriptionModel, TranscriptionResponse } from "../transcription.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+import { MediaInput } from "./utils/media-input.js";
+const ADAPTER = "assemblyai-transcription";
+const NAME = "AssemblyAI";
+const PROVIDER = ProviderID.make("assemblyai");
+export const DEFAULT_BASE_URL = "https://api.assemblyai.com";
+export const PATH = "/v2/transcript";
+export const UPLOAD_PATH = "/v2/upload";
+// ---------------------------------------------------------------------------
+// 2. Token and response schemas
+// ---------------------------------------------------------------------------
+export const Token = Schema.Struct({ transcriptID: Schema.String });
+const Upload = Schema.Struct({ upload_url: Schema.String });
+/** Word and utterance times are milliseconds. */
+const Transcript = Schema.Struct({
+    id: Schema.String,
+    status: Schema.String,
+    text: optionalNull(Schema.String),
+    words: optionalNull(Schema.Array(Schema.Struct({
+        text: Schema.String,
+        start: Schema.Number,
+        end: Schema.Number,
+        confidence: optionalNull(Schema.Number),
+        speaker: optionalNull(Schema.String),
+    }))),
+    utterances: optionalNull(Schema.Array(Schema.Struct({
+        text: Schema.String,
+        start: Schema.Number,
+        end: Schema.Number,
+        speaker: optionalNull(Schema.String),
+    }))),
+    language_code: optionalNull(Schema.String),
+    audio_duration: optionalNull(Schema.Number),
+    speech_model_used: optionalNull(Schema.String),
+    error: optionalNull(Schema.String),
+});
+const STATUS = {
+    queued: "queued",
+    processing: "running",
+    completed: "completed",
+    error: "failed",
+};
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const decodeUpload = MediaProtocol.decodeJson(ADAPTER, NAME, Upload);
+/** `/v2/transcript` only takes a URL, so inline audio is uploaded to `/v2/upload` first. */
+const prepare = Effect.fn("AssemblyAITranscription.prepare")(function* (request, send) {
+    if (request.audio.source.type !== "bytes" && request.audio.source.type !== "base64")
+        return request;
+    const audio = yield* MediaInput.inlineBytes(ADAPTER, request.audio);
+    const uploaded = yield* send(UPLOAD_PATH, MediaProtocol.binary(audio, "application/octet-stream")).pipe(Effect.flatMap(decodeUpload));
+    return { ...request, audio: Media.url(uploaded.value.upload_url, { mediaType: request.audio.mediaType }) };
+});
+const fromRequest = Effect.fn("AssemblyAITranscription.fromRequest")(function* (request) {
+    const audio = yield* ProviderShared.mediaReference(request.audio, PROVIDER, NAME);
+    return MediaProtocol.json(mergeJsonRecords({
+        audio_url: audio.value,
+        speech_models: [request.model.id],
+        language_code: request.language,
+        language_detection: request.language === undefined ? true : undefined,
+        prompt: request.prompt,
+        // Turn-level `utterances`, the only segments AssemblyAI returns, require speaker labels.
+        speaker_labels: request.diarize === true || request.timestamps === "segment" ? true : undefined,
+        speakers_expected: request.speakers,
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeTranscript = MediaProtocol.decodeJson(ADAPTER, NAME, Transcript);
+const decodeStart = Effect.fn("AssemblyAITranscription.decodeStart")(function* (response) {
+    const output = yield* decodeTranscript(response);
+    const status = yield* MediaProtocol.status(STATUS, output.value.status, output);
+    return { token: { transcriptID: output.value.id }, snapshot: { id: output.value.id, status } };
+});
+const decodeStatus = Effect.fn("AssemblyAITranscription.decodeStatus")(function* (response, context) {
+    const output = yield* decodeTranscript(response);
+    const status = yield* MediaProtocol.status(STATUS, output.value.status, output);
+    return { id: context.token.transcriptID, status };
+});
+const seconds = (milliseconds) => milliseconds / 1000;
+const decodeResult = Effect.fn("AssemblyAITranscription.decodeResult")(function* (response, context) {
+    const output = yield* decodeTranscript(response);
+    const transcript = output.value;
+    const status = yield* MediaProtocol.status(STATUS, transcript.status, output);
+    const error = transcript.error ?? undefined;
+    if (status === "failed")
+        return yield* output.ended("failed", `${NAME} transcription failed${error === undefined ? "" : `: ${error}`}`);
+    if (status !== "completed")
+        return yield* output.invalid(`${NAME} transcript ${context.token.transcriptID} has not finished`);
+    const duration = transcript.audio_duration ?? undefined;
+    return new TranscriptionResponse({
+        text: transcript.text ?? "",
+        segments: transcript.utterances?.map((utterance) => ({
+            text: utterance.text,
+            startSeconds: seconds(utterance.start),
+            endSeconds: seconds(utterance.end),
+            speaker: utterance.speaker ?? undefined,
+        })),
+        words: transcript.words?.map((word) => ({
+            text: word.text,
+            startSeconds: seconds(word.start),
+            endSeconds: seconds(word.end),
+            speaker: word.speaker ?? undefined,
+            confidence: word.confidence ?? undefined,
+        })),
+        language: transcript.language_code?.toLowerCase(),
+        durationSeconds: duration,
+        usage: duration === undefined ? undefined : { type: "seconds", seconds: duration },
+        providerMetadata: {
+            assemblyai: { transcriptId: transcript.id, speechModel: transcript.speech_model_used ?? undefined },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+const transcriptPath = (token) => `${PATH}/${token.transcriptID}`;
+export const protocol = MediaProtocol.queued({
+    id: ADAPTER,
+    name: NAME,
+    token: Token,
+    start: { prepare, body: { from: fromRequest }, decode: decodeStart },
+    status: { path: transcriptPath, decode: decodeStatus },
+    result: { path: transcriptPath, decode: decodeResult },
+});
+export const model = (input) => TranscriptionModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const AssemblyAITranscription = {
+    protocol,
+    model,
+};

package/dist/protocols/bedrock-converse.js

@@ -13,6 +13,7 @@ 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
@@ -162,10 +163,10 @@ const lowerToolSpec = (tool, inputSchema) => ({
         inputSchema: { json: inputSchema },
     },
 });
-const lowerTools = (compatibility, breakpoints, tools) => {
+const lowerTools = (model, breakpoints, tools) => {
     const result = [];
     for (const tool of tools) {
-        result.push(lowerToolSpec(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, compatibility)));
+        result.push(lowerToolSpec(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, model)));
         const cachePoint = BedrockCache.block(breakpoints, tool.cache);
         if (cachePoint)
             result.push(cachePoint);
@@ -348,7 +349,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(request.model, breakpoints, flattened.tools),
             // Converse has no native "none". Keep definitions stable for prompt
             // caching and omit only the unsupported choice.
             toolChoice,
@@ -413,14 +414,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,32 @@
+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. */
+export declare const Token: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly pollingURL: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, ImageResponse, {
+    readonly id: string;
+    readonly pollingURL: string;
+}>;
+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 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 { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+import { MediaInput } from "./utils/media-input.js";
+const ADAPTER = "bfl-images";
+const NAME = "Black Forest Labs";
+const PROVIDER = ProviderID.make("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. */
+export const Token = Schema.Struct({ id: Schema.String, pollingURL: Schema.String });
+const StartResponse = Schema.Struct({
+    id: Schema.String,
+    polling_url: Schema.String,
+});
+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 unsupported = (model, field, message) => ProviderShared.unsupportedOperation({
+    operation: `media.${field}`,
+    provider: PROVIDER,
+    route: ADAPTER,
+    message: `${model} ${message}`,
+});
+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(unsupported(id, "n", "generates one image per request; call it once per image"));
+    if (request.size !== undefined && model.sizing !== "dimensions")
+        return Effect.fail(unsupported(id, "size", "does not take size (width and height)"));
+    if (request.aspectRatio !== undefined && model.sizing !== "aspectRatio")
+        return Effect.fail(unsupported(id, "aspectRatio", "does not take aspectRatio"));
+    if (images > model.maxImages)
+        return Effect.fail(unsupported(id, "images", `takes at most ${model.maxImages} images`));
+    if (request.mask !== undefined && !model.mask)
+        return Effect.fail(unsupported(id, "mask", "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(`${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 = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+    token: { id: value.id, pollingURL: value.polling_url },
+    snapshot: { id: value.id, status: "queued" },
+}));
+const decodeDocument = MediaProtocol.decodeJson(ADAPTER, NAME, 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(`${NAME} moderated the generation`);
+    if (status === "failed" || status === "expired")
+        return yield* output.ended(status, `${NAME} generation ${context.token.id} ended with ${document.status}`);
+    if (status !== "completed" || document.result === undefined || document.result === null)
+        return yield* output.invalid(`${NAME} generation ${context.token.id} has no result`);
+    const { sample, seed, prompt, ...rest } = document.result;
+    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: document.cost === undefined || document.cost === null ? undefined : { type: "credits", credits: document.cost },
+        providerMetadata: {
+            bfl: { id: context.token.id, seed: seed ?? undefined, prompt: prompt ?? undefined, ...rest },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.queued({
+    id: ADAPTER,
+    name: NAME,
+    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({
+    id: ADAPTER,
+    provider: PROVIDER,
+    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,127 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.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 CartesiaSpeechString<Known extends string> = Known | (string & {});
+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?: CartesiaSpeechString<"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 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 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,126 @@
+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, ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { SpeechModel } from "../speech.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+import { SpeechStream } from "./utils/speech-stream.js";
+const ADAPTER = "cartesia-speech";
+const NAME = "Cartesia";
+const PROVIDER = ProviderID.make("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 = MediaProtocol.decodeFrame(ADAPTER, NAME, 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* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${NAME} supports the pcm, wav, and mp3 formats, not "${format}"`);
+    if (sse && container !== "raw")
+        return yield* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${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(`${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: `${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* MediaProtocol.incomplete(ADAPTER);
+    const format = yield* outputFormat(context.request);
+    return yield* SpeechStream.finish(ADAPTER, 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({
+    id: ADAPTER,
+    name: NAME,
+    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({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    headers: { "Cartesia-Version": API_VERSION },
+    path: ({ request }) => (usesSse(request) ? SSE_PATH : BYTES_PATH),
+}, input);
+export const CartesiaSpeech = {
+    protocol,
+    model,
+};