@opencode/ai 0.0.0-beta-19507 → 0.0.0-dev-19276

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

@@ -585,7 +585,7 @@ export declare const decodeKnownErrorEvent: (event: Event) => Effect.Effect<{
     readonly param?: string | null | undefined;
     readonly status_code?: number | undefined;
 }, Schema.SchemaError, never>;
-export declare const Event: Schema.decodeTo<Schema.toType<Schema.StructWithRest<Schema.Struct<{
+export declare const Event: Schema.StructWithRest<Schema.Struct<{
     readonly type: Schema.String;
     readonly delta: Schema.optional<Schema.String>;
     readonly arguments: Schema.optional<Schema.String>;
@@ -648,152 +648,14 @@ export declare const Event: Schema.decodeTo<Schema.toType<Schema.StructWithRest<
     readonly status: Schema.optional<Schema.Unknown>;
     readonly status_code: Schema.optional<Schema.Unknown>;
     readonly headers: Schema.optional<Schema.Unknown>;
-}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>, Schema.StructWithRest<Schema.Struct<{
-    readonly type: Schema.String;
-    readonly delta: Schema.optional<Schema.String>;
-    readonly arguments: Schema.optional<Schema.String>;
-    readonly text: Schema.optional<Schema.String>;
-    readonly item_id: Schema.optional<Schema.String>;
-    readonly output_index: Schema.optional<Schema.Number>;
-    readonly summary_index: Schema.optional<Schema.Number>;
-    readonly item: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
-        readonly type: Schema.String;
-        readonly id: Schema.optional<Schema.String>;
-        readonly call_id: Schema.optional<Schema.String>;
-        readonly name: Schema.optional<Schema.String>;
-        readonly namespace: Schema.optional<Schema.String>;
-        readonly arguments: Schema.optional<Schema.String>;
-        readonly encrypted_content: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
-    readonly response: Schema.optional<Schema.StructWithRest<Schema.Struct<{
-        readonly id: Schema.optional<Schema.String>;
-        readonly service_tier: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly incomplete_details: Schema.optional<Schema.NullOr<Schema.Struct<{
-            readonly reason: Schema.optional<Schema.String>;
-        }>>>;
-        readonly output: Schema.optional<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
-            readonly type: Schema.String;
-            readonly id: Schema.optional<Schema.String>;
-            readonly call_id: Schema.optional<Schema.String>;
-            readonly name: Schema.optional<Schema.String>;
-            readonly namespace: Schema.optional<Schema.String>;
-            readonly arguments: Schema.optional<Schema.String>;
-            readonly encrypted_content: Schema.optional<Schema.NullOr<Schema.String>>;
-        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
-        readonly usage: Schema.optional<Schema.NullOr<Schema.Struct<{
-            readonly input_tokens: Schema.optional<Schema.Number>;
-            readonly input_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
-                readonly cached_tokens: Schema.optional<Schema.Number>;
-                readonly cache_write_tokens: Schema.optional<Schema.Number>;
-            }>>>;
-            readonly output_tokens: Schema.optional<Schema.Number>;
-            readonly output_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
-                readonly reasoning_tokens: Schema.optional<Schema.Number>;
-            }>>>;
-            readonly total_tokens: Schema.optional<Schema.Number>;
-        }>>>;
-        readonly error: Schema.optional<Schema.NullOr<Schema.Struct<{
-            readonly type: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly message: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-        }>>>;
-    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
-    readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-    readonly message: Schema.optional<Schema.String>;
-    readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-    readonly error: Schema.optional<Schema.NullOr<Schema.Struct<{
-        readonly type: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly message: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>>>;
-    readonly status: Schema.optional<Schema.Unknown>;
-    readonly status_code: Schema.optional<Schema.Unknown>;
-    readonly headers: Schema.optional<Schema.Unknown>;
-}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, never, never>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
 export type Event = Schema.Schema.Type<typeof Event>;
 export type NormalizedEvent = Event & {
     readonly item?: OutputItem | null;
 };
-/**
- * Decodes one WebSocket frame. xAI answers a rejected `response.create` with `{ "error": { "message", "type" } }` and no
- * event type; that envelope reads as an error event so the failure classifies instead of failing decoding.
- */
-export declare const decodeChannelEvent: (frame: string) => Effect.Effect<{
-    readonly [x: string]: unknown;
-    readonly type: string;
-    readonly status?: unknown;
-    readonly code?: string | null | undefined;
-    readonly message?: string | undefined;
-    readonly headers?: unknown;
-    readonly text?: string | undefined;
-    readonly error?: {
-        readonly type?: string | null | undefined;
-        readonly code?: string | null | undefined;
-        readonly message?: string | null | undefined;
-        readonly param?: string | null | undefined;
-    } | null | undefined;
-    readonly item?: {
-        readonly [x: string]: unknown;
-        readonly type: string;
-        readonly id?: string | undefined;
-        readonly name?: string | undefined;
-        readonly namespace?: string | undefined;
-        readonly arguments?: string | undefined;
-        readonly encrypted_content?: string | null | undefined;
-        readonly call_id?: string | undefined;
-    } | null | undefined;
-    readonly delta?: string | undefined;
-    readonly response?: {
-        readonly [x: string]: unknown;
-        readonly id?: string | undefined;
-        readonly output?: readonly {
-            readonly [x: string]: unknown;
-            readonly type: string;
-            readonly id?: string | undefined;
-            readonly name?: string | undefined;
-            readonly namespace?: string | undefined;
-            readonly arguments?: string | undefined;
-            readonly encrypted_content?: string | null | undefined;
-            readonly call_id?: string | undefined;
-        }[] | undefined;
-        readonly error?: {
-            readonly type?: string | null | undefined;
-            readonly code?: string | null | undefined;
-            readonly message?: string | null | undefined;
-            readonly param?: string | null | undefined;
-        } | null | undefined;
-        readonly usage?: {
-            readonly input_tokens?: number | undefined;
-            readonly output_tokens?: number | undefined;
-            readonly output_tokens_details?: {
-                readonly reasoning_tokens?: number | undefined;
-            } | null | undefined;
-            readonly total_tokens?: number | undefined;
-            readonly input_tokens_details?: {
-                readonly cached_tokens?: number | undefined;
-                readonly cache_write_tokens?: number | undefined;
-            } | null | undefined;
-        } | null | undefined;
-        readonly service_tier?: string | null | undefined;
-        readonly incomplete_details?: {
-            readonly reason?: string | undefined;
-        } | null | undefined;
-    } | undefined;
-    readonly arguments?: string | undefined;
-    readonly param?: string | null | undefined;
-    readonly status_code?: unknown;
-    readonly item_id?: string | undefined;
-    readonly output_index?: number | undefined;
-    readonly summary_index?: number | undefined;
-}, Schema.SchemaError, never>;
 export interface ProviderAdapter {
     readonly id: string;
     readonly name: string;
-    readonly nativeTool?: (native: NonNullable<ToolDefinition["native"]>) => Effect.Effect<{
-        readonly type: string;
-    }, AIError>;
     readonly lowerMedia?: (input: {
         readonly part: MediaPart;
         readonly media: ProviderShared.NormalizedMedia;
@@ -888,7 +750,13 @@ export declare const fromRequestWithAdapter: (request: LLMRequest<import("../sch
     readonly [x: string]: unknown;
 }, import("../route.js").CompactionOperations | undefined>>, adapter: ProviderAdapter) => Effect.Effect<{
     tools: {
-        readonly type: string;
+        type: "function";
+        name: string;
+        description: string;
+        parameters: {
+            readonly [x: string]: unknown;
+        };
+        strict: boolean;
     }[] | undefined;
     tool_choice: "required" | "auto" | "none" | {
         type: "allowed_tools";

package/dist/protocols/open-responses.js

@@ -1,4 +1,4 @@
-import { Effect, Option, Schema, SchemaGetter } from "effect";
+import { Effect, Option, Schema } from "effect";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
 import { AIError, LLMEvent, ProviderInternalError, Usage, } from "../schema/index.js";
@@ -232,8 +232,9 @@ export const StreamItem = Schema.StructWithRest(Schema.Struct({
     arguments: Schema.optional(Schema.String),
     encrypted_content: optionalNull(Schema.String),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
-// Responses-compatible providers put streaming error details at the top level or
-// under `error`, and response failures under `response.error`. Accept all three shapes.
+// The Responses schema puts streaming error details at the top level and
+// response failures under `response.error`. WebSocket failures use an
+// event-level `error` envelope, so accept all three shapes here.
 // https://www.openresponses.org/specification
 const OpenResponsesErrorPayload = Schema.Struct({
     type: optionalNull(Schema.String),
@@ -286,27 +287,7 @@ export const Event = Schema.StructWithRest(Schema.Struct({
     status: Schema.optional(Schema.Unknown),
     status_code: Schema.optional(Schema.Unknown),
     headers: Schema.optional(Schema.Unknown),
-}), [Schema.Record(Schema.String, Schema.Unknown)]).pipe(Schema.decode({
-    decode: SchemaGetter.transform((event) => {
-        if (event.type !== "error" || event.error != null)
-            return event;
-        const { code, message, param, ...rest } = event;
-        if (code === undefined && message === undefined && param === undefined)
-            return event;
-        // Flat errors (for example, Meta's) can also arrive through generic Responses endpoints.
-        return { ...rest, error: { code, message, param } };
-    }),
-    encode: SchemaGetter.passthrough(),
-}));
-const decodeEventValue = Schema.decodeUnknownEffect(Event);
-const decodeFrame = Schema.decodeUnknownEffect(ProviderShared.Json);
-/**
- * Decodes one WebSocket frame. xAI answers a rejected `response.create` with `{ "error": { "message", "type" } }` and no
- * event type; that envelope reads as an error event so the failure classifies instead of failing decoding.
- */
-export const decodeChannelEvent = (frame) => decodeFrame(frame).pipe(Effect.flatMap((value) => decodeEventValue(ProviderShared.isRecord(value) && value.type === undefined && ProviderShared.isRecord(value.error)
-    ? { ...value, type: "error" }
-    : value)));
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
 const BASE_ADAPTER = { id: ADAPTER, name: NAME };
 // =============================================================================
 // Request Lowering
@@ -464,8 +445,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                     type: "message",
                     ...(group.id === undefined ? {} : { id: group.id }),
                     role: "assistant",
-                    // Replayed text is a finished input item, even if generation was cut short.
-                    status: "completed",
+                    status: metadata?.status,
                     content: group.parts.map((part) => ({ type: "output_text", text: part.text })),
                     ...(group.phase === undefined ? {} : { phase: group.phase }),
                 })));
@@ -617,9 +597,7 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
         ...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, toolSchemaCompatibility))),
+            : yield* Effect.forEach(projected.tools, (tool) => lowerTool(adapter.name, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility))),
         tool_choice: allowedToolChoice(request) ??
             (request.toolChoice ? yield* lowerToolChoice(adapter.name, request.toolChoice) : undefined),
     };

package/dist/provider-package.d.ts

@@ -1,9 +1,5 @@
 import type { LanguageModel, ProviderOptions } from "./schema/index.js";
 import type { CompactionOperations } from "./route/client.js";
-/**
- * Flat, serializable settings for `model(modelID, settings)`. Each entrypoint declares the connection keys it
- * reads; every other key is a request option for the route's protocol.
- */
 export interface Settings extends Readonly<Record<string, unknown>> {
     readonly baseURL?: string;
     readonly headers?: Readonly<Record<string, string>>;

package/dist/providers/amazon-bedrock-mantle.d.ts

@@ -17,7 +17,7 @@ export type Config = RouteDefaultsInput & {
     readonly region?: string;
     readonly providerOptions?: OpenAIProviderOptionsInput;
 };
-export type Settings = ProviderPackage.Settings & OpenAIProviderOptionsInput & {
+export interface Settings extends ProviderPackage.Settings {
     readonly apiKey?: string;
     readonly auth?: "bearer" | "sigv4";
     readonly baseURL?: string;
@@ -25,7 +25,8 @@ export type Settings = ProviderPackage.Settings & OpenAIProviderOptionsInput & {
     readonly profile?: string;
     readonly region?: string;
     readonly topP?: number;
-};
+    readonly providerOptions?: OpenAIProviderOptionsInput;
+}
 export declare const routes: (Route<{
     readonly model: string;
     readonly messages: readonly ({
@@ -236,6 +237,34 @@ export declare const routes: (Route<{
             readonly type: "input_video";
             readonly video_url: string;
         })[];
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "computer_call";
+        readonly status?: string | undefined;
+        readonly action?: {
+            readonly [x: string]: unknown;
+        } | null | undefined;
+        readonly call_id?: string | undefined;
+        readonly pending_safety_checks?: readonly {
+            readonly [x: string]: unknown;
+        }[] | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "web_search_preview_call";
+        readonly status?: string | undefined;
+        readonly action?: {
+            readonly [x: string]: unknown;
+        } | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        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 model: string;
     readonly stream: true;
@@ -247,7 +276,7 @@ export declare const routes: (Route<{
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
         readonly effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
     } | undefined;
-    readonly tools?: readonly {
+    readonly tools?: readonly ({
         readonly type: "function";
         readonly description: string;
         readonly name: string;
@@ -255,12 +284,39 @@ export declare const routes: (Route<{
             readonly [x: string]: unknown;
         };
         readonly strict?: boolean | undefined;
-    }[] | undefined;
+    } | {
+        readonly type: "image_generation";
+        readonly size?: string | undefined;
+        readonly action?: "generate" | "auto" | "edit" | undefined;
+        readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly quality?: "auto" | "low" | "medium" | "high" | undefined;
+        readonly background?: "auto" | "opaque" | "transparent" | undefined;
+        readonly output_compression?: number | undefined;
+        readonly input_fidelity?: "low" | "high" | undefined;
+        readonly partial_images?: number | undefined;
+    } | {
+        readonly type: "namespace";
+        readonly name: string;
+        readonly description: string;
+        readonly tools: readonly {
+            readonly type: "function";
+            readonly description: string;
+            readonly name: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+            readonly strict?: boolean | undefined;
+        }[];
+    })[] | undefined;
     readonly text?: {
         readonly verbosity?: import("../protocols/utils/open-responses-options.js").TextVerbosity | undefined;
     } | undefined;
     readonly temperature?: number | undefined;
     readonly service_tier?: import("../protocols/utils/open-responses-options.js").ServiceTier | undefined;
+    readonly context_management?: readonly {
+        readonly type: "compaction";
+        readonly compact_threshold?: number | undefined;
+    }[] | undefined;
     readonly tool_choice?: "required" | "auto" | "none" | {
         readonly type: "function";
         readonly name: string;
@@ -271,6 +327,8 @@ export declare const routes: (Route<{
             readonly type: "function";
             readonly name: string;
         }[];
+    } | {
+        readonly type: "image_generation";
     } | undefined;
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;

package/dist/providers/amazon-bedrock-mantle.js

@@ -1,19 +1,19 @@
 import { Route } from "../route/client.js";
-import { Endpoint } from "../route/endpoint.js";
 import { OpenAIChat } from "../protocols/openai-chat.js";
-import { OpenResponses } from "../protocols/open-responses.js";
+import { OpenAIResponses } from "../protocols/openai-responses.js";
 import { BedrockAuth } from "../protocols/utils/bedrock-auth.js";
-import { ProviderConfigurationError, ProviderID } from "../schema/index.js";
+import { ProviderID } from "../schema/index.js";
 import { withOpenAIOptions } from "./openai-options.js";
 export const id = ProviderID.make("amazon-bedrock");
 const responsesRoute = Route.make({
     id: "bedrock-mantle-responses",
     provider: id,
     providerMetadataKey: "mantle",
-    protocol: OpenResponses.protocol,
-    endpoint: Endpoint.path(OpenResponses.PATH),
-    transport: OpenResponses.httpTransport,
-    defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
+    protocol: OpenAIResponses.protocol,
+    endpoint: OpenAIResponses.route.endpoint,
+    auth: OpenAIResponses.route.auth,
+    transport: OpenAIResponses.httpTransport,
+    defaults: OpenAIResponses.route.defaults,
 });
 const chatRoute = OpenAIChat.route.with({
     id: "bedrock-mantle-chat",
@@ -38,12 +38,9 @@ const defaults = (input) => {
 };
 export const configure = (input = {}) => {
     if (input.auth === "bearer" && input.apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-        throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock Mantle bearer auth requires apiKey" });
+        throw new Error("Amazon Bedrock Mantle bearer auth requires apiKey");
     if (input.auth === "sigv4" && input.apiKey !== undefined)
-        throw new ProviderConfigurationError({
-            provider: id,
-            message: "Amazon Bedrock Mantle SigV4 auth does not accept apiKey",
-        });
+        throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey");
     const configuredResponsesRoute = configuredRoute(responsesRoute, input);
     const configuredChatRoute = configuredRoute(chatRoute, input);
     const modelDefaults = defaults(input);
@@ -62,17 +59,17 @@ export const configure = (input = {}) => {
     };
 };
 export const provider = configure();
-const fromSettings = ({ apiKey, auth, baseURL, body, credentials, headers, profile, region, topP, ...providerOptions }) => configure({
-    apiKey,
-    auth,
-    baseURL,
-    credentials,
-    generation: topP === undefined ? undefined : { topP },
-    headers: headers === undefined ? undefined : { ...headers },
-    http: body === undefined ? undefined : { body: { ...body } },
-    profile,
-    providerOptions,
-    region,
+const fromSettings = (settings) => configure({
+    apiKey: settings.apiKey,
+    auth: settings.auth,
+    baseURL: settings.baseURL,
+    credentials: settings.credentials,
+    generation: settings.topP === undefined ? undefined : { topP: settings.topP },
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    profile: settings.profile,
+    providerOptions: settings.providerOptions,
+    region: settings.region,
 });
 export const chatModel = (modelID, settings) => fromSettings(settings).chat(modelID);
 export const responsesModel = (modelID, settings) => fromSettings(settings).responses(modelID);

package/dist/providers/amazon-bedrock.js

@@ -1,4 +1,4 @@
-import { ProviderConfigurationError, ProviderID } from "../schema/index.js";
+import { ProviderID } from "../schema/index.js";
 import * as BedrockConverse from "../protocols/bedrock-converse.js";
 import { BedrockAuth } from "../protocols/utils/bedrock-auth.js";
 export const id = ProviderID.make("amazon-bedrock");
@@ -7,9 +7,9 @@ const bedrockBaseURL = (region) => `https://bedrock-runtime.${region}.amazonaws.
 const configuredRoute = (input) => {
     const { apiKey, auth, credentials, profile, region, baseURL, ...rest } = input;
     if (auth === "bearer" && apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-        throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock bearer auth requires apiKey" });
+        throw new Error("Amazon Bedrock bearer auth requires apiKey");
     if (auth === "sigv4" && apiKey !== undefined)
-        throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock SigV4 auth does not accept apiKey" });
+        throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey");
     const resolvedRegion = BedrockAuth.resolveRegion(input);
     return BedrockConverse.route.with({
         ...rest,

package/dist/providers/anthropic-compatible.d.ts

@@ -12,7 +12,7 @@ export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
     readonly baseURL: string;
     readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
 };
-export type Settings = ProviderPackage.Settings & AnthropicMessages.ProviderOptionsInput & ({
+export type Settings = ProviderPackage.Settings & ({
     readonly apiKey?: string;
     readonly authToken?: never;
 } | {
@@ -21,6 +21,7 @@ export type Settings = ProviderPackage.Settings & AnthropicMessages.ProviderOpti
 }) & {
     readonly baseURL: string;
     readonly provider?: string;
+    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
 };
 export declare const routes: import("../route/client.js").Route<{
     readonly max_tokens: number;
@@ -236,15 +237,9 @@ export declare const routes: import("../route/client.js").Route<{
         readonly type: "enabled";
         readonly budget_tokens: number;
         readonly display?: "summarized" | "omitted" | undefined;
-        readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
-        } | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
-        readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
-        } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;

package/dist/providers/anthropic-compatible.js

@@ -1,6 +1,6 @@
 import { AnthropicMessages } from "../protocols/anthropic-messages.js";
 import { Auth } from "../route/auth.js";
-import { ProviderConfigurationError, ProviderID } from "../schema/index.js";
+import { ProviderID } from "../schema/index.js";
 export const id = ProviderID.make("anthropic-compatible");
 export const routes = [AnthropicMessages.route];
 const auth = (input) => {
@@ -9,12 +9,9 @@ const auth = (input) => {
     return Auth.optional("apiKey" in input ? input.apiKey : undefined, "apiKey").pipe(Auth.header("x-api-key"));
 };
 export const configure = (input) => {
-    const provider = input.provider ?? "anthropic-compatible";
     if (!input.baseURL)
-        throw new ProviderConfigurationError({
-            provider: ProviderID.make(provider),
-            message: "Anthropic-compatible providers require a baseURL",
-        });
+        throw new Error("Anthropic-compatible providers require a baseURL");
+    const provider = input.provider ?? "anthropic-compatible";
     const { provider: _, baseURL, apiKey: _apiKey, auth: _auth, ...rest } = input;
     const route = AnthropicMessages.route.with({
         ...rest,
@@ -32,19 +29,16 @@ export const provider = {
     id,
     configure,
 };
-export const model = (modelID, { apiKey, authToken, baseURL, body, headers, provider, ...providerOptions }) => {
-    if (apiKey !== undefined && authToken !== undefined)
-        throw new ProviderConfigurationError({
-            provider: ProviderID.make(provider ?? id),
-            message: "Anthropic-compatible apiKey cannot be combined with authToken",
-        });
+export const model = (modelID, settings) => {
+    if (settings.apiKey !== undefined && settings.authToken !== undefined)
+        throw new Error("Anthropic-compatible apiKey cannot be combined with authToken");
     return configure({
-        ...(authToken === undefined ? { apiKey: apiKey } : { auth: Auth.bearer(authToken) }),
-        baseURL,
-        headers: headers === undefined ? undefined : { ...headers },
-        http: body === undefined ? undefined : { body: { ...body } },
-        provider,
-        providerOptions,
+        ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
+        baseURL: settings.baseURL,
+        headers: settings.headers === undefined ? undefined : { ...settings.headers },
+        http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+        provider: settings.provider,
+        providerOptions: settings.providerOptions,
     }).model(modelID);
 };
 export * as AnthropicCompatible from "./anthropic-compatible.js";

package/dist/providers/anthropic.d.ts

@@ -221,15 +221,9 @@ export declare const routes: import("../route/client.js").Route<{
         readonly type: "enabled";
         readonly budget_tokens: number;
         readonly display?: "summarized" | "omitted" | undefined;
-        readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
-        } | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
-        readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
-        } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
@@ -281,7 +275,7 @@ export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
     readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
 };
-export type Settings = ProviderPackage.Settings & AnthropicMessages.ProviderOptionsInput & ({
+export type Settings = ProviderPackage.Settings & ({
     readonly apiKey?: string;
     readonly authToken?: never;
 } | {
@@ -289,6 +283,7 @@ export type Settings = ProviderPackage.Settings & AnthropicMessages.ProviderOpti
     readonly authToken?: string;
 }) & {
     readonly baseURL?: string;
+    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
 };
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;

package/dist/providers/anthropic.js

@@ -1,5 +1,5 @@
 import { Auth } from "../route/auth.js";
-import { ProviderConfigurationError, ProviderID } from "../schema/index.js";
+import { ProviderID } from "../schema/index.js";
 import { AnthropicMessages } from "../protocols/anthropic-messages.js";
 import { AnthropicCompatible } from "./anthropic-compatible.js";
 export const id = ProviderID.make("anthropic");
@@ -26,17 +26,14 @@ export const configure = (input = {}) => {
     };
 };
 export const provider = configure();
-export const model = (modelID, { apiKey, authToken, baseURL, body, headers, ...providerOptions }) => {
-    if (apiKey !== undefined && authToken !== undefined)
-        throw new ProviderConfigurationError({
-            provider: id,
-            message: "Anthropic apiKey cannot be combined with authToken",
-        });
+export const model = (modelID, settings) => {
+    if (settings.apiKey !== undefined && settings.authToken !== undefined)
+        throw new Error("Anthropic apiKey cannot be combined with authToken");
     return configure({
-        ...(authToken === undefined ? { apiKey: apiKey } : { auth: Auth.bearer(authToken) }),
-        baseURL,
-        headers: headers === undefined ? undefined : { ...headers },
-        http: body === undefined ? undefined : { body: { ...body } },
-        providerOptions,
+        ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
+        baseURL: settings.baseURL,
+        headers: settings.headers === undefined ? undefined : { ...settings.headers },
+        http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+        providerOptions: settings.providerOptions,
     }).model(modelID);
 };

package/dist/providers/azure.d.ts

@@ -15,11 +15,12 @@ export type LanguageModelOptions = AzureURL & RouteDefaultsInput & ProviderAuthO
     readonly providerOptions?: OpenAIProviderOptionsInput;
 };
 export type Config = LanguageModelOptions;
-export type Settings = ProviderPackage.Settings & OpenAIProviderOptionsInput & AzureURL & {
+export type Settings = ProviderPackage.Settings & AzureURL & {
     readonly apiKey?: string;
     readonly apiVersion?: string;
     readonly queryParams?: Readonly<Record<string, string>>;
     readonly useDeploymentBasedUrls?: boolean;
+    readonly providerOptions?: OpenAIProviderOptionsInput;
 };
 declare const responsesRoute: Route<{
     readonly input: readonly ({