@opencode/ai 2.0.16 → 2.0.17

package/dist/protocols/google-transcription.js

@@ -1,13 +1,10 @@
 import { Effect, Schema, SchemaGetter } from "effect";
 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 { TranscriptionFinishEvent, TranscriptionModel, TranscriptionSegmentEvent, TranscriptionTextDeltaEvent, } from "../transcription.js";
-import { ProviderShared } from "./shared.js";
 import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
-const ADAPTER = "google-transcription";
-const NAME = "Google Transcription";
-const PROVIDER = ProviderID.make("google");
+const route = MediaProtocol.identity({ id: "google-transcription", name: "Google Transcription", provider: "google" });
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
 // ---------------------------------------------------------------------------
 // 3. Streaming event schema
@@ -26,21 +23,16 @@ const AudioTranscription = Schema.Struct({
         speakerLabel: Schema.optional(Schema.String),
     }))),
 });
-const decodeChunk = MediaProtocol.decodeFrame(ADAPTER, NAME, GeminiGenerateContent.chunk(Schema.Struct({ audioTranscription: Schema.optional(AudioTranscription) })));
+const decodeChunk = route.decodeFrame(GeminiGenerateContent.chunk(Schema.Struct({ audioTranscription: Schema.optional(AudioTranscription) })));
 // ---------------------------------------------------------------------------
 // 5. Request body construction
 // ---------------------------------------------------------------------------
 const fromRequest = Effect.fn("GoogleTranscription.fromRequest")(function* (request) {
     // General Gemini models ignore `audioTranscriptionConfig` and answer the audio conversationally.
     if (!request.model.id.includes("transcribe"))
-        return yield* ProviderShared.unsupportedOperation({
-            operation: "transcription.model",
-            provider: PROVIDER,
-            route: ADAPTER,
-            message: `${request.model.id} is not a transcription model; use a transcribe model such as gemini-3.5-transcribe`,
-        });
+        return yield* route.unsupported("transcription.model", `${request.model.id} is not a transcription model; use a transcribe model such as gemini-3.5-transcribe`);
     return MediaProtocol.json(mergeJsonRecords({
-        contents: [{ role: "user", parts: [yield* GeminiGenerateContent.mediaPart(ADAPTER, request.audio)] }],
+        contents: [{ role: "user", parts: [yield* GeminiGenerateContent.mediaPart(route.id, request.audio)] }],
         generationConfig: mergeJsonRecords({
             audioTranscriptionConfig: {
                 languageCodes: request.language === undefined ? undefined : [request.language],
@@ -80,7 +72,7 @@ const turn = (part) => {
 };
 const step = Effect.fn("GoogleTranscription.step")(function* (state, frame) {
     const chunk = yield* decodeChunk(frame);
-    const blocked = GeminiGenerateContent.blocked(NAME, chunk, frame);
+    const blocked = GeminiGenerateContent.blocked(route.name, chunk, frame);
     if (blocked !== undefined)
         return yield* blocked;
     const turns = (chunk.candidates?.[0]?.content?.parts ?? []).flatMap((part) => part.audioTranscription === undefined ? [] : [turn(part.audioTranscription)]);
@@ -101,7 +93,7 @@ const step = Effect.fn("GoogleTranscription.step")(function* (state, frame) {
 });
 const finish = (state) => {
     if (state.finishReason === undefined)
-        return Effect.fail(MediaProtocol.incomplete(ADAPTER));
+        return Effect.fail(route.incomplete());
     return Effect.succeed([
         TranscriptionFinishEvent.make({
             text: state.text,
@@ -115,9 +107,7 @@ const finish = (state) => {
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.stream({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.stream(route, {
     unsupported: ["prompt", "speakers"],
     body: { from: fromRequest },
     frames: (bytes, context) => GeminiGenerateContent.frames(bytes, context.request.mode),
@@ -126,8 +116,6 @@ export const protocol = MediaProtocol.stream({
     finish,
 });
 export const model = (input) => TranscriptionModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
     protocol,
     baseURL: DEFAULT_BASE_URL,
     path: ({ request }) => GeminiGenerateContent.path(request.model.id, request.mode),

package/dist/protocols/google-video.d.ts

@@ -1,12 +1,12 @@
 import { Schema } from "effect";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
 import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js";
 export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
-export type GoogleVideoString<Known extends string> = Known | (string & {});
 /** Provider-native `parameters`. Common fields (`aspectRatio`, `resolution`, `durationSeconds`, `seed`) live on the request. */
 export type GoogleVideoOptions = {
-    readonly personGeneration?: GoogleVideoString<"allow_all" | "allow_adult" | "dont_allow">;
+    readonly personGeneration?: OpenString<"allow_all" | "allow_adult" | "dont_allow">;
 } & Record<string, unknown>;
 export type Request = VideoRequestFor<GoogleVideoOptions>;
 /** The long-running operation name, e.g. `models/veo-3.1-generate-preview/operations/abc123`. */

package/dist/protocols/google-video.js

@@ -2,12 +2,10 @@ import { Duration, 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 { mergeJsonRecords } from "../schema/index.js";
 import { VideoModel, VideoResponse } from "../video.js";
 import { ProviderShared, optionalArray } from "./shared.js";
-const ADAPTER = "google-video";
-const NAME = "Google Veo";
-const PROVIDER = ProviderID.make("google");
+const route = MediaProtocol.identity({ id: "google-video", name: "Google Veo", provider: "google" });
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
 /** Veo keeps generated files for two days; the asset carries that deadline so callers materialize in time. */
 const FILE_RETENTION = Duration.days(2);
@@ -38,24 +36,14 @@ const Operation = Schema.Struct({
 // 5. Request body construction
 // ---------------------------------------------------------------------------
 // Veo takes inline media only; a prior Veo output is `Media.url` with transient auth, so materialize it first.
-const inlineMedia = (asset) => ProviderShared.requireInlineMedia(NAME, asset).pipe(Effect.map((inline) => ({ inlineData: { mimeType: inline.mime, data: inline.base64 } })));
+const inlineMedia = (asset) => ProviderShared.requireInlineMedia(route.name, asset).pipe(Effect.map((inline) => ({ inlineData: { mimeType: inline.mime, data: inline.base64 } })));
 const fromRequest = Effect.fn("GoogleVideo.fromRequest")(function* (request) {
     if (request.n !== undefined && request.n > 1)
-        return yield* ProviderShared.unsupportedOperation({
-            operation: "video.n",
-            provider: PROVIDER,
-            route: ADAPTER,
-            message: `${NAME} generates one video per request; call it once per video instead of n=${request.n}`,
-        });
+        return yield* route.unsupported("video.n", `${route.name} generates one video per request; call it once per video instead of n=${request.n}`);
     if (request.audio === false)
-        return yield* ProviderShared.unsupportedOperation({
-            operation: "video.audio",
-            provider: PROVIDER,
-            route: ADAPTER,
-            message: `${NAME} always generates audio; audio: false cannot be honored`,
-        });
+        return yield* route.unsupported("video.audio", `${route.name} always generates audio; audio: false cannot be honored`);
     if (request.frames?.last !== undefined && request.frames.first === undefined)
-        return yield* ProviderShared.invalidRequest(`${NAME} requires frames.first when frames.last is set`);
+        return yield* ProviderShared.invalidRequest(`${route.name} requires frames.first when frames.last is set`);
     const image = request.frames?.first === undefined ? undefined : yield* inlineMedia(request.frames.first);
     const lastFrame = request.frames?.last === undefined ? undefined : yield* inlineMedia(request.frames.last);
     const video = request.video === undefined ? undefined : yield* inlineMedia(request.video);
@@ -82,7 +70,7 @@ const fromRequest = Effect.fn("GoogleVideo.fromRequest")(function* (request) {
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
-const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+const decodeStart = route.decodeStarted(StartResponse, (value) => ({
     token: { operation: value.name },
     snapshot: { id: value.name, status: "running" },
 }));
@@ -92,7 +80,7 @@ const statusOf = (operation) => {
         return "running";
     return operation.error === undefined ? "completed" : "failed";
 };
-const decodeOperation = MediaProtocol.decodeJson(ADAPTER, NAME, Operation);
+const decodeOperation = route.decodeJson(Operation);
 const decodeStatus = Effect.fn("GoogleVideo.decodeStatus")(function* (response, context) {
     const output = yield* decodeOperation(response);
     return { id: context.token.operation, status: statusOf(output.value) };
@@ -102,9 +90,9 @@ const decodeResult = Effect.fn("GoogleVideo.decodeResult")(function* (response,
     const operation = output.value;
     const status = statusOf(operation);
     if (status === "running")
-        return yield* output.invalid(`${NAME} operation ${context.token.operation} has not finished`);
+        return yield* output.pending(context.token.operation);
     if (status === "failed")
-        return yield* output.ended("failed", `${NAME} operation failed${operation.error?.message === undefined ? "" : `: ${operation.error.message}`}`);
+        return yield* output.ended("failed", `${route.name} operation failed${operation.error?.message === undefined ? "" : `: ${operation.error.message}`}`);
     const generated = operation.response?.generateVideoResponse;
     // Downloads require the same API key as the poll; the asset carries it transiently and follows the redirect.
     const videos = yield* Effect.forEach((generated?.generatedSamples ?? []).flatMap((sample) => sample.video?.uri === undefined ? [] : [{ uri: sample.video.uri, mimeType: sample.video.mimeType }]), (video) => MediaProtocol.expiringUrl(video.uri, FILE_RETENTION, {
@@ -114,13 +102,13 @@ const decodeResult = Effect.fn("GoogleVideo.decodeResult")(function* (response,
     const reasons = generated?.raiMediaFilteredReasons ?? [];
     const notices = reasons.map((reason) => ({
         type: "filtered",
-        message: `${NAME} filtered media: ${reason}`,
+        message: `${route.name} filtered media: ${reason}`,
         providerMetadata: { google: { raiMediaFilteredReason: reason } },
     }));
     if (videos.length === 0 && (reasons.length > 0 || (generated?.raiMediaFilteredCount ?? 0) > 0))
-        return yield* output.contentPolicy(`${NAME} filtered every video${reasons.length === 0 ? "" : `: ${reasons.join("; ")}`}`);
+        return yield* output.contentPolicy(`${route.name} filtered every video${reasons.length === 0 ? "" : `: ${reasons.join("; ")}`}`);
     if (videos.length === 0)
-        return yield* output.invalid(`${NAME} operation completed without any video`);
+        return yield* output.invalid(`${route.name} operation completed without any video`);
     return new VideoResponse({
         videos,
         notices: notices.length === 0 ? undefined : notices,
@@ -137,17 +125,13 @@ const decodeResult = Effect.fn("GoogleVideo.decodeResult")(function* (response,
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
 const operationPath = (token) => `/${token.operation}`;
-export const protocol = MediaProtocol.queued({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.queued(route, {
     token: Token,
     start: { body: { from: fromRequest }, decode: decodeStart },
     status: { path: operationPath, decode: decodeStatus },
     result: { path: operationPath, decode: decodeResult },
 });
 export const model = (input) => VideoModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
     protocol,
     baseURL: DEFAULT_BASE_URL,
     path: ({ request }) => `/models/${request.model.id}:predictLongRunning`,

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

@@ -1,7 +1,8 @@
 import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
-type OpenString<Known extends string> = Known | (string & {});
+import { type OpenString } from "../schema/index.js";
+export declare const DEFAULT_BASE_URL = "https://api.meta.ai/v1";
 /** Provider-native options. Common fields (`n`, `size`, `format`, `images`) live on the request. */
 export type ImageOptions = {
     readonly responseFormat?: OpenString<"b64_json" | "url">;
@@ -15,7 +16,5 @@ export type ImageOptions = {
 };
 export type Request = ImageRequestFor<ImageOptions>;
 export declare const protocol: MediaProtocol.Inline<Request, ImageResponse>;
-export declare const model: (input: MediaRoute.ModelInput & {
-    readonly baseURL: string;
-}) => ImageModel<ImageOptions>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<ImageOptions>;
 export * as MetaImages from "./meta-images.js";

package/dist/protocols/meta-images.js

@@ -3,12 +3,11 @@ 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 { mergeJsonRecords } from "../schema/index.js";
 import { JsonObject, ProviderShared, optionalNull } from "./shared.js";
 import { MediaInput } from "./utils/media-input.js";
-const ADAPTER = "meta-images";
-const NAME = "Meta Images";
-const PROVIDER = ProviderID.make("meta");
+const route = MediaProtocol.identity({ id: "meta-images", name: "Meta Images", provider: "meta" });
+export const DEFAULT_BASE_URL = "https://api.meta.ai/v1";
 // ---------------------------------------------------------------------------
 // 2. Request body and response schemas
 // ---------------------------------------------------------------------------
@@ -38,7 +37,7 @@ const Response = Schema.Struct({
 // ---------------------------------------------------------------------------
 const isEdit = (request) => (request.images?.length ?? 0) > 0;
 // Meta has no file handles: refs are rejected even when they name this provider.
-const reference = (asset) => ProviderShared.mediaReference(asset, undefined, NAME).pipe(Effect.map((item) => ({ image_url: item.value })));
+const reference = (asset) => ProviderShared.mediaReference(asset, undefined, route.name).pipe(Effect.map((item) => ({ image_url: item.value })));
 const fromRequest = Effect.fn("MetaImages.fromRequest")(function* (request) {
     const images = yield* Effect.forEach(request.images ?? [], reference);
     const { responseFormat, reasoningStrength, toolEnablement, ...native } = request.providerOptions ?? {};
@@ -58,23 +57,18 @@ const fromRequest = Effect.fn("MetaImages.fromRequest")(function* (request) {
 // ---------------------------------------------------------------------------
 // 6. Response decoding
 // ---------------------------------------------------------------------------
+const decodeDocument = route.decodeJson(Response);
 const decodeResponse = Effect.fn("MetaImages.decodeResponse")(function* (response, context) {
-    const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, Response)(response);
+    const output = yield* decodeDocument(response);
     const decoded = output.value;
     const requested = context.body.type === "json" ? context.body.value.output_format : undefined;
     const format = decoded.output_format ?? (typeof requested === "string" ? requested : "webp");
     const mediaType = `image/${format}`;
-    const images = yield* Effect.forEach(decoded.data, (item, index) => {
-        if (item.b64_json)
-            return MediaInput.decodedAsset(output.invalid, `${NAME} result ${index}`, item.b64_json, mediaType, {
-                info: { format },
-            });
-        if (item.url)
-            return Effect.succeed(Media.url(item.url, { mediaType, info: { format } }));
-        return Effect.fail(output.invalid(`${NAME} result ${index} has neither image data nor a URL`));
-    });
+    const images = yield* Effect.forEach(decoded.data, (item, index) => MediaInput.imageOutput(output.invalid, `${route.name} result ${index}`, item, mediaType, {
+        info: { format },
+    }));
     if (images.length === 0)
-        return yield* output.invalid(`${NAME} returned no images`);
+        return yield* output.invalid(`${route.name} returned no images`);
     return new ImageResponse({
         images,
         usage: decoded.usage === undefined
@@ -92,17 +86,14 @@ const decodeResponse = Effect.fn("MetaImages.decodeResponse")(function* (respons
 // ---------------------------------------------------------------------------
 // 7. Protocol and route
 // ---------------------------------------------------------------------------
-export const protocol = MediaProtocol.inline({
-    id: ADAPTER,
-    name: NAME,
+export const protocol = MediaProtocol.inline(route, {
     unsupported: ["mask", "aspectRatio", "seed"],
     body: { from: fromRequest },
     response: { decode: decodeResponse },
 });
 export const model = (input) => ImageModel.fromRoute({
-    id: ADAPTER,
-    provider: PROVIDER,
     protocol,
+    baseURL: DEFAULT_BASE_URL,
     path: ({ request }) => `/images/${isEdit(request) ? "edits" : "generations"}`,
 }, input);
 export * as MetaImages from "./meta-images.js";

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

@@ -221,20 +221,20 @@ export declare const protocol: Protocol<{
     readonly thinking?: {
         readonly type: "enabled";
         readonly budget_tokens: number;
-        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
+        readonly display?: import("../schema/options.js").OpenString<"summarized" | "omitted"> | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
+            readonly prefix_mismatch_behavior?: import("../schema/options.js").OpenString<"error" | "drop_block"> | undefined;
         } | undefined;
     } | {
         readonly type: "adaptive";
-        readonly display?: (string & {}) | "summarized" | "omitted" | undefined;
+        readonly display?: import("../schema/options.js").OpenString<"summarized" | "omitted"> | undefined;
         readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: (string & {}) | "error" | "drop_block" | undefined;
+            readonly prefix_mismatch_behavior?: import("../schema/options.js").OpenString<"error" | "drop_block"> | undefined;
         } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
-    readonly service_tier?: "auto" | (string & {}) | "standard_only" | undefined;
+    readonly service_tier?: import("../schema/options.js").OpenString<"auto" | "standard_only"> | undefined;
     readonly container?: string | {
         readonly id?: string | null | undefined;
         readonly skills?: readonly {

package/dist/protocols/meta-responses.js

@@ -5,8 +5,7 @@ import { LLMEvent, LLMRequest, Message, ToolResultPart } from "../schema/index.j
 import { OpenResponses } from "./open-responses.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
-import { MetaImage } from "./utils/meta-image.js";
+import { detectMediaType } from "../utils/media-type.js";
 const ADAPTER = "meta-responses";
 const NAME = "Meta Responses";
 export const WebSearch = Schema.Struct({
@@ -82,7 +81,7 @@ const fromRequest = Effect.fn("MetaResponses.fromRequest")(function* (request) {
             ? undefined
             : yield* Effect.forEach(projected.tools, (tool) => Effect.gen(function* () {
                 if (tool.native === undefined)
-                    return yield* OpenResponses.lowerTool(NAME, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model));
+                    return yield* OpenResponses.lowerTool(NAME, tool);
                 return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(NativeTool))(tool.native.meta);
             })),
         tool_choice: OpenResponses.allowedToolChoice(request) ??
@@ -101,7 +100,10 @@ const HOSTED_TOOLS = {
             if (!item.result)
                 return yield* ProviderShared.eventError(ADAPTER, "Meta returned an image without data", ProviderShared.encodeJson(raw));
             const data = yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Meta returned invalid image base64", ProviderShared.encodeJson(raw), cause)));
-            const mime = MetaImage.mediaType(data, item.output_format);
+            // Responses image items can omit output_format, including when PNG/JPEG was requested.
+            const mime = item.output_format === undefined
+                ? (detectMediaType(data) ?? "application/octet-stream")
+                : `image/${item.output_format}`;
             return {
                 type: "content",
                 value: [{ type: "file", uri: `data:${mime};base64,${item.result}`, mime }],

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

@@ -716,9 +716,7 @@ interface ReasoningStreamItem {
     readonly summaryParts: Readonly<Record<number, ReasoningSummaryStatus>>;
     readonly deltaIndexes: ReadonlySet<number>;
 }
-export declare const lowerTool: (protocolName: string, tool: ToolDefinition, inputSchema: {
-    readonly [x: string]: unknown;
-}) => Effect.Effect<{
+export declare const lowerTool: (protocolName: string, tool: ToolDefinition) => Effect.Effect<{
     type: "function";
     name: string;
     description: string;
@@ -727,6 +725,9 @@ export declare const lowerTool: (protocolName: string, tool: ToolDefinition, inp
     };
     strict: boolean;
 }, AIError, never>;
+export declare const lowerTools: (tools: ReadonlyArray<ToolDefinition>, adapter: ProviderAdapter) => Effect.Effect<{
+    readonly type: string;
+}[], AIError, never>;
 export declare const lowerToolChoice: (protocolName: string, toolChoice: NonNullable<LLMRequest["toolChoice"]>) => Effect.Effect<"required" | "auto" | "none" | {
     type: "function";
     name: string;

package/dist/protocols/open-responses.js

@@ -7,7 +7,6 @@ import { classifyProviderFailure } from "../provider-error.js";
 import { effortUpdate } from "../effort-updates.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 import { Lifecycle } from "./utils/lifecycle.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "open-responses";
 const NAME = "Open Responses";
@@ -281,18 +280,19 @@ const BASE_ADAPTER = { id: ADAPTER, name: NAME };
 // =============================================================================
 // Request Lowering
 // =============================================================================
-export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protocolName, tool, inputSchema) {
+export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protocolName, tool) {
     if (tool.native !== undefined)
         return yield* ProviderShared.invalidRequest(`${protocolName} does not support provider-native tool ${tool.name}`);
     return {
         type: "function",
         name: tool.name,
         description: tool.description,
-        parameters: inputSchema,
+        parameters: tool.inputSchema,
         // The common tool definition does not currently express Responses strict-schema policy.
         strict: false,
     };
 });
+export const lowerTools = (tools, adapter) => Effect.forEach(tools, (tool) => tool.native !== undefined && adapter.nativeTool ? adapter.nativeTool(tool.native) : lowerTool(adapter.name, tool));
 export const lowerToolChoice = (protocolName, toolChoice) => ProviderShared.matchToolChoice(protocolName, toolChoice, {
     auto: () => "auto",
     none: () => "none",
@@ -606,11 +606,7 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
     return {
         ...(yield* lowerConversation(projected.request, adapter)),
         ...lowerGeneration(request),
-        tools: projected.tools.length === 0
-            ? undefined
-            : yield* Effect.forEach(projected.tools, (tool) => tool.native !== undefined && adapter.nativeTool
-                ? adapter.nativeTool(tool.native)
-                : lowerTool(adapter.name, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model))),
+        tools: projected.tools.length === 0 ? undefined : yield* lowerTools(projected.tools, adapter),
         tool_choice: allowedToolChoice(request) ??
             (request.toolChoice ? yield* lowerToolChoice(adapter.name, request.toolChoice) : undefined),
     };

package/dist/protocols/openai-chat.js

@@ -11,7 +11,6 @@ import { classifyProviderFailure } from "../provider-error.js";
 import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { OpenAIOptions } from "./utils/openai-options.js";
 import { Lifecycle } from "./utils/lifecycle.js";
-import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "openai-chat";
 const RESERVED_REASONING_FIELDS = new Set(["role", "content", "refusal", "tool_calls"]);
@@ -209,12 +208,12 @@ export const OpenAIChatEvent = Schema.StructWithRest(Schema.Struct({
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
 const DONE = "[DONE]";
 const OpenAIChatStreamEvent = Schema.Union([Schema.Literal(DONE), Protocol.jsonEvent(OpenAIChatEvent)]);
-const lowerTool = (tool, inputSchema, options, supportsStrictMode) => ({
+const lowerTool = (tool, options, supportsStrictMode) => ({
     type: "function",
     function: {
         name: tool.name,
         description: tool.description,
-        parameters: inputSchema,
+        parameters: tool.inputSchema,
         ...(supportsStrictMode ? { strict: false } : {}),
     },
     cache_control: options.cacheControl?.(tool.cache),
@@ -649,7 +648,7 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (reques
             ? hasHistory
                 ? []
                 : undefined
-            : flattened.tools.map((tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model), options, supportsStrictMode)),
+            : flattened.tools.map((tool) => lowerTool(tool, options, supportsStrictMode)),
         tool_choice: hasActiveTools && request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
         stream: true,
         ...(supportsUsageInStreaming ? { stream_options: { include_usage: true } } : {}),

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

@@ -2,16 +2,15 @@ import { ImageModel, type ImageRequestFor } from "../image.js";
 import { Media } from "../media.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
-import { type MediaUsage } from "../schema/index.js";
+import { type MediaUsage, type OpenString } from "../schema/index.js";
 export declare const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export declare const PATH = "/images/generations";
 export declare const EDIT_PATH = "/images/edits";
-export type OpenAIImageString<Known extends string> = Known | (string & {});
 /** Provider-native options. Common fields (`n`, `size`, `format`, `images`, `mask`) live on the request. */
 export type OpenAIImageOptions = {
-    readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">;
-    readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">;
-    readonly moderation?: OpenAIImageString<"auto" | "low">;
+    readonly quality?: OpenString<"auto" | "low" | "medium" | "high" | "standard" | "hd">;
+    readonly background?: OpenString<"auto" | "opaque" | "transparent">;
+    readonly moderation?: OpenString<"auto" | "low">;
     readonly outputCompression?: number;
     /** Previews sent before the final image when streaming (default 2); ignored by `Image.generate`. */
     readonly partialImages?: number;
@@ -25,6 +24,9 @@ type Frame = string | {
 interface State {
     readonly completed: number;
     readonly format?: string;
+    readonly size?: string;
+    readonly quality?: string;
+    readonly background?: string;
     readonly usage?: MediaUsage;
 }
 export declare const protocol: MediaProtocol.Streamed<Request, {