@opencode-ai/ai 0.0.0-beta-17492

package/dist/protocols/utils/bedrock-auth.js

@@ -0,0 +1,43 @@
+import { AwsV4Signer } from "aws4fetch";
+import { Effect } from "effect";
+import { Headers } from "effect/unstable/http";
+import { Auth } from "../../route/auth.js";
+import { ProviderShared } from "../shared.js";
+const signRequest = (input) => Effect.tryPromise({
+    try: async () => {
+        const signed = await new AwsV4Signer({
+            url: input.url,
+            method: "POST",
+            headers: Object.entries(input.headers),
+            body: input.body,
+            region: input.credentials.region,
+            accessKeyId: input.credentials.accessKeyId,
+            secretAccessKey: input.credentials.secretAccessKey,
+            sessionToken: input.credentials.sessionToken,
+            service: input.service,
+        }).sign();
+        return Object.fromEntries(signed.headers.entries());
+    },
+    catch: (error) => ProviderShared.invalidRequest(`${input.name} SigV4 signing failed: ${error instanceof Error ? error.message : String(error)}`),
+});
+/** Sign the exact JSON bytes with SigV4 using credentials configured on the route. */
+export const sigV4 = (credentials, options = {}) => Auth.custom((input) => {
+    return Effect.gen(function* () {
+        if (!credentials) {
+            return yield* ProviderShared.invalidRequest(`${options.name ?? "Bedrock Converse"} requires either route bearer auth or AWS credentials configured on the route`);
+        }
+        const headersForSigning = Headers.set(input.headers, "content-type", "application/json");
+        const signed = yield* signRequest({
+            url: input.url,
+            body: input.body,
+            headers: headersForSigning,
+            credentials,
+            service: options.service ?? "bedrock",
+            name: options.name ?? "Bedrock Converse",
+        });
+        return Headers.setAll(headersForSigning, signed);
+    });
+});
+/** Bedrock route auth defaults to SigV4 and expects credentials from route configuration. */
+export const auth = sigV4(undefined);
+export * as BedrockAuth from "./bedrock-auth.js";

package/dist/protocols/utils/bedrock-cache.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+import type { CacheHint } from "../../schema/index.js";
+import { type Breakpoints } from "./cache.js";
+export declare const CachePointBlock: Schema.Struct<{
+    readonly cachePoint: Schema.Struct<{
+        readonly type: Schema.tag<"default">;
+        readonly ttl: Schema.optional<Schema.Literals<readonly ["5m", "1h"]>>;
+    }>;
+}>;
+export type CachePointBlock = Schema.Schema.Type<typeof CachePointBlock>;
+export declare const BEDROCK_BREAKPOINT_CAP = 4;
+export type { Breakpoints } from "./cache.js";
+export declare const breakpoints: () => Breakpoints;
+export declare const block: (breakpoints: Breakpoints, cache: CacheHint | undefined) => CachePointBlock | undefined;
+export * as BedrockCache from "./bedrock-cache.js";

package/dist/protocols/utils/bedrock-cache.js

@@ -0,0 +1,29 @@
+import { Schema } from "effect";
+import { newBreakpoints, ttlBucket } from "./cache.js";
+// Bedrock cache markers are positional: emit a `cachePoint` block immediately
+// after the content the caller wants treated as a cacheable prefix. Bedrock
+// accepts optional `ttl: "5m" | "1h"` on cachePoint, mirroring Anthropic.
+export const CachePointBlock = Schema.Struct({
+    cachePoint: Schema.Struct({
+        type: Schema.tag("default"),
+        ttl: Schema.optional(Schema.Literals(["5m", "1h"])),
+    }),
+});
+// Bedrock-Claude enforces the same 4-breakpoint cap as the Anthropic Messages
+// API. Callers pass a shared counter through every `block()` call site so the
+// budget is respected across `system`, `messages`, and `tools`.
+export const BEDROCK_BREAKPOINT_CAP = 4;
+export const breakpoints = () => newBreakpoints(BEDROCK_BREAKPOINT_CAP);
+const DEFAULT_5M = { cachePoint: { type: "default" } };
+const DEFAULT_1H = { cachePoint: { type: "default", ttl: "1h" } };
+export const block = (breakpoints, cache) => {
+    if (cache?.type !== "ephemeral" && cache?.type !== "persistent")
+        return undefined;
+    if (breakpoints.remaining <= 0) {
+        breakpoints.dropped += 1;
+        return undefined;
+    }
+    breakpoints.remaining -= 1;
+    return ttlBucket(cache.ttlSeconds) === "1h" ? DEFAULT_1H : DEFAULT_5M;
+};
+export * as BedrockCache from "./bedrock-cache.js";

package/dist/protocols/utils/bedrock-media.d.ts

@@ -0,0 +1,49 @@
+import { Effect, Schema } from "effect";
+export declare const ImageFormat: Schema.Literals<readonly ["png", "jpeg", "gif", "webp"]>;
+export type ImageFormat = Schema.Schema.Type<typeof ImageFormat>;
+export declare const ImageBlock: Schema.Struct<{
+    readonly image: Schema.Struct<{
+        readonly format: Schema.Literals<readonly ["png", "jpeg", "gif", "webp"]>;
+        readonly source: Schema.Struct<{
+            readonly bytes: Schema.String;
+        }>;
+    }>;
+}>;
+export type ImageBlock = Schema.Schema.Type<typeof ImageBlock>;
+export declare const DocumentFormat: Schema.Literals<readonly ["pdf", "csv", "doc", "docx", "xls", "xlsx", "html", "txt", "md"]>;
+export type DocumentFormat = Schema.Schema.Type<typeof DocumentFormat>;
+export declare const DocumentBlock: Schema.Struct<{
+    readonly document: Schema.Struct<{
+        readonly format: Schema.Literals<readonly ["pdf", "csv", "doc", "docx", "xls", "xlsx", "html", "txt", "md"]>;
+        readonly name: Schema.String;
+        readonly source: Schema.Struct<{
+            readonly bytes: Schema.String;
+        }>;
+    }>;
+}>;
+export type DocumentBlock = Schema.Schema.Type<typeof DocumentBlock>;
+export declare const lower: (part: {
+    readonly data: string | Uint8Array<ArrayBufferLike>;
+    readonly type: "media";
+    readonly mediaType: string;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+    readonly filename?: string | undefined;
+}) => Effect.Effect<{
+    readonly document: {
+        readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+        readonly name: string;
+        readonly source: {
+            readonly bytes: string;
+        };
+    };
+} | {
+    image: {
+        format: "png" | "jpeg" | "gif" | "webp";
+        source: {
+            bytes: string;
+        };
+    };
+}, import("../../schema/errors.js").AIError, never>;
+export * as BedrockMedia from "./bedrock-media.js";

package/dist/protocols/utils/bedrock-media.js

@@ -0,0 +1,70 @@
+import { Effect, Schema } from "effect";
+import { ProviderShared } from "../shared.js";
+// Bedrock Converse accepts image `format` as the file extension and
+// `source.bytes` as base64 in the JSON wire format.
+export const ImageFormat = Schema.Literals(["png", "jpeg", "gif", "webp"]);
+export const ImageBlock = Schema.Struct({
+    image: Schema.Struct({
+        format: ImageFormat,
+        source: Schema.Struct({ bytes: Schema.String }),
+    }),
+});
+// Bedrock document blocks require a user-facing name so the model can refer to
+// the uploaded document.
+export const DocumentFormat = Schema.Literals(["pdf", "csv", "doc", "docx", "xls", "xlsx", "html", "txt", "md"]);
+export const DocumentBlock = Schema.Struct({
+    document: Schema.Struct({
+        format: DocumentFormat,
+        name: Schema.String,
+        source: Schema.Struct({ bytes: Schema.String }),
+    }),
+});
+const IMAGE_FORMATS = {
+    "image/png": "png",
+    "image/jpeg": "jpeg",
+    "image/jpg": "jpeg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+};
+const DOCUMENT_FORMATS = {
+    "application/pdf": "pdf",
+    "text/csv": "csv",
+    "application/msword": "doc",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+    "application/vnd.ms-excel": "xls",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+    "text/html": "html",
+    "text/plain": "txt",
+    "text/markdown": "md",
+};
+const documentBlock = (name, format, bytes) => ({
+    document: {
+        format,
+        name,
+        source: { bytes },
+    },
+});
+// Route by MIME. Known image/document formats lower into a typed block; anything
+// else fails with a clear error instead of silently degrading to a malformed
+// document block. Image MIME types not in `IMAGE_FORMATS` (e.g. `image/svg+xml`)
+// get an image-specific error so the caller knows it's a format-support issue,
+// not a kind-detection issue.
+export const lower = Effect.fn("BedrockMedia.lower")(function* (part) {
+    const mime = part.mediaType.toLowerCase();
+    const imageFormat = IMAGE_FORMATS[mime];
+    if (imageFormat) {
+        const media = yield* ProviderShared.validateMedia("Bedrock Converse", part, new Set(Object.keys(IMAGE_FORMATS)));
+        return { image: { format: imageFormat, source: { bytes: media.base64 } } };
+    }
+    if (mime.startsWith("image/"))
+        return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support image media type ${part.mediaType}`);
+    const documentFormat = DOCUMENT_FORMATS[mime];
+    if (documentFormat) {
+        if (!part.filename)
+            return yield* ProviderShared.invalidRequest("Bedrock Converse document media requires a filename");
+        const media = yield* ProviderShared.validateMedia("Bedrock Converse", part, new Set(Object.keys(DOCUMENT_FORMATS)));
+        return documentBlock(part.filename, documentFormat, media.base64);
+    }
+    return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support media type ${part.mediaType}`);
+});
+export * as BedrockMedia from "./bedrock-media.js";

package/dist/protocols/utils/cache.d.ts

@@ -0,0 +1,6 @@
+export interface Breakpoints {
+    remaining: number;
+    dropped: number;
+}
+export declare const newBreakpoints: (cap: number) => Breakpoints;
+export declare const ttlBucket: (ttlSeconds: number | undefined) => "1h" | undefined;

package/dist/protocols/utils/cache.js

@@ -0,0 +1,8 @@
+// Shared helpers for provider cache-marker lowering. Anthropic and Bedrock
+// both enforce a 4-breakpoint cap per request and accept the same `5m`/`1h`
+// TTL buckets, so the counter and TTL mapping live here.
+export const newBreakpoints = (cap) => ({ remaining: cap, dropped: 0 });
+// Returns `"1h"` for any `ttlSeconds >= 3600`, otherwise `undefined` (the
+// provider default 5m). Anthropic & Bedrock both treat anything shorter than
+// an hour as 5m.
+export const ttlBucket = (ttlSeconds) => ttlSeconds !== undefined && ttlSeconds >= 3600 ? "1h" : undefined;

package/dist/protocols/utils/gemini-tool-schema.d.ts

@@ -0,0 +1,2 @@
+export declare const convert: (schema: unknown) => Record<string, unknown> | undefined;
+export * as GeminiToolSchema from "./gemini-tool-schema.js";

package/dist/protocols/utils/gemini-tool-schema.js

@@ -0,0 +1,103 @@
+import { isRecord } from "../../utils/record.js";
+// Gemini accepts a JSON Schema-like dialect for tool parameters, but rejects a
+// handful of common JSON Schema shapes. Keep this projection isolated so the
+// Gemini protocol file still reads like the other protocol modules.
+const SCHEMA_INTENT_KEYS = [
+    "type",
+    "properties",
+    "items",
+    "prefixItems",
+    "enum",
+    "const",
+    "$ref",
+    "additionalProperties",
+    "patternProperties",
+    "required",
+    "not",
+    "if",
+    "then",
+    "else",
+];
+const hasCombiner = (schema) => isRecord(schema) && (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf) || Array.isArray(schema.allOf));
+const hasSchemaIntent = (schema) => isRecord(schema) && (hasCombiner(schema) || SCHEMA_INTENT_KEYS.some((key) => key in schema));
+const sanitizeNode = (schema) => {
+    if (!isRecord(schema))
+        return Array.isArray(schema) ? schema.map(sanitizeNode) : schema;
+    const result = Object.fromEntries(Object.entries(schema).map(([key, value]) => [
+        key,
+        key === "enum" && Array.isArray(value) ? value.map(String) : sanitizeNode(value),
+    ]));
+    if (Array.isArray(result.enum) && (result.type === "integer" || result.type === "number"))
+        result.type = "string";
+    const properties = result.properties;
+    if (result.type === "object" && isRecord(properties) && Array.isArray(result.required)) {
+        result.required = result.required.filter((field) => typeof field === "string" && field in properties);
+    }
+    if (result.type === "array" && !hasCombiner(result)) {
+        result.items = result.items ?? {};
+        if (isRecord(result.items) && !hasSchemaIntent(result.items))
+            result.items = { ...result.items, type: "string" };
+    }
+    if (typeof result.type === "string" && result.type !== "object" && !hasCombiner(result)) {
+        delete result.properties;
+        delete result.required;
+    }
+    return result;
+};
+const emptyObjectSchema = (schema) => schema.type === "object" &&
+    (!isRecord(schema.properties) || Object.keys(schema.properties).length === 0) &&
+    !schema.additionalProperties;
+const projectNode = (schema, nested = false) => {
+    if (!isRecord(schema))
+        return undefined;
+    if (!nested && emptyObjectSchema(schema))
+        return undefined;
+    const types = Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null") : undefined;
+    const anyOf = Array.isArray(schema.anyOf) ? schema.anyOf : undefined;
+    const hasNullAnyOf = anyOf?.some((item) => isRecord(item) && item.type === "null") ?? false;
+    const anyOfTypes = hasNullAnyOf ? anyOf?.filter((item) => !isRecord(item) || item.type !== "null") : anyOf;
+    const flattenedAnyOf = hasNullAnyOf && anyOfTypes?.length === 1 ? projectNode(anyOfTypes[0], true) : undefined;
+    const result = Object.fromEntries([
+        ["description", schema.description],
+        ["required", schema.required],
+        ["format", schema.format],
+        ["type", types ? (types.length === 0 ? "null" : undefined) : schema.type],
+        [
+            "nullable",
+            (Array.isArray(schema.type) && schema.type.includes("null") && types && types.length > 0) || hasNullAnyOf
+                ? true
+                : undefined,
+        ],
+        ["enum", schema.const !== undefined ? [schema.const] : schema.enum],
+        [
+            "properties",
+            isRecord(schema.properties)
+                ? Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [key, projectNode(value, true)]))
+                : undefined,
+        ],
+        [
+            "items",
+            Array.isArray(schema.items)
+                ? schema.items.map((item) => projectNode(item, true))
+                : schema.items === undefined
+                    ? undefined
+                    : projectNode(schema.items, true),
+        ],
+        ["allOf", Array.isArray(schema.allOf) ? schema.allOf.map((item) => projectNode(item, true)) : undefined],
+        [
+            "anyOf",
+            anyOfTypes
+                ? hasNullAnyOf && anyOfTypes.length === 1
+                    ? undefined
+                    : anyOfTypes.map((item) => projectNode(item, true))
+                : types && types.length > 0
+                    ? types.map((type) => ({ type }))
+                    : undefined,
+        ],
+        ["oneOf", Array.isArray(schema.oneOf) ? schema.oneOf.map((item) => projectNode(item, true)) : undefined],
+        ["minLength", schema.minLength],
+    ].filter((entry) => entry[1] !== undefined));
+    return flattenedAnyOf ? { ...result, ...flattenedAnyOf } : result;
+};
+export const convert = (schema) => projectNode(sanitizeNode(schema));
+export * as GeminiToolSchema from "./gemini-tool-schema.js";

package/dist/protocols/utils/image-input.d.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import type { ImageInput } from "../../image.js";
+import { AIError } from "../../schema/index.js";
+export declare const dataUrl: (input: Extract<ImageInput, {
+    readonly type: "bytes";
+}>) => string;
+export declare const decodeDataUrl: (url: string, module: string) => Effect.Effect<{
+    readonly mediaType: string;
+    readonly data: Uint8Array;
+} | undefined, AIError>;
+export declare const invalidImageInput: (module: string, message: string) => AIError;
+export declare const ImageInputs: {
+    readonly dataUrl: (input: Extract<ImageInput, {
+        readonly type: "bytes";
+    }>) => string;
+    readonly decodeDataUrl: (url: string, module: string) => Effect.Effect<{
+        readonly mediaType: string;
+        readonly data: Uint8Array;
+    } | undefined, AIError>;
+    readonly invalid: (module: string, message: string) => AIError;
+};

package/dist/protocols/utils/image-input.js

@@ -0,0 +1,22 @@
+import { Effect, Encoding } from "effect";
+import { InvalidRequestReason, AIError } from "../../schema/index.js";
+const invalid = (module, message) => new AIError({
+    module,
+    method: "generate",
+    reason: new InvalidRequestReason({ message }),
+});
+export const dataUrl = (input) => `data:${input.mediaType};base64,${Encoding.encodeBase64(input.data)}`;
+export const decodeDataUrl = (url, module) => {
+    if (!url.startsWith("data:"))
+        return Effect.succeed(undefined);
+    const match = /^data:([^;,]+);base64,(.*)$/s.exec(url);
+    if (!match)
+        return Effect.fail(invalid(module, "Image data URLs must contain a MIME type and base64 data"));
+    return Effect.fromResult(Encoding.decodeBase64(match[2])).pipe(Effect.mapError(() => invalid(module, "Image data URL contains invalid base64 data")), Effect.map((data) => ({ mediaType: match[1], data })));
+};
+export const invalidImageInput = invalid;
+export const ImageInputs = {
+    dataUrl,
+    decodeDataUrl,
+    invalid: invalidImageInput,
+};

package/dist/protocols/utils/lifecycle.d.ts

@@ -0,0 +1,20 @@
+import { LLMEvent, type FinishReasonDetails, type ProviderMetadata, type Usage } from "../../schema/index.js";
+export interface State {
+    readonly stepStarted: boolean;
+    readonly text: ReadonlySet<string>;
+    readonly reasoning: ReadonlySet<string>;
+}
+export declare const initial: () => State;
+export declare const stepStart: (state: State, events: LLMEvent[]) => State;
+export declare const textStart: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
+export declare const textDelta: (state: State, events: LLMEvent[], id: string, text: string) => State;
+export declare const reasoningStart: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
+export declare const reasoningDelta: (state: State, events: LLMEvent[], id: string, text: string, providerMetadata?: ProviderMetadata) => State;
+export declare const reasoningEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
+export declare const textEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
+export declare const finish: (state: State, events: LLMEvent[], input: {
+    readonly reason: FinishReasonDetails;
+    readonly usage?: Usage;
+    readonly providerMetadata?: ProviderMetadata;
+}) => State;
+export * as Lifecycle from "./lifecycle.js";

package/dist/protocols/utils/lifecycle.js

@@ -0,0 +1,68 @@
+import { LLMEvent } from "../../schema/index.js";
+export const initial = () => ({ stepStarted: false, text: new Set(), reasoning: new Set() });
+export const stepStart = (state, events) => {
+    if (state.stepStarted)
+        return state;
+    events.push(LLMEvent.stepStart({ index: 0 }));
+    return { ...state, stepStarted: true };
+};
+export const textStart = (state, events, id, providerMetadata) => {
+    if (state.text.has(id))
+        return state;
+    const stepped = stepStart(state, events);
+    events.push(LLMEvent.textStart({ id, providerMetadata }));
+    return { ...stepped, text: new Set([...stepped.text, id]) };
+};
+export const textDelta = (state, events, id, text) => {
+    const started = textStart(state, events, id);
+    events.push(LLMEvent.textDelta({ id, text }));
+    return started;
+};
+export const reasoningStart = (state, events, id, providerMetadata) => {
+    if (state.reasoning.has(id))
+        return state;
+    const stepped = stepStart(state, events);
+    events.push(LLMEvent.reasoningStart({ id, providerMetadata }));
+    return { ...stepped, reasoning: new Set([...stepped.reasoning, id]) };
+};
+export const reasoningDelta = (state, events, id, text, providerMetadata) => {
+    const started = reasoningStart(state, events, id, providerMetadata);
+    events.push(LLMEvent.reasoningDelta({ id, text, providerMetadata }));
+    return started;
+};
+export const reasoningEnd = (state, events, id, providerMetadata) => {
+    if (!state.reasoning.has(id))
+        return state;
+    const stepped = stepStart(state, events);
+    events.push(LLMEvent.reasoningEnd({ id, providerMetadata }));
+    const reasoning = new Set(stepped.reasoning);
+    reasoning.delete(id);
+    return { ...stepped, reasoning };
+};
+export const textEnd = (state, events, id, providerMetadata) => {
+    if (!state.text.has(id))
+        return state;
+    const stepped = stepStart(state, events);
+    events.push(LLMEvent.textEnd({ id, providerMetadata }));
+    const text = new Set(stepped.text);
+    text.delete(id);
+    return { ...stepped, text };
+};
+const closeOpenBlocks = (state, events) => {
+    for (const id of state.reasoning)
+        events.push(LLMEvent.reasoningEnd({ id }));
+    for (const id of state.text)
+        events.push(LLMEvent.textEnd({ id }));
+    return { ...state, text: new Set(), reasoning: new Set() };
+};
+export const finish = (state, events, input) => {
+    const stepped = closeOpenBlocks(stepStart(state, events), events);
+    events.push(LLMEvent.stepFinish({
+        index: 0,
+        reason: input.reason,
+        usage: input.usage,
+        providerMetadata: input.providerMetadata,
+    }), LLMEvent.finish(input));
+    return { ...stepped, stepStarted: false };
+};
+export * as Lifecycle from "./lifecycle.js";

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

@@ -0,0 +1,21 @@
+import { Schema } from "effect";
+import { TextVerbosity, type LLMRequest } from "../../schema/index.js";
+export declare const ResponseIncludables: readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"];
+export type ResponseIncludable = (typeof ResponseIncludables)[number];
+export declare const ServiceTiers: readonly ["auto", "default", "flex", "priority"];
+export type ServiceTier = (typeof ServiceTiers)[number];
+export declare const ReasoningEffort: Schema.String;
+export declare const TextVerbositySchema: Schema.Literals<readonly ["low", "medium", "high"]>;
+export declare const ResponseIncludableSchema: Schema.Literals<readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"]>;
+export declare const ServiceTierSchema: Schema.Literals<readonly ["auto", "default", "flex", "priority"]>;
+export interface Resolved {
+    readonly instructions?: string;
+    readonly store?: boolean;
+    readonly reasoningEffort?: string;
+    readonly reasoningSummary?: "auto" | "concise" | "detailed";
+    readonly include?: ReadonlyArray<ResponseIncludable>;
+    readonly textVerbosity?: Schema.Schema.Type<typeof TextVerbosity>;
+    readonly serviceTier?: ServiceTier;
+}
+export declare const resolve: (request: LLMRequest) => Resolved;
+export * as OpenResponsesOptions from "./open-responses-options.js";

package/dist/protocols/utils/open-responses-options.js

@@ -0,0 +1,41 @@
+import { Schema } from "effect";
+import { TextVerbosity } from "../../schema/index.js";
+export const ResponseIncludables = [
+    "file_search_call.results",
+    "web_search_call.results",
+    "web_search_call.action.sources",
+    "message.input_image.image_url",
+    "computer_call_output.output.image_url",
+    "code_interpreter_call.outputs",
+    "reasoning.encrypted_content",
+    "message.output_text.logprobs",
+];
+export const ServiceTiers = ["auto", "default", "flex", "priority"];
+const TEXT_VERBOSITY = new Set(["low", "medium", "high"]);
+const INCLUDABLES = new Set(ResponseIncludables);
+const SERVICE_TIERS = new Set(ServiceTiers);
+const isTextVerbosity = (value) => typeof value === "string" && TEXT_VERBOSITY.has(value);
+const isServiceTier = (value) => typeof value === "string" && SERVICE_TIERS.has(value);
+export const ReasoningEffort = Schema.String;
+export const TextVerbositySchema = TextVerbosity;
+export const ResponseIncludableSchema = Schema.Literals(ResponseIncludables);
+export const ServiceTierSchema = Schema.Literals(ServiceTiers);
+export const resolve = (request) => {
+    const input = request.providerOptions?.[request.model.route.providerMetadataKey ?? "openresponses"];
+    const include = Array.isArray(input?.include)
+        ? input.include.filter((entry) => INCLUDABLES.has(entry))
+        : [];
+    const reasoningSummary = input?.reasoningSummary;
+    return {
+        instructions: typeof input?.instructions === "string" ? input.instructions : undefined,
+        store: typeof input?.store === "boolean" ? input.store : undefined,
+        reasoningEffort: typeof input?.reasoningEffort === "string" ? input.reasoningEffort : undefined,
+        reasoningSummary: reasoningSummary === "auto" || reasoningSummary === "concise" || reasoningSummary === "detailed"
+            ? reasoningSummary
+            : undefined,
+        include: include.length > 0 ? include : undefined,
+        textVerbosity: isTextVerbosity(input?.textVerbosity) ? input.textVerbosity : undefined,
+        serviceTier: isServiceTier(input?.serviceTier) ? input.serviceTier : undefined,
+    };
+};
+export * as OpenResponsesOptions from "./open-responses-options.js";

package/dist/protocols/utils/openai-image.d.ts

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+export declare const Size: Schema.String;
+export declare const OpenAIImage: {
+    readonly Size: Schema.String;
+};

package/dist/protocols/utils/openai-image.js

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+const dimensions = (value) => {
+    const match = /^(\d+)x(\d+)$/.exec(value);
+    if (!match)
+        return undefined;
+    return { width: Number(match[1]), height: Number(match[2]) };
+};
+export const Size = Schema.String.check(Schema.makeFilter((value) => {
+    if (value === "auto")
+        return undefined;
+    const parsed = dimensions(value);
+    if (!parsed)
+        return "image size must be `auto` or `{width}x{height}`";
+    return parsed.width > 0 && parsed.height > 0 ? undefined : "image dimensions must be positive integers";
+}));
+export const OpenAIImage = {
+    Size,
+};

package/dist/protocols/utils/openai-options.d.ts

@@ -0,0 +1,14 @@
+import { OpenResponsesOptions } from "./open-responses-options.js";
+export declare const OpenAIReasoningEfforts: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type OpenAIReasoningEffort = string;
+export declare const OpenAIResponseIncludables: readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"];
+export type OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludable;
+export declare const OpenAIServiceTiers: readonly ["auto", "default", "flex", "priority"];
+export type OpenAIServiceTier = OpenResponsesOptions.ServiceTier;
+export declare const OpenAIReasoningEffort: import("effect/Schema").String;
+export declare const OpenAITextVerbosity: import("effect/Schema").Literals<readonly ["low", "medium", "high"]>;
+export declare const OpenAIResponseIncludable: import("effect/Schema").Literals<readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"]>;
+export declare const OpenAIServiceTier: import("effect/Schema").Literals<readonly ["auto", "default", "flex", "priority"]>;
+export declare const isReasoningEffort: (effort: unknown) => effort is OpenAIReasoningEffort;
+export declare const resolve: (request: import("../../schema/messages.js").LLMRequest) => OpenResponsesOptions.Resolved;
+export * as OpenAIOptions from "./openai-options.js";

package/dist/protocols/utils/openai-options.js

@@ -0,0 +1,14 @@
+import { ReasoningEfforts } from "../../schema/index.js";
+import { OpenResponsesOptions } from "./open-responses-options.js";
+export const OpenAIReasoningEfforts = ReasoningEfforts;
+// Mirrors OpenAI's `ResponseIncludable` union from the official SDK. Keep this
+// in lockstep with `openai-node/src/resources/responses/responses.ts`.
+export const OpenAIResponseIncludables = OpenResponsesOptions.ResponseIncludables;
+export const OpenAIServiceTiers = OpenResponsesOptions.ServiceTiers;
+export const OpenAIReasoningEffort = OpenResponsesOptions.ReasoningEffort;
+export const OpenAITextVerbosity = OpenResponsesOptions.TextVerbositySchema;
+export const OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludableSchema;
+export const OpenAIServiceTier = OpenResponsesOptions.ServiceTierSchema;
+export const isReasoningEffort = (effort) => typeof effort === "string";
+export const resolve = OpenResponsesOptions.resolve;
+export * as OpenAIOptions from "./openai-options.js";

package/dist/protocols/utils/tool-schema.d.ts

@@ -0,0 +1,8 @@
+import type { JsonSchema, LanguageModelToolSchemaCompatibility } from "../../schema/index.js";
+export declare const ToolSchemaProjection: {
+    readonly gemini: (schema: JsonSchema) => JsonSchema;
+    readonly modelCompatibility: (schema: JsonSchema, compatibility: LanguageModelToolSchemaCompatibility | undefined) => JsonSchema;
+    readonly moonshot: (schema: JsonSchema) => JsonSchema;
+    readonly openAI: (schema: JsonSchema) => JsonSchema;
+    readonly responses: (schema: JsonSchema) => JsonSchema;
+};