@opencode/ai 2.0.15 → 2.0.17

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

@@ -291,8 +291,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -328,8 +328,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -364,8 +364,8 @@ export declare const protocol: Protocol<{
         readonly type: "image_generation_call";
         readonly status?: string | undefined;
         readonly result?: string | null | undefined;
-        readonly revised_prompt?: string | null | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly revised_prompt?: string | null | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -392,9 +392,9 @@ export declare const protocol: Protocol<{
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
+        readonly partial_images?: number | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;
@@ -574,8 +574,8 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -611,8 +611,8 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -647,8 +647,8 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         readonly type: "image_generation_call";
         readonly status?: string | undefined;
         readonly result?: string | null | undefined;
-        readonly revised_prompt?: string | null | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly revised_prompt?: string | null | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -675,9 +675,9 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
+        readonly partial_images?: number | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;
@@ -802,8 +802,8 @@ export declare const channelTransport: (options: import("./open-responses-channe
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -839,8 +839,8 @@ export declare const channelTransport: (options: import("./open-responses-channe
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -875,8 +875,8 @@ export declare const channelTransport: (options: import("./open-responses-channe
         readonly type: "image_generation_call";
         readonly status?: string | undefined;
         readonly result?: string | null | undefined;
-        readonly revised_prompt?: string | null | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly revised_prompt?: string | null | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -903,9 +903,9 @@ export declare const channelTransport: (options: import("./open-responses-channe
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
+        readonly partial_images?: number | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;
@@ -1030,8 +1030,8 @@ export declare const transport: import("../route/transport/index.js").Transport<
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -1067,8 +1067,8 @@ export declare const transport: import("../route/transport/index.js").Transport<
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -1103,8 +1103,8 @@ export declare const transport: import("../route/transport/index.js").Transport<
         readonly type: "image_generation_call";
         readonly status?: string | undefined;
         readonly result?: string | null | undefined;
-        readonly revised_prompt?: string | null | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly revised_prompt?: string | null | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -1131,9 +1131,9 @@ export declare const transport: import("../route/transport/index.js").Transport<
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
+        readonly partial_images?: number | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;
@@ -1258,8 +1258,8 @@ export declare const route: Route<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -1295,8 +1295,8 @@ export declare const route: Route<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly detail?: string | undefined;
             readonly file_data?: string | undefined;
+            readonly detail?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -1331,8 +1331,8 @@ export declare const route: Route<{
         readonly type: "image_generation_call";
         readonly status?: string | undefined;
         readonly result?: string | null | undefined;
-        readonly revised_prompt?: string | null | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly revised_prompt?: string | null | undefined;
     })[];
     readonly model: string;
     readonly stream: true;
@@ -1359,9 +1359,9 @@ export declare const route: Route<{
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
         readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
         readonly background?: "auto" | "opaque" | "transparent" | undefined;
+        readonly partial_images?: number | undefined;
         readonly output_compression?: number | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
-        readonly partial_images?: number | undefined;
     } | {
         readonly type: "namespace";
         readonly name: string;

package/dist/protocols/openai-responses.js

@@ -5,14 +5,12 @@ import { Auth } from "../route/auth.js";
 import { Endpoint } from "../route/endpoint.js";
 import { Protocol } from "../route/protocol.js";
 import { HttpTransport } from "../route/transport/index.js";
-import { LLMRequest, mergeJsonRecords } from "../schema/index.js";
+import { LLMRequest } from "../schema/index.js";
 import { resolveEffortUpdates } from "../effort-updates.js";
 import { OpenResponses } from "./open-responses.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
-import { OpenAIImage } from "./utils/openai-image.js";
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { OpenResponsesChannel } from "./open-responses-channel.js";
 import { ResponsesCompaction } from "./utils/responses-compaction.js";
 import { ResponsesCheckpoint } from "./utils/responses-checkpoint.js";
@@ -35,7 +33,14 @@ const OpenAIResponsesImageGenerationTool = Schema.Struct({
     output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
     partial_images: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
     quality: Schema.optional(Schema.Literals(["auto", "low", "medium", "high"])),
-    size: Schema.optional(OpenAIImage.Size),
+    size: Schema.optional(Schema.String.check(Schema.makeFilter((value) => {
+        if (value === "auto")
+            return undefined;
+        const match = /^(\d+)x(\d+)$/.exec(value);
+        if (!match)
+            return "image size must be `auto` or `{width}x{height}`";
+        return Number(match[1]) > 0 && Number(match[2]) > 0 ? undefined : "image dimensions must be positive integers";
+    }))),
 });
 const OpenAIResponsesHostedToolItem = Schema.Union([
     Schema.StructWithRest(Schema.Struct({
@@ -100,23 +105,23 @@ export const CompactionTrigger = Schema.Struct({ type: Schema.Literal("compactio
 const CheckpointBody = Schema.Struct({
     ...OpenAIResponsesBody.fields,
     input: Schema.Array(Schema.Union([OpenAIResponsesInputItem, CompactionTrigger])),
-    store: Schema.Literal(false),
-    prompt_cache_retention: optionalNull(Schema.String),
-    prompt_cache_options: optionalNull(Schema.Struct({ mode: Schema.optional(Schema.String), ttl: Schema.optional(Schema.String) })),
 });
 const adapter = {
     id: ADAPTER,
     name: NAME,
     restoreHostedToolItem: (item) => (Schema.is(OpenAIResponsesHostedToolItem)(item) ? item : undefined),
 };
-// Only GPT-6 Astra accepts `configuration_update`, and never alongside automatic `context_management` compaction.
+// GPT-6 Astra, Sol, and Luna accept `configuration_update` only in standard mode (not `reasoning.mode: "pro"` or
+// `-pro` slugs), and never alongside automatic `context_management` compaction.
 const supportsEffortUpdates = (request) => {
     if (request.providerOptions?.contextManagement !== undefined)
         return false;
+    if (Schema.is(Schema.Struct({ mode: Schema.Literal("pro") }))(request.http?.body?.reasoning))
+        return false;
     const override = request.model.compatibility?.supportsEffortUpdates;
     if (override !== undefined)
         return override;
-    return /(?:^|\/)gpt-6-astra$/i.test(request.model.id);
+    return /(?:^|\/)gpt-6-(?:astra|sol|luna)$/i.test(request.model.id);
 };
 const nativeImageToolInput = (tool) => {
     const native = tool.native?.openai;
@@ -126,29 +131,30 @@ const nativeImageTool = (tool) => {
     const native = nativeImageToolInput(tool);
     return Schema.is(OpenAIResponsesImageGenerationTool)(native) ? native : undefined;
 };
-const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool, inputSchema) {
+const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool) {
     const native = nativeImageToolInput(tool);
     if (native !== undefined) {
         if (Schema.is(OpenAIResponsesImageGenerationTool)(native))
             return native;
         return yield* ProviderShared.invalidRequest("OpenAI Responses image generation tool options are invalid");
     }
-    return yield* OpenResponses.lowerTool(NAME, tool, inputSchema);
+    return yield* OpenResponses.lowerTool(NAME, tool);
 });
 // Native namespaces hold only function tools, so deeper levels flatten into
 // the leaf names the same way non-native protocols flatten the whole tree.
-const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (tool, compatibility) {
+const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (tool) {
     if (tool.type === "tool")
-        return yield* lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, compatibility));
+        return yield* lowerTool(tool);
     // OpenAI requires a namespace description; fall back to a generic one so a
     // missing description never blocks the request.
     return {
         type: "namespace",
         name: tool.name,
         description: tool.description ?? `Tools in the ${tool.name} namespace.`,
-        tools: yield* Effect.forEach(ProviderShared.flattenTools(tool.tools), (leaf) => OpenResponses.lowerTool(NAME, leaf, ToolSchemaProjection.modelCompatibility(leaf.inputSchema, compatibility))),
+        tools: yield* Effect.forEach(ProviderShared.flattenTools(tool.tools), (leaf) => OpenResponses.lowerTool(NAME, leaf)),
     };
 });
+const lowerTools = (request) => Effect.forEach(request.tools, lowerToolEntry);
 const lowerToolChoice = (toolChoice, tools) => ProviderShared.matchToolChoice(NAME, toolChoice, {
     auto: () => "auto",
     none: () => "none",
@@ -162,14 +168,11 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request)
     const management = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)))(request.providerOptions?.contextManagement);
     const options = OpenResponsesOptions.resolve(request);
     const updates = resolveEffortUpdates(request, options.reasoningEffort);
-    const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     return yield* decodeBody({
         ...(yield* OpenResponses.lowerConversation(updates.request, adapter)),
         ...OpenResponses.lowerGeneration(request, { ...options, reasoningEffort: updates.effort }),
         context_management: management?.map((edit) => ({ type: edit.type, compact_threshold: edit.compactThreshold })),
-        tools: request.tools.length === 0
-            ? undefined
-            : yield* Effect.forEach(request.tools, (tool) => lowerToolEntry(tool, toolSchemaCompatibility)),
+        tools: request.tools.length === 0 ? undefined : yield* lowerTools(request),
         tool_choice: request.tools.length === 0
             ? undefined
             : (OpenResponses.allowedToolChoice(request) ??
@@ -179,25 +182,19 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request)
 const checkpointBody = {
     schema: CheckpointBody,
     from: Effect.fn("OpenAIResponses.checkpointBody")(function* (request) {
-        const native = yield* fromRequest(LLMRequest.update(request, { toolChoice: undefined }));
         const overlay = request.http?.body;
         // Complete history is required for stateless replay and SSE recovery. Raw input overrides bypass that contract.
         if (overlay?.input !== undefined ||
             overlay?.previous_response_id !== undefined ||
             overlay?.conversation !== undefined)
             return yield* ProviderShared.invalidRequest("Trigger compaction requires complete canonical history, not an input or continuation override");
-        return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(CheckpointBody))({
-            ...mergeJsonRecords(native, overlay),
+        if (overlay?.stream !== undefined && overlay.stream !== true)
+            return yield* ProviderShared.invalidRequest("Trigger compaction requires a streamed response");
+        const native = yield* fromRequest(request);
+        return {
+            ...native,
             input: [...native.input, { type: "compaction_trigger" }],
-            stream: true,
-            store: false,
-            parallel_tool_calls: true,
-            tool_choice: undefined,
-            context_management: undefined,
-            text: undefined,
-            max_output_tokens: undefined,
-            max_tool_calls: undefined,
-        });
+        };
     }),
 };
 const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item) {
@@ -268,7 +265,10 @@ export const transport = channelTransport({
     headers: (headers) => Headers.set(headers, "openai-beta", headers["openai-beta"] ?? WEBSOCKET_PROTOCOL_HEADER),
 });
 export const route = Route.make({
-    compact: { endpoint: ResponsesCompaction.make(adapter), trigger: ResponsesCheckpoint.make(checkpointBody) },
+    compact: {
+        endpoint: ResponsesCompaction.make(adapter, lowerTools),
+        trigger: ResponsesCheckpoint.make(checkpointBody),
+    },
     id: ADAPTER,
     provider: "openai",
     providerMetadataKey: "openai",

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

@@ -0,0 +1,136 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { type MediaUsage } 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.openai.com/v1";
+export declare const PATH = "/audio/speech";
+/** `voice`, `instructions`, `speed`, and `format` are common request fields; other native body fields pass through. */
+export type OpenAISpeechOptions = {
+    /** Defaults to `"sse"` in `stream` mode on models that support it; the merged value selects the response framing. */
+    readonly stream_format?: "sse" | "audio";
+} & Record<string, unknown>;
+export type Request = SpeechRequestFor<OpenAISpeechOptions>;
+interface State extends SpeechStream.Audio {
+    readonly done: boolean;
+    readonly usage?: MediaUsage;
+}
+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<OpenAISpeechOptions>;
+export declare const OpenAISpeech: {
+    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<OpenAISpeechOptions>;
+};
+export {};

package/dist/protocols/openai-speech.js

@@ -0,0 +1,97 @@
+import { Effect, Schema } from "effect";
+import { Framing } from "../route/framing.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { mergeJsonRecords } from "../schema/index.js";
+import { SpeechModel } from "../speech.js";
+import { SpeechStream } from "./utils/speech-stream.js";
+const route = MediaProtocol.identity({ id: "openai-speech", name: "OpenAI Speech", provider: "openai" });
+export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+export const PATH = "/audio/speech";
+/** `pcm` is raw 24 kHz, 16-bit signed little-endian mono samples without a header. */
+const PCM_SAMPLE_RATE = 24000;
+// ---------------------------------------------------------------------------
+// 3. Streaming event schema
+// ---------------------------------------------------------------------------
+const SpeechStreamEvent = Schema.Union([
+    Schema.Struct({ type: Schema.Literal("speech.audio.delta"), audio: Schema.Uint8ArrayFromBase64 }),
+    Schema.Struct({
+        type: Schema.Literal("speech.audio.done"),
+        usage: Schema.optional(Schema.Struct({
+            input_tokens: Schema.optional(Schema.Number),
+            output_tokens: Schema.optional(Schema.Number),
+            total_tokens: Schema.optional(Schema.Number),
+        })),
+    }),
+]);
+const decodeEvent = route.decodeFrame(SpeechStreamEvent);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+// `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 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`);
+    return MediaProtocol.json(mergeJsonRecords({
+        model: request.model.id,
+        input: request.text,
+        voice: request.voice,
+        instructions: request.instructions,
+        response_format: request.format,
+        speed: request.speed,
+        stream_format: request.mode === "stream" && supportsSse(request.model.id) ? "sse" : undefined,
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Stream parsing
+// ---------------------------------------------------------------------------
+const isSse = (body) => body.type === "json" && body.value.stream_format === "sse";
+const onEvent = Effect.fn("OpenAISpeech.onEvent")(function* (state, frame) {
+    const event = yield* decodeEvent(frame);
+    if (event.type === "speech.audio.delta")
+        return SpeechStream.delta(state, event.audio);
+    const usage = event.usage;
+    return [
+        {
+            ...state,
+            done: true,
+            usage: usage === undefined
+                ? undefined
+                : {
+                    type: "tokens",
+                    input: usage.input_tokens,
+                    output: usage.output_tokens,
+                    total: usage.total_tokens,
+                    details: { openai: usage },
+                },
+        },
+        [],
+    ];
+});
+const finish = (state, context) => {
+    if (isSse(context.body) && !state.done)
+        return Effect.fail(route.incomplete());
+    const format = context.request.format ?? "mp3";
+    return SpeechStream.finish(route, state, {
+        ...(format === "pcm" ? SpeechStream.pcm("pcm_s16le", PCM_SAMPLE_RATE) : SpeechStream.container(format)),
+        usage: state.usage,
+    });
+};
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.stream(route, {
+    unsupported: ["language"],
+    body: { from: fromRequest },
+    frames: (bytes, context) => (isSse(context.body) ? 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, path: PATH }, input);
+export const OpenAISpeech = {
+    protocol,
+    model,
+};