@opencode-ai/ai 0.0.0-beta-17492

package/dist/protocols/utils/tool-stream.js

@@ -0,0 +1,141 @@
+import { Effect } from "effect";
+import { AIError, LLMEvent } from "../../schema/index.js";
+import { eventError, parseToolInput } from "../shared.js";
+/** Create empty accumulator state for one provider stream. */
+export const empty = () => ({});
+const withTool = (tools, key, tool) => {
+    return { ...tools, [key]: tool };
+};
+const withoutTool = (tools, key) => {
+    const next = { ...tools };
+    delete next[key];
+    return next;
+};
+const inputStart = (tool) => LLMEvent.toolInputStart({
+    id: tool.id,
+    name: tool.name,
+    providerExecuted: tool.providerExecuted ? true : undefined,
+    providerMetadata: tool.providerMetadata,
+});
+const inputDelta = (tool, text) => LLMEvent.toolInputDelta({
+    id: tool.id,
+    name: tool.name,
+    text,
+});
+const toolCall = (route, tool, inputOverride) => {
+    const raw = inputOverride ?? tool.input;
+    return parseToolInput(route, tool.name, raw).pipe(Effect.map((input) => LLMEvent.toolCall({
+        id: tool.id,
+        name: tool.name,
+        input,
+        providerExecuted: tool.providerExecuted ? true : undefined,
+        providerMetadata: tool.providerMetadata,
+    })), Effect.catch((error) => tool.providerExecuted
+        ? Effect.fail(error)
+        : Effect.succeed(LLMEvent.toolInputError({
+            id: tool.id,
+            name: tool.name,
+            raw,
+        }))));
+};
+const finishEvents = (tool, event) => event.type === "tool-input-error"
+    ? [event]
+    : [LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }), event];
+/** Store the updated tool and produce the optional public delta event. */
+const appendTool = (tools, key, tool, text) => {
+    const events = [];
+    if (!tools[key])
+        events.push(inputStart(tool));
+    if (text.length > 0)
+        events.push(inputDelta(tool, text));
+    return {
+        tools: withTool(tools, key, tool),
+        tool,
+        events,
+    };
+};
+export const isError = (result) => result instanceof AIError;
+/**
+ * Register a tool call whose start event arrived before any argument deltas.
+ * Used by Anthropic `content_block_start`, Bedrock `contentBlockStart`, and
+ * OpenAI Responses `response.output_item.added`.
+ */
+export const start = (tools, key, tool) => withTool(tools, key, { ...tool, input: tool.input ?? "" });
+/**
+ * Append a streamed argument delta, starting the tool if this provider encodes
+ * identity on the first delta instead of a separate start event. OpenAI Chat has
+ * this shape: `tool_calls[].index` is the stream key, and `id` / `name` may only
+ * appear on the first delta for that index.
+ */
+export const appendOrStart = (route, tools, key, delta, missingToolMessage) => {
+    const current = tools[key];
+    const id = current?.id ?? delta.id;
+    const name = current?.name ?? delta.name;
+    if (!id || !name)
+        return eventError(route, missingToolMessage);
+    const tool = {
+        id,
+        name,
+        input: `${current?.input ?? ""}${delta.text}`,
+        providerExecuted: current?.providerExecuted,
+        providerMetadata: current?.providerMetadata,
+    };
+    if (current && delta.text.length === 0 && current.id === id && current.name === name)
+        return { tools, tool: current, events: [] };
+    return appendTool(tools, key, tool, delta.text);
+};
+/**
+ * Append argument text to a tool that must already have been started. This keeps
+ * protocols honest when their stream grammar promises a start event before any
+ * argument delta.
+ */
+export const appendExisting = (route, tools, key, text, missingToolMessage) => {
+    const current = tools[key];
+    if (!current)
+        return eventError(route, missingToolMessage);
+    if (text.length === 0)
+        return { tools, tool: current, events: [] };
+    return appendTool(tools, key, { ...current, input: `${current.input}${text}` }, text);
+};
+/**
+ * Finalize one pending tool call: parse the accumulated raw JSON, remove it
+ * from state, and return either a call or a non-executable local input error.
+ * Missing keys are a no-op because some providers emit stop events for
+ * non-tool content blocks.
+ */
+export const finish = (route, tools, key) => Effect.gen(function* () {
+    const tool = tools[key];
+    if (!tool)
+        return { tools };
+    return {
+        tools: withoutTool(tools, key),
+        events: finishEvents(tool, yield* toolCall(route, tool)),
+    };
+});
+/**
+ * Finalize one pending tool call with an authoritative final input string.
+ * OpenAI Responses can send accumulated deltas and then repeat the completed
+ * arguments on `response.output_item.done`; the final value wins.
+ */
+export const finishWithInput = (route, tools, key, input) => Effect.gen(function* () {
+    const tool = tools[key];
+    if (!tool)
+        return { tools };
+    return {
+        tools: withoutTool(tools, key),
+        events: finishEvents(tool, yield* toolCall(route, tool, input)),
+    };
+});
+/**
+ * Finalize every pending tool call at once. OpenAI Chat has this shape: it does
+ * not emit per-tool stop events, so all accumulated calls finish independently
+ * when the choice receives a terminal `finish_reason`.
+ */
+export const finishAll = (route, tools) => Effect.gen(function* () {
+    const pending = Object.values(tools).filter((tool) => tool !== undefined);
+    return {
+        tools: empty(),
+        events: yield* Effect.forEach(pending, (tool) => toolCall(route, tool).pipe(Effect.map((event) => finishEvents(tool, event)))).pipe(Effect.map((events) => events.flat())),
+    };
+});
+export * as ToolStream from "./tool-stream.js";

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

@@ -0,0 +1,26 @@
+import { ImageModel } from "../image.js";
+import { type Definition as AuthDefinition } from "../route/auth.js";
+import { type HttpOptions } from "../schema/index.js";
+export declare const DEFAULT_BASE_URL = "https://api.x.ai/v1";
+export declare const PATH = "/images/generations";
+export declare const EDIT_PATH = "/images/edits";
+export type XAIImageString<Known extends string> = Known | (string & {});
+export type XAIImageOptions = {
+    readonly n?: number;
+    readonly aspectRatio?: XAIImageString<"1:1" | "3:4" | "4:3" | "9:16" | "16:9" | "2:3" | "3:2" | "9:19.5" | "19.5:9" | "9:20" | "20:9" | "1:2" | "2:1" | "auto">;
+    readonly aspect_ratio?: XAIImageString<"1:1" | "3:4" | "4:3" | "9:16" | "16:9" | "2:3" | "3:2" | "9:19.5" | "19.5:9" | "9:20" | "20:9" | "1:2" | "2:1" | "auto">;
+    readonly resolution?: XAIImageString<"1k" | "2k">;
+    readonly responseFormat?: XAIImageString<"url" | "b64_json">;
+    readonly response_format?: XAIImageString<"url" | "b64_json">;
+} & Record<string, unknown>;
+export interface ModelInput {
+    readonly id: string;
+    readonly auth: AuthDefinition;
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions;
+}
+export declare const model: (input: ModelInput) => ImageModel<XAIImageOptions>;
+export declare const XAIImages: {
+    readonly model: (input: ModelInput) => ImageModel<XAIImageOptions>;
+};

package/dist/protocols/xai-images.js

@@ -0,0 +1,111 @@
+import { Effect, Encoding, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { GeneratedImage, ImageModel, ImageResponse } from "../image.js";
+import { Auth } from "../route/auth.js";
+import { InvalidProviderOutputReason, AIError, Usage, mergeHttpOptions, mergeJsonRecords, } from "../schema/index.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+import { ImageInputs } from "./utils/image-input.js";
+const ADAPTER = "xai-images";
+export const DEFAULT_BASE_URL = "https://api.x.ai/v1";
+export const PATH = "/images/generations";
+export const EDIT_PATH = "/images/edits";
+const XAIImageResponse = Schema.Struct({
+    data: Schema.Array(Schema.Struct({
+        b64_json: optionalNull(Schema.String),
+        url: optionalNull(Schema.String),
+        revised_prompt: optionalNull(Schema.String),
+        mime_type: optionalNull(Schema.String),
+    })),
+    usage: Schema.optional(Schema.Unknown),
+});
+const nativeOptions = (options) => {
+    if (!options)
+        return undefined;
+    const { aspectRatio, responseFormat, ...native } = options;
+    return {
+        aspect_ratio: aspectRatio,
+        response_format: responseFormat,
+        ...native,
+    };
+};
+const invalidOutput = (message) => new AIError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
+});
+const applyQuery = (url, query) => {
+    if (!query)
+        return url;
+    const next = new URL(url);
+    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
+    return next.toString();
+};
+export const model = (input) => {
+    const route = {
+        id: ADAPTER,
+        generate: Effect.fn("XAIImages.generate")(function* (request, execute) {
+            const http = mergeHttpOptions(request.model.http, request.http);
+            const imageReferences = (request.images ?? []).map((image) => {
+                if (image.type === "bytes")
+                    return { url: ImageInputs.dataUrl(image), type: "image_url" };
+                if (image.type === "url")
+                    return { url: image.url, type: "image_url" };
+                if (image.type === "file-id")
+                    return { file_id: image.id };
+                return undefined;
+            });
+            if (imageReferences.some((image) => image === undefined))
+                return yield* ImageInputs.invalid(ADAPTER, "xAI Images accepts image URLs, data URLs, bytes, and file IDs");
+            const requestBody = mergeJsonRecords({
+                model: request.model.id,
+                prompt: request.prompt,
+                image: imageReferences.length === 1 ? imageReferences[0] : undefined,
+                images: imageReferences.length > 1 ? imageReferences : undefined,
+            }, nativeOptions(request.options), http?.body);
+            const text = ProviderShared.encodeJson(requestBody);
+            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${imageReferences.length === 0 ? PATH : EDIT_PATH}`, http?.query);
+            const headers = yield* Auth.toEffect(input.auth)({
+                request,
+                method: "POST",
+                url,
+                body: text,
+                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
+            });
+            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
+            const payload = yield* response.json.pipe(Effect.mapError(() => invalidOutput("Failed to read the xAI Images response")));
+            const decoded = yield* Schema.decodeUnknownEffect(XAIImageResponse)(payload).pipe(Effect.mapError(() => invalidOutput("xAI Images returned an invalid response")));
+            const images = yield* Effect.forEach(decoded.data, (item, index) => {
+                const mediaType = item.mime_type ?? "application/octet-stream";
+                if (item.b64_json)
+                    return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(Effect.mapError(() => invalidOutput(`xAI Images result ${index} contains invalid base64 data`)), Effect.map((data) => new GeneratedImage({
+                        mediaType,
+                        data,
+                        providerMetadata: item.revised_prompt === undefined || item.revised_prompt === null
+                            ? undefined
+                            : { xai: { revisedPrompt: item.revised_prompt } },
+                    })));
+                if (item.url)
+                    return Effect.succeed(new GeneratedImage({
+                        mediaType,
+                        data: item.url,
+                        providerMetadata: item.revised_prompt === undefined || item.revised_prompt === null
+                            ? undefined
+                            : { xai: { revisedPrompt: item.revised_prompt } },
+                    }));
+                return Effect.fail(invalidOutput(`xAI Images result ${index} has neither image data nor a URL`));
+            });
+            if (images.length === 0)
+                return yield* invalidOutput("xAI Images returned no images");
+            const usage = ProviderShared.isRecord(decoded.usage) ? decoded.usage : undefined;
+            return new ImageResponse({
+                images,
+                usage: usage === undefined ? undefined : new Usage({ providerMetadata: { xai: usage } }),
+                providerMetadata: usage === undefined ? undefined : { xai: { usage } },
+            });
+        }),
+    };
+    return ImageModel.make({ id: input.id, provider: "xai", route, http: input.http });
+};
+export const XAIImages = {
+    model,
+};

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

@@ -0,0 +1,22 @@
+import { ImageModel } from "../image.js";
+import { type Definition as AuthDefinition } from "../route/auth.js";
+import { type HttpOptions } from "../schema/index.js";
+export declare const DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4";
+export declare const PATH = "/images/generations";
+export type ZAIImageString<Known extends string> = Known | (string & {});
+export type ZAIImageOptions = {
+    readonly size?: ZAIImageString<"1024x1024" | "768x1344" | "864x1152" | "1344x768" | "1152x864" | "1440x720" | "720x1440">;
+    readonly quality?: ZAIImageString<"hd" | "standard">;
+    readonly userID?: string;
+} & Record<string, unknown>;
+export interface ModelInput {
+    readonly id: string;
+    readonly auth: AuthDefinition;
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions;
+}
+export declare const model: (input: ModelInput) => ImageModel<ZAIImageOptions>;
+export declare const ZAIImages: {
+    readonly model: (input: ModelInput) => ImageModel<ZAIImageOptions>;
+};

package/dist/protocols/zai-images.js

@@ -0,0 +1,84 @@
+import { Effect, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { GeneratedImage, ImageModel, ImageResponse } from "../image.js";
+import { Auth } from "../route/auth.js";
+import { InvalidProviderOutputReason, AIError, mergeHttpOptions, mergeJsonRecords, } from "../schema/index.js";
+import { ProviderShared } from "./shared.js";
+import { ImageInputs } from "./utils/image-input.js";
+const ADAPTER = "zai-images";
+export const DEFAULT_BASE_URL = "https://api.z.ai/api/paas/v4";
+export const PATH = "/images/generations";
+const ZAIImageResponse = Schema.Struct({
+    created: Schema.optional(Schema.Int),
+    id: Schema.optional(Schema.String),
+    request_id: Schema.optional(Schema.String),
+    data: Schema.Array(Schema.Struct({ url: Schema.String })),
+    content_filter: Schema.optional(Schema.Array(Schema.Struct({
+        role: Schema.optional(Schema.String),
+        level: Schema.optional(Schema.Number),
+    }))),
+});
+const nativeOptions = (options) => {
+    if (!options)
+        return undefined;
+    const { userID, ...native } = options;
+    return {
+        user_id: userID,
+        ...native,
+    };
+};
+const invalidOutput = (message) => new AIError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
+});
+const applyQuery = (url, query) => {
+    if (!query)
+        return url;
+    const next = new URL(url);
+    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
+    return next.toString();
+};
+export const model = (input) => {
+    const route = {
+        id: ADAPTER,
+        generate: Effect.fn("ZAIImages.generate")(function* (request, execute) {
+            if ((request.images?.length ?? 0) > 0)
+                return yield* ImageInputs.invalid(ADAPTER, "Z.ai hosted image generation does not support image inputs");
+            const http = mergeHttpOptions(request.model.http, request.http);
+            const requestBody = mergeJsonRecords({ model: request.model.id, prompt: request.prompt }, nativeOptions(request.options), http?.body);
+            const text = ProviderShared.encodeJson(requestBody);
+            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${PATH}`, http?.query);
+            const headers = yield* Auth.toEffect(input.auth)({
+                request,
+                method: "POST",
+                url,
+                body: text,
+                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
+            });
+            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
+            const payload = yield* response.json.pipe(Effect.mapError(() => invalidOutput("Failed to read the Z.ai Images response")));
+            const decoded = yield* Schema.decodeUnknownEffect(ZAIImageResponse)(payload).pipe(Effect.mapError(() => invalidOutput("Z.ai Images returned an invalid response")));
+            if (decoded.data.length === 0)
+                return yield* invalidOutput("Z.ai Images returned no images");
+            return new ImageResponse({
+                images: decoded.data.map((item) => new GeneratedImage({
+                    mediaType: "application/octet-stream",
+                    data: item.url,
+                })),
+                providerMetadata: {
+                    zai: {
+                        created: decoded.created,
+                        id: decoded.id,
+                        requestID: decoded.request_id,
+                        contentFilter: decoded.content_filter,
+                    },
+                },
+            });
+        }),
+    };
+    return ImageModel.make({ id: input.id, provider: "zai", route, http: input.http });
+};
+export const ZAIImages = {
+    model,
+};

package/dist/protocols.d.ts

@@ -0,0 +1 @@
+export * from "./protocols/index.js";

package/dist/protocols.js

@@ -0,0 +1 @@
+export * from "./protocols/index.js";

package/dist/provider-error.d.ts

@@ -0,0 +1,14 @@
+import { AIError, type HttpContext, type HttpRateLimitDetails, type ProviderMetadata } from "./schema/index.js";
+export declare const isContextOverflow: (message: string) => boolean;
+export declare const isPayloadTooLarge: (message: string) => boolean;
+export declare const isContextOverflowFailure: (failure: unknown) => boolean;
+export interface ProviderFailure {
+    readonly message: string;
+    readonly status?: number | undefined;
+    readonly code?: string | undefined;
+    readonly retryAfterMs?: number | undefined;
+    readonly rateLimit?: HttpRateLimitDetails | undefined;
+    readonly http?: HttpContext | undefined;
+    readonly providerMetadata?: ProviderMetadata | undefined;
+}
+export declare function classifyProviderFailure(input: ProviderFailure): AIError["reason"];

package/dist/provider-error.js

@@ -0,0 +1,130 @@
+import { Option, Schema } from "effect";
+import { AuthenticationReason, ContentPolicyReason, InvalidRequestReason, AIError, ProviderErrorEvent, ProviderInternalReason, QuotaExceededReason, RateLimitReason, UnknownProviderReason, } from "./schema/index.js";
+const patterns = [
+    /prompt is too long/i,
+    /input is too long for requested model/i,
+    /exceeds the context window/i,
+    /exceeds (?:the )?(?:model'?s )?maximum context length(?: of [\d,]+ tokens?|\s*\([\d,]+\))/i,
+    /input token count.*exceeds the maximum/i,
+    /tokens in request more than max tokens allowed/i,
+    /maximum prompt length is \d+/i,
+    /reduce the length of the messages/i,
+    /maximum context length is \d+ tokens/i,
+    /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
+    /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
+    /exceeds the limit of \d+/i,
+    /exceeds the available context size/i,
+    /greater than the context length/i,
+    /context window exceeds limit/i,
+    /exceeded model token limit/i,
+    /context[_ ]length[_ ]exceeded/i,
+    /context length is only \d+ tokens/i,
+    /input length.*exceeds.*context length/i,
+    /prompt too long; exceeded (?:max )?context length/i,
+    /too large for model with \d+ maximum context length/i,
+    /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
+    /model_context_window_exceeded/i,
+    /too many tokens/i,
+    /token limit exceeded/i,
+];
+const payloadPatterns = [/request_too_large/i, /request entity too large/i, /payload too large/i, /request too large/i];
+const exclusions = [/^(throttling error|service unavailable):/i, /rate limit/i, /too many requests/i];
+export const isContextOverflow = (message) => !exclusions.some((pattern) => pattern.test(message)) &&
+    (patterns.some((pattern) => pattern.test(message)) || /^400\s*(status code)?\s*\(no body\)/i.test(message));
+export const isPayloadTooLarge = (message) => payloadPatterns.some((pattern) => pattern.test(message));
+export const isContextOverflowFailure = (failure) => failure instanceof AIError
+    ? failure.reason._tag === "InvalidRequest" && failure.reason.classification === "context-overflow"
+    : Schema.is(ProviderErrorEvent)(failure) && failure.classification === "context-overflow";
+const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString);
+const QUOTA_CODES = new Set(["insufficient_quota", "usage_not_included", "billing_error"]);
+const SERVER_CODES = new Set([
+    "api_error",
+    "internal_error",
+    "internalserverexception",
+    "modelstreamerrorexception",
+    "overloaded_error",
+    "server_error",
+    "server_is_overloaded",
+    "slow_down",
+    "serviceunavailableexception",
+]);
+const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error", "validationexception"]);
+const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|too[_\s]?many[_\s]?requests/i;
+const QUOTA_TEXT = /insufficient[-_\s]?quota|quota[-_\s]?exceeded/i;
+const CONTENT_POLICY_TEXT = /content[-_\s]?policy|content_filter|safety/i;
+// Keep HTTP failures and provider-reported stream failures on one typed path so
+// session retry policy never needs provider-specific string matching.
+export function classifyProviderFailure(input) {
+    const body = input.http?.body ?? "";
+    const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message)]
+        .filter((code) => code !== undefined)
+        .map((code) => code.toLowerCase());
+    const text = body || input.message;
+    const common = { message: input.message, providerMetadata: input.providerMetadata, http: input.http };
+    const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500);
+    if (clientScoped &&
+        (codes.includes("context_length_exceeded") ||
+            codes.includes("model_context_window_exceeded") ||
+            isContextOverflow(text)))
+        return new InvalidRequestReason({ ...common, classification: "context-overflow" });
+    if (input.status === 413 || isPayloadTooLarge(text))
+        return new InvalidRequestReason({ ...common, classification: "payload-too-large" });
+    if (CONTENT_POLICY_TEXT.test(text))
+        return new ContentPolicyReason(common);
+    if (codes.some((code) => QUOTA_CODES.has(code)) || (input.status === 429 && QUOTA_TEXT.test(text)))
+        return new QuotaExceededReason(common);
+    if (input.status === 401)
+        return new AuthenticationReason({ ...common, kind: "invalid" });
+    if (input.status === 403)
+        return new AuthenticationReason({ ...common, kind: "insufficient-permissions" });
+    if (codes.includes("authentication_error"))
+        return new AuthenticationReason({ ...common, kind: "invalid" });
+    if (codes.includes("permission_error"))
+        return new AuthenticationReason({ ...common, kind: "insufficient-permissions" });
+    if (codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception"))
+        return new RateLimitReason({
+            ...common,
+            retryAfterMs: input.retryAfterMs,
+            rateLimit: input.rateLimit,
+        });
+    if (RATE_LIMIT_TEXT.test(text))
+        return new RateLimitReason({
+            ...common,
+            retryAfterMs: input.retryAfterMs,
+            rateLimit: input.rateLimit,
+        });
+    if (codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
+        return new ProviderInternalReason({
+            ...common,
+            status: input.status,
+            retryAfterMs: input.retryAfterMs,
+        });
+    if (input.status === 429) {
+        return new RateLimitReason({
+            ...common,
+            retryAfterMs: input.retryAfterMs,
+            rateLimit: input.rateLimit,
+        });
+    }
+    if (input.status === 408 || input.status === 409 || (input.status !== undefined && input.status >= 500))
+        return new ProviderInternalReason({
+            ...common,
+            status: input.status,
+            retryAfterMs: input.retryAfterMs,
+        });
+    if (codes.some((code) => INVALID_REQUEST_CODES.has(code)))
+        return new InvalidRequestReason(common);
+    if (input.status === 400 || input.status === 404 || input.status === 413 || input.status === 422)
+        return new InvalidRequestReason(common);
+    return new UnknownProviderReason({ ...common, status: input.status });
+}
+function providerCodes(value) {
+    const decoded = Option.getOrUndefined(decodeJson(value));
+    if (!isRecord(decoded))
+        return [];
+    const error = isRecord(decoded.error) ? decoded.error : undefined;
+    return [decoded.code, error?.code, error?.type].filter((value) => typeof value === "string");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/provider-package.d.ts

@@ -0,0 +1,15 @@
+import type { LanguageModel, ProviderOptions } from "./schema/index.js";
+export interface Settings extends Readonly<Record<string, unknown>> {
+    readonly baseURL?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly body?: Readonly<Record<string, unknown>>;
+    readonly limits?: {
+        readonly context: number;
+        readonly input?: number;
+        readonly output: number;
+    };
+}
+export interface Definition<ProviderSettings extends Settings = Settings, Options extends ProviderOptions = ProviderOptions> {
+    readonly model: (modelID: string, settings: ProviderSettings) => LanguageModel<Options>;
+}
+export * as ProviderPackage from "./provider-package.js";

package/dist/provider-package.js

@@ -0,0 +1 @@
+export * as ProviderPackage from "./provider-package.js";

package/dist/provider.d.ts

@@ -0,0 +1,23 @@
+import type { LanguageModel, ModelID, ProviderID } from "./schema/index.js";
+export type LanguageModelOptions = Pick<LanguageModel.Input, "defaults" | "compatibility">;
+/**
+ * Advanced structural provider definition helper. Built-in providers should
+ * prefer explicit `configure(options).model(id)` facades so deployment config is
+ * chosen before model selection. The optional `apis` map remains for external
+ * structural providers that expose multiple route selectors behind one provider.
+ */
+export type LanguageModelFactory<Options extends LanguageModelOptions = LanguageModelOptions> = (id: string | ModelID, options?: Options) => LanguageModel;
+type AnyLanguageModelFactory = (...args: never[]) => LanguageModel;
+export interface Definition<Factory extends AnyLanguageModelFactory = LanguageModelFactory> {
+    readonly id: ProviderID;
+    readonly model: Factory;
+    readonly apis?: Record<string, AnyLanguageModelFactory>;
+}
+type DefinitionShape = {
+    readonly id: ProviderID;
+    readonly model: (...args: never[]) => LanguageModel;
+    readonly apis?: Record<string, (...args: never[]) => LanguageModel>;
+};
+type NoExtraFields<Input, Shape> = Input & Record<Exclude<keyof Input, keyof Shape>, never>;
+export declare const make: <DefinitionType extends DefinitionShape>(definition: NoExtraFields<DefinitionType, DefinitionShape>) => NoExtraFields<DefinitionType, DefinitionShape>;
+export * as Provider from "./provider.js";

package/dist/provider.js

@@ -0,0 +1,2 @@
+export const make = (definition) => definition;
+export * as Provider from "./provider.js";

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

@@ -0,0 +1,2 @@
+export { chatModel as model } from "../../amazon-bedrock-mantle.js";
+export type { Settings } from "../../amazon-bedrock-mantle.js";

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

@@ -0,0 +1 @@
+export { chatModel as model } from "../../amazon-bedrock-mantle.js";

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

@@ -0,0 +1,2 @@
+export { responsesModel as model } from "../../amazon-bedrock-mantle.js";
+export type { Settings } from "../../amazon-bedrock-mantle.js";

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

@@ -0,0 +1 @@
+export { responsesModel as model } from "../../amazon-bedrock-mantle.js";

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

@@ -0,0 +1,2 @@
+export { chatModel as model } from "../amazon-bedrock-mantle.js";
+export type { Settings } from "../amazon-bedrock-mantle.js";

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

@@ -0,0 +1 @@
+export { chatModel as model } from "../amazon-bedrock-mantle.js";