@opencode/ai 2.0.16 → 2.0.17

package/dist/protocols/openai-images.js

@@ -4,12 +4,10 @@ import { Media } from "../media.js";
 import { Framing } from "../route/framing.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
-import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { mergeJsonRecords } from "../schema/index.js";
 import { ProviderShared } from "./shared.js";
 import { MediaInput } from "./utils/media-input.js";
-const ADAPTER = "openai-images";
-const NAME = "OpenAI Images";
-const PROVIDER = ProviderID.make("openai");
+const route = MediaProtocol.identity({ id: "openai-images", name: "OpenAI Images", provider: "openai" });
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export const PATH = "/images/generations";
 export const EDIT_PATH = "/images/edits";
@@ -23,13 +21,16 @@ const Usage = Schema.Struct({
     input_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
     output_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 });
-const OpenAIImageResponse = Schema.Struct({
-    data: Schema.Array(Schema.Struct({
-        b64_json: Schema.optional(Schema.String),
-        url: Schema.optional(Schema.String),
-        revised_prompt: Schema.optional(Schema.String),
-    })),
+/** What the provider actually rendered; it can differ from the request when `auto` or a default applied. */
+const Settings = {
     output_format: Schema.optional(Schema.String),
+    size: Schema.optional(Schema.String),
+    quality: Schema.optional(Schema.String),
+    background: Schema.optional(Schema.String),
+};
+const OpenAIImageResponse = Schema.Struct({
+    data: Schema.Array(Schema.Struct({ b64_json: Schema.String })),
+    ...Settings,
     usage: Schema.optional(Usage),
 });
 // ---------------------------------------------------------------------------
@@ -40,16 +41,18 @@ const StreamEvent = Schema.Union([
         type: Schema.Literals(["image_generation.partial_image", "image_edit.partial_image"]),
         b64_json: Schema.String,
         partial_image_index: Schema.Number,
+        ...Settings,
         output_format: Schema.String,
     }),
     Schema.Struct({
         type: Schema.Literals(["image_generation.completed", "image_edit.completed"]),
         b64_json: Schema.String,
+        ...Settings,
         output_format: Schema.String,
         usage: Schema.optional(Usage),
     }),
 ]);
-const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, StreamEvent);
+const decodeEvent = route.decodeFrame(StreamEvent);
 const decodeDocument = Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIImageResponse));
 // ---------------------------------------------------------------------------
 // 5. Request body construction
@@ -65,25 +68,13 @@ const nativeOptions = (options) => {
 const streamOptions = (request) => {
     if (request.mode !== "stream")
         return Effect.succeed(undefined);
-    if (request.model.id.startsWith("dall-e"))
-        return Effect.fail(ProviderShared.unsupportedOperation({
-            operation: "media.stream",
-            provider: PROVIDER,
-            route: ADAPTER,
-            message: `${request.model.id} does not stream; use Image.generate or a GPT image model`,
-        }));
     if (request.n !== undefined && request.n > 1)
-        return Effect.fail(ProviderShared.unsupportedOperation({
-            operation: "media.n",
-            provider: PROVIDER,
-            route: ADAPTER,
-            message: `${NAME} streams one image; use Image.generate for n=${request.n}`,
-        }));
+        return Effect.fail(route.unsupported("media.n", `${route.name} streams one image; use Image.generate for n=${request.n}`));
     return Effect.succeed({ stream: true, partial_images: request.providerOptions?.partialImages ?? 2 });
 };
 const isEdit = (request) => (request.images?.length ?? 0) > 0;
 const isInline = (asset) => asset.source.type === "bytes" || asset.source.type === "base64";
-const reference = (asset) => ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(Effect.map((item) => (item.type === "ref" ? { file_id: item.value } : { image_url: item.value })));
+const reference = (asset) => ProviderShared.mediaReference(asset, route.provider, route.name).pipe(Effect.map((item) => (item.type === "ref" ? { file_id: item.value } : { image_url: item.value })));
 const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request) {
     const images = request.images ?? [];
     const mask = request.mask;
@@ -93,17 +84,11 @@ const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request) {
     // Owned bytes go through multipart edits; remote URLs and file IDs use the JSON edits body instead.
     if (images.length > 0 && images.every(isInline) && (mask === undefined || isInline(mask))) {
         const form = new FormData();
-        form.append("model", request.model.id);
-        form.append("prompt", request.prompt);
-        Object.entries(fields ?? {}).forEach(([key, value]) => {
-            if (RESERVED_FORM_FIELDS.has(key))
-                return;
-            form.append(key, typeof value === "string" ? value : ProviderShared.encodeJson(value));
-        });
-        const uploads = yield* Effect.forEach(images, (image) => MediaInput.inlineBytes(ADAPTER, image));
+        MediaInput.appendFields(form, { model: request.model.id, prompt: request.prompt }, { overlay: fields, reserved: RESERVED_FORM_FIELDS });
+        const uploads = yield* Effect.forEach(images, (image) => MediaInput.inlineBytes(route.id, image));
         uploads.forEach((data, index) => form.append("image[]", MediaInput.blob(data, images[index].mediaType), `image-${index}`));
         if (mask !== undefined)
-            form.append("mask", MediaInput.blob(yield* MediaInput.inlineBytes(ADAPTER, mask), mask.mediaType), "mask");
+            form.append("mask", MediaInput.blob(yield* MediaInput.inlineBytes(route.id, mask), mask.mediaType), "mask");
         return MediaProtocol.multipart(form);
     }
     const references = yield* Effect.forEach(images, reference);
@@ -133,55 +118,75 @@ const usage = (value) => value === undefined
         total: value.total_tokens,
         details: { openai: value },
     };
-const eventImage = (frame, label, data, format) => MediaInput.decodedAsset((message, cause) => MediaProtocol.frameError(ADAPTER, message, frame, cause), label, data, `image/${format}`, { info: { format } });
+/** `size` echoes the rendered `WIDTHxHEIGHT`; `auto` or any other value leaves the dimensions unknown. */
+const info = (format, size) => {
+    const match = size?.match(/^(\d+)x(\d+)$/);
+    return match ? { format, width: Number(match[1]), height: Number(match[2]) } : { format };
+};
+const eventImage = (frame, label, data, format, size) => MediaInput.decodedAsset((message, cause) => route.frameError(message, frame, cause), label, data, `image/${format}`, {
+    info: info(format, size),
+});
 const onEvent = Effect.fn("OpenAIImages.onEvent")(function* (state, frame) {
     const event = yield* decodeEvent(frame);
     const format = event.output_format;
     if ("partial_image_index" in event) {
-        const image = yield* eventImage(frame, `${NAME} partial image`, event.b64_json, format);
+        const image = yield* eventImage(frame, `${route.name} partial image`, event.b64_json, format, event.size);
         return [state, [ImagePartialEvent.make({ index: event.partial_image_index, image })]];
     }
-    const image = yield* eventImage(frame, `${NAME} result ${state.completed}`, event.b64_json, format);
+    const image = yield* eventImage(frame, `${route.name} result ${state.completed}`, event.b64_json, format, event.size);
     return [
-        { ...state, completed: state.completed + 1, format, usage: usage(event.usage) },
+        {
+            completed: state.completed + 1,
+            format,
+            size: event.size,
+            quality: event.quality,
+            background: event.background,
+            usage: usage(event.usage),
+        },
         [ImageOutputEvent.make({ index: state.completed, image })],
     ];
 });
 const onDocument = Effect.fn("OpenAIImages.onDocument")(function* (frame) {
-    const invalid = (message, cause) => MediaProtocol.frameError(ADAPTER, message, frame.document, cause);
-    const decoded = yield* decodeDocument(frame.document).pipe(Effect.mapError((cause) => invalid(`${NAME} returned an invalid response`, cause)));
+    const invalid = (message, cause) => route.frameError(message, frame.document, cause);
+    const decoded = yield* decodeDocument(frame.document).pipe(Effect.mapError((cause) => invalid(`${route.name} returned an invalid response`, cause)));
     const format = decoded.output_format ?? frame.requested ?? "png";
-    const mediaType = `image/${format}`;
-    const images = yield* Effect.forEach(decoded.data, (item, index) => {
-        const providerMetadata = item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } };
-        if (item.b64_json)
-            return MediaInput.decodedAsset(invalid, `${NAME} result ${index}`, item.b64_json, mediaType, {
-                info: { format },
-                providerMetadata,
-            });
-        if (item.url)
-            return Effect.succeed(Media.url(item.url, { mediaType, info: { format }, providerMetadata }));
-        return Effect.fail(invalid(`${NAME} result ${index} has neither image data nor a URL`));
-    });
+    const images = yield* Effect.forEach(decoded.data, (item, index) => MediaInput.decodedAsset(invalid, `${route.name} result ${index}`, item.b64_json, `image/${format}`, {
+        info: info(format, decoded.size),
+    }));
     if (images.length === 0)
-        return yield* invalid(`${NAME} returned no images`);
-    const state = { completed: images.length, format, usage: usage(decoded.usage) };
+        return yield* invalid(`${route.name} returned no images`);
+    const state = {
+        completed: images.length,
+        format,
+        size: decoded.size,
+        quality: decoded.quality,
+        background: decoded.background,
+        usage: usage(decoded.usage),
+    };
     return [state, images.map((image, index) => ImageOutputEvent.make({ index, image }))];
 });
 const step = (state, frame) => (typeof frame === "string" ? onEvent(state, frame) : onDocument(frame));
 const finish = (state) => {
     if (state.completed === 0)
-        return Effect.fail(MediaProtocol.incomplete(ADAPTER));
+        return Effect.fail(route.incomplete());
     return Effect.succeed([
-        ImageFinishEvent.make({ usage: state.usage, providerMetadata: { openai: { outputFormat: state.format } } }),
+        ImageFinishEvent.make({
+            usage: state.usage,
+            providerMetadata: {
+                openai: {
+                    outputFormat: state.format,
+                    size: state.size,
+                    quality: state.quality,
+                    background: state.background,
+                },
+            },
+        }),
     ]);
 };
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.stream({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.stream(route, {
     unsupported: ["aspectRatio", "seed"],
     body: { from: fromRequest },
     frames: (bytes, context) => context.request.mode === "stream"
@@ -193,13 +198,7 @@ export const protocol = MediaProtocol.stream({
     step,
     finish,
 });
-export const model = (input) => ImageModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
-    protocol,
-    baseURL: DEFAULT_BASE_URL,
-    path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH),
-}, input);
+export const model = (input) => ImageModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: ({ request }) => (isEdit(request) ? EDIT_PATH : PATH) }, input);
 export const OpenAIImages = {
     protocol,
     model,

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

@@ -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;
@@ -390,9 +390,9 @@ export declare const protocol: Protocol<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
-        readonly partial_images?: number | 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;
     } | {
@@ -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;
@@ -673,9 +673,9 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
-        readonly partial_images?: number | 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;
     } | {
@@ -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;
@@ -901,9 +901,9 @@ export declare const channelTransport: (options: import("./open-responses-channe
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
-        readonly partial_images?: number | 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;
     } | {
@@ -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;
@@ -1129,9 +1129,9 @@ export declare const transport: import("../route/transport/index.js").Transport<
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
-        readonly partial_images?: number | 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;
     } | {
@@ -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;
@@ -1357,9 +1357,9 @@ export declare const route: Route<{
         readonly size?: string | undefined;
         readonly action?: "generate" | "auto" | "edit" | undefined;
         readonly output_format?: "png" | "jpeg" | "webp" | undefined;
-        readonly partial_images?: number | 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;
     } | {

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, model) {
+const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (tool) {
     if (tool.type === "tool")
-        return yield* lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, model));
+        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, model))),
+        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",
@@ -166,9 +172,7 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request)
         ...(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, request.model)),
+        tools: request.tools.length === 0 ? undefined : yield* lowerTools(request),
         tool_choice: request.tools.length === 0
             ? undefined
             : (OpenResponses.allowedToolChoice(request) ??
@@ -178,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) {
@@ -267,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

@@ -5,13 +5,25 @@ 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";
-export type OpenAISpeechOptions = Record<string, unknown>;
+/** `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>;
 } | {
@@ -63,6 +75,14 @@ export declare const protocol: MediaProtocol.Streamed<Request, {
 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>;
     } | {

package/dist/protocols/openai-speech.js

@@ -2,12 +2,10 @@ 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 { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { mergeJsonRecords } from "../schema/index.js";
 import { SpeechModel } from "../speech.js";
 import { SpeechStream } from "./utils/speech-stream.js";
-const ADAPTER = "openai-speech";
-const NAME = "OpenAI Speech";
-const PROVIDER = ProviderID.make("openai");
+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. */
@@ -26,13 +24,16 @@ const SpeechStreamEvent = Schema.Union([
         })),
     }),
 ]);
-const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, SpeechStreamEvent);
+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,
@@ -71,9 +72,9 @@ const onEvent = Effect.fn("OpenAISpeech.onEvent")(function* (state, frame) {
 });
 const finish = (state, context) => {
     if (isSse(context.body) && !state.done)
-        return Effect.fail(MediaProtocol.incomplete(ADAPTER));
+        return Effect.fail(route.incomplete());
     const format = context.request.format ?? "mp3";
-    return SpeechStream.finish(ADAPTER, state, {
+    return SpeechStream.finish(route, state, {
         ...(format === "pcm" ? SpeechStream.pcm("pcm_s16le", PCM_SAMPLE_RATE) : SpeechStream.container(format)),
         usage: state.usage,
     });
@@ -81,17 +82,15 @@ const finish = (state, context) => {
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.stream({
-    id: ADAPTER,
-    name: NAME,
-    unsupported: ["language", "timestamps"],
+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({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const model = (input) => SpeechModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
 export const OpenAISpeech = {
     protocol,
     model,

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

@@ -41,6 +41,10 @@ declare const Transcript: Schema.Struct<{
         readonly input_tokens: Schema.optional<Schema.Number>;
         readonly output_tokens: Schema.optional<Schema.Number>;
         readonly total_tokens: Schema.optional<Schema.Number>;
+        readonly input_token_details: Schema.optional<Schema.Struct<{
+            readonly audio_tokens: Schema.optional<Schema.Number>;
+            readonly text_tokens: Schema.optional<Schema.Number>;
+        }>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"duration">;
         readonly seconds: Schema.Number;