@opencode/ai 0.0.0-beta-19425 → 0.0.0-beta-19500

package/dist/protocols/anthropic-messages.js

@@ -1432,7 +1432,10 @@ export const transport = () => {
     };
 };
 function requiredBetaHeaders(body) {
-    const betas = [];
+    // Always request interleaved thinking. The API accepts the header on any
+    // model and ignores it where unsupported, while manual-thinking models need
+    // it for thinking between tool calls.
+    const betas = ["interleaved-thinking-2025-05-14"];
     const requestsCompaction = (body.context_management?.edits.length ?? 0) > 0;
     const replaysCompaction = body.messages.some((message) => message.content.some((block) => block.type === "compaction"));
     if (requestsCompaction || replaysCompaction)

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

@@ -1,5 +1,6 @@
 import { Headers } from "effect/unstable/http";
 import { HttpTransport, type Transport, type WebSocketChannelDriver } from "../route/transport/index.js";
+import { OpenResponsesContinuation } from "./open-responses-continuation.js";
 export interface Options {
     readonly id: string;
     readonly name: string;
@@ -7,6 +8,7 @@ export interface Options {
     readonly enabled?: (url: string) => boolean;
     readonly url?: (url: string) => string;
     readonly headers?: (headers: Headers.Headers) => Headers.Headers;
+    readonly continuation?: OpenResponsesContinuation.Shape;
 }
 export interface Prepared {
     readonly http: HttpTransport.HttpPrepared<string>;

package/dist/protocols/open-responses-channel.js

@@ -10,7 +10,6 @@ const WebSocketResponseCreate = Schema.StructWithRest(Schema.Struct({ type: Sche
 ]);
 const decodeMessage = ProviderShared.validateWith(Schema.decodeUnknownEffect(WebSocketResponseCreate));
 const encodeMessage = Schema.encodeSync(Schema.fromJsonString(WebSocketResponseCreate));
-const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event);
 const message = (body) => Effect.gen(function* () {
     if (!ProviderShared.isRecord(body))
         return yield* ProviderShared.invalidRequest("Open Responses WebSocket body must be a JSON object");
@@ -28,7 +27,7 @@ const driver = (options, body) => {
             return { message: body, mode: "full" };
         }),
         observe: (_create, frame) => Effect.gen(function* () {
-            const event = yield* decodeEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause)));
+            const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause)));
             if (terminal)
                 return yield* ProviderShared.eventError(options.id, `${options.name} emitted ${event.type} after a terminal event`, frame);
             if (event.type === "error") {
@@ -97,6 +96,7 @@ export const transport = (options) => {
                             request: create.request,
                             message: create.message,
                             base,
+                            continuation: options.continuation,
                         }),
                     };
                 })

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

@@ -1,12 +1,16 @@
 import type { WebSocketChannelDriver } from "../route/transport/index.js";
+/**
+ * Fields to send next to `previous_response_id` on an incremental step, or undefined to send the step in full.
+ * Whether omitted fields carry over from the continued response is provider behavior the route must know.
+ */
+export type Shape = (request: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>> | undefined;
 export interface DriverInput {
     readonly id: string;
     readonly name: string;
     readonly request: Readonly<Record<string, unknown>>;
     readonly message: string;
     readonly base: WebSocketChannelDriver;
+    readonly continuation?: Shape;
 }
 export declare const driver: (input: DriverInput) => WebSocketChannelDriver;
-export declare const OpenResponsesContinuation: {
-    readonly driver: (input: DriverInput) => WebSocketChannelDriver;
-};
+export * as OpenResponsesContinuation from "./open-responses-continuation.js";

package/dist/protocols/open-responses-continuation.js

@@ -4,7 +4,6 @@ import * as ProviderShared from "./shared.js";
 import { OpenResponses } from "./open-responses.js";
 const PROTOCOL = "open-responses.websocket.v1";
 const VERSION = 1;
-const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event);
 const checkpointValue = (checkpoint) => {
     if (checkpoint?.protocol !== PROTOCOL || !ProviderShared.isRecord(checkpoint.value))
         return undefined;
@@ -104,21 +103,24 @@ const rejected = (observation, recovery) => ({
 });
 export const driver = (input) => {
     const { previous_response_id: _previousResponseID, ...request } = input.request;
+    const shape = input.continuation ?? ((fields) => fields);
     let output = [];
     return {
         create: (checkpoint) => Effect.sync(() => {
             output = [];
             const previous = checkpointValue(checkpoint);
-            const delta = previous ? incremental(request, previous) : undefined;
-            if (!previous || !delta)
+            // Ask the route first: diffing the whole history is wasted when it declines the continuation.
+            const fields = previous ? shape(request) : undefined;
+            const delta = previous && fields ? incremental(request, previous) : undefined;
+            if (!previous || !fields || !delta)
                 return { message: ProviderShared.encodeJson(request), mode: "full" };
             return {
-                message: ProviderShared.encodeJson({ ...request, input: delta, previous_response_id: previous.responseID }),
+                message: ProviderShared.encodeJson({ ...fields, input: delta, previous_response_id: previous.responseID }),
                 mode: "incremental",
             };
         }),
         observe: (create, frame) => Effect.gen(function* () {
-            const event = yield* decodeEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause)));
+            const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause)));
             const observation = yield* input.base.observe(create, frame);
             if (event.type === "response.output_item.done" && event.item)
                 output.push(event.item);
@@ -165,4 +167,4 @@ export const driver = (input) => {
         }),
     };
 };
-export const OpenResponsesContinuation = { driver };
+export * as OpenResponsesContinuation from "./open-responses-continuation.js";

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.StructWithRest<Schema.Struct<{
+export declare const Event: Schema.decodeTo<Schema.toType<Schema.StructWithRest<Schema.Struct<{
     readonly type: Schema.String;
     readonly delta: Schema.optional<Schema.String>;
     readonly arguments: Schema.optional<Schema.String>;
@@ -648,11 +648,146 @@ export declare const Event: Schema.StructWithRest<Schema.Struct<{
     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>]>;
+}>, 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>;
 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;

package/dist/protocols/open-responses.js

@@ -1,4 +1,4 @@
-import { Effect, Option, Schema } from "effect";
+import { Effect, Option, Schema, SchemaGetter } 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,9 +232,8 @@ export const StreamItem = Schema.StructWithRest(Schema.Struct({
     arguments: Schema.optional(Schema.String),
     encrypted_content: optionalNull(Schema.String),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
-// 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.
+// Responses-compatible providers put streaming error details at the top level or
+// under `error`, and response failures under `response.error`. Accept all three shapes.
 // https://www.openresponses.org/specification
 const OpenResponsesErrorPayload = Schema.Struct({
     type: optionalNull(Schema.String),
@@ -287,7 +286,27 @@ 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)]);
+}), [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)));
 const BASE_ADAPTER = { id: ADAPTER, name: NAME };
 // =============================================================================
 // Request Lowering

package/dist/provider-package.d.ts

@@ -1,5 +1,9 @@
 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/alibaba.d.ts

@@ -20,9 +20,8 @@ type Location = AtLeastOne<{
 export type Config = Location & Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
     readonly providerOptions?: ChatOptionsInput | MessagesOptionsInput | ResponsesOptionsInput;
 };
-export type Settings<Options = ChatOptionsInput> = Location & ProviderPackage.Settings & {
+export type Settings<Options = ChatOptionsInput> = Location & ProviderPackage.Settings & Options & {
     readonly apiKey?: string;
-    readonly providerOptions?: Options;
 };
 export declare const routes: (Route<{
     readonly model: string;

package/dist/providers/alibaba.js

@@ -1,3 +1,4 @@
+import { Struct } from "effect";
 import { AlibabaChat } from "../protocols/alibaba-chat.js";
 import { AlibabaMessages } from "../protocols/alibaba-messages.js";
 import { AlibabaResponses } from "../protocols/alibaba-responses.js";
@@ -5,7 +6,7 @@ import { AuthOptions } from "../route/auth-options.js";
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
 import { Framing } from "../route/framing.js";
-import { ProviderID, ToolDefinition } from "../schema/index.js";
+import { ProviderConfigurationError, ProviderID, ToolDefinition } from "../schema/index.js";
 export const id = ProviderID.make("alibaba");
 const hosts = new Map([
     ["ap-southeast-1", "dashscope-intl.aliyuncs.com"],
@@ -48,9 +49,12 @@ export const configure = (input) => {
             : `${workspaceID}.${region}.maas.aliyuncs.com`;
     if (baseURL === undefined) {
         if (region === undefined)
-            throw new Error("Alibaba requires region or baseURL");
+            throw new ProviderConfigurationError({ provider: id, message: "Alibaba requires region or baseURL" });
         if (host === undefined)
-            throw new Error(`Alibaba region ${region} requires workspaceID or baseURL`);
+            throw new ProviderConfigurationError({
+                provider: id,
+                message: `Alibaba region ${region} requires workspaceID or baseURL`,
+            });
     }
     const opts = { ...rest, auth: AuthOptions.bearer(input, ["DASHSCOPE_API_KEY", "ALIBABA_API_KEY"]) };
     const common = { ...opts, endpoint: { baseURL: baseURL ?? `https://${host}/compatible-mode/v1` } };
@@ -70,7 +74,11 @@ export const messagesModel = (id, input) => fromSettings(input).messages(id);
 export const responsesModel = (id, input) => fromSettings(input).responses(id);
 function fromSettings(input) {
     const { body, ...rest } = input;
-    return configure({ ...rest, http: body === undefined ? undefined : { body } });
+    return configure({
+        ...rest,
+        http: body === undefined ? undefined : { body },
+        providerOptions: Struct.omit(rest, ["apiKey", "baseURL", "headers", "region", "workspaceID"]),
+    });
 }
 export const webSearch = () => hostedTool("web_search", "Search the web with Alibaba's hosted search tool.");
 export const webExtractor = () => hostedTool("web_extractor", "Extract web page content with Alibaba's hosted tool.");

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

@@ -17,7 +17,7 @@ export type Config = RouteDefaultsInput & {
     readonly region?: string;
     readonly providerOptions?: OpenAIProviderOptionsInput;
 };
-export interface Settings extends ProviderPackage.Settings {
+export type Settings = ProviderPackage.Settings & OpenAIProviderOptionsInput & {
     readonly apiKey?: string;
     readonly auth?: "bearer" | "sigv4";
     readonly baseURL?: string;
@@ -25,8 +25,7 @@ export interface Settings extends ProviderPackage.Settings {
     readonly profile?: string;
     readonly region?: string;
     readonly topP?: number;
-    readonly providerOptions?: OpenAIProviderOptionsInput;
-}
+};
 export declare const routes: (Route<{
     readonly model: string;
     readonly messages: readonly ({
@@ -237,34 +236,6 @@ 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;
@@ -276,7 +247,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;
@@ -284,39 +255,12 @@ export declare const routes: (Route<{
             readonly [x: string]: unknown;
         };
         readonly strict?: boolean | 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;
+    }[] | 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;
@@ -327,8 +271,6 @@ 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 { OpenAIResponses } from "../protocols/openai-responses.js";
+import { OpenResponses } from "../protocols/open-responses.js";
 import { BedrockAuth } from "../protocols/utils/bedrock-auth.js";
-import { ProviderID } from "../schema/index.js";
+import { ProviderConfigurationError, 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: OpenAIResponses.protocol,
-    endpoint: OpenAIResponses.route.endpoint,
-    auth: OpenAIResponses.route.auth,
-    transport: OpenAIResponses.httpTransport,
-    defaults: OpenAIResponses.route.defaults,
+    protocol: OpenResponses.protocol,
+    endpoint: Endpoint.path(OpenResponses.PATH),
+    transport: OpenResponses.httpTransport,
+    defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 });
 const chatRoute = OpenAIChat.route.with({
     id: "bedrock-mantle-chat",
@@ -38,9 +38,12 @@ const defaults = (input) => {
 };
 export const configure = (input = {}) => {
     if (input.auth === "bearer" && input.apiKey === undefined && process.env.AWS_BEARER_TOKEN_BEDROCK === undefined)
-        throw new Error("Amazon Bedrock Mantle bearer auth requires apiKey");
+        throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock Mantle bearer auth requires apiKey" });
     if (input.auth === "sigv4" && input.apiKey !== undefined)
-        throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey");
+        throw new ProviderConfigurationError({
+            provider: id,
+            message: "Amazon Bedrock Mantle SigV4 auth does not accept apiKey",
+        });
     const configuredResponsesRoute = configuredRoute(responsesRoute, input);
     const configuredChatRoute = configuredRoute(chatRoute, input);
     const modelDefaults = defaults(input);
@@ -59,17 +62,17 @@ export const configure = (input = {}) => {
     };
 };
 export const provider = configure();
-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,
+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,
 });
 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 { ProviderID } from "../schema/index.js";
+import { ProviderConfigurationError, 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 Error("Amazon Bedrock bearer auth requires apiKey");
+        throw new ProviderConfigurationError({ provider: id, message: "Amazon Bedrock bearer auth requires apiKey" });
     if (auth === "sigv4" && apiKey !== undefined)
-        throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey");
+        throw new ProviderConfigurationError({ provider: id, message: "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 & ({
+export type Settings = ProviderPackage.Settings & AnthropicMessages.ProviderOptionsInput & ({
     readonly apiKey?: string;
     readonly authToken?: never;
 } | {
@@ -21,7 +21,6 @@ export type Settings = ProviderPackage.Settings & ({
 }) & {
     readonly baseURL: string;
     readonly provider?: string;
-    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
 };
 export declare const routes: import("../route/client.js").Route<{
     readonly max_tokens: number;