@opencode-ai/ai 0.0.0-bootstrap.0 → 0.0.0-next-15617

package/dist/provider-error.d.ts

@@ -0,0 +1,13 @@
+import { LLMError, type HttpContext, type HttpRateLimitDetails, type ProviderMetadata } from "./schema";
+export declare const isContextOverflow: (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): LLMError["reason"];

package/dist/provider-error.js

@@ -0,0 +1,122 @@
+import { Option, Schema } from "effect";
+import { AuthenticationReason, ContentPolicyReason, InvalidRequestReason, LLMError, ProviderErrorEvent, ProviderInternalReason, QuotaExceededReason, RateLimitReason, UnknownProviderReason, } from "./schema";
+const patterns = [
+    /prompt is too long/i,
+    /input is too long for requested model/i,
+    /exceeds the context window/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 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,
+    /request entity too large/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,
+    /model_context_window_exceeded/i,
+];
+export const isContextOverflow = (message) => patterns.some((pattern) => pattern.test(message)) || /^4(00|13)\s*(status code)?\s*\(no body\)/i.test(message);
+export const isContextOverflowFailure = (failure) => failure instanceof LLMError
+    ? 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",
+    "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 (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 !== 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 === 409 ||
+        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,13 @@
+import type { Model } from "./schema";
+export interface Settings extends Readonly<Record<string, unknown>> {
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly body?: Readonly<Record<string, unknown>>;
+    readonly limits?: {
+        readonly context: number;
+        readonly output: number;
+    };
+}
+export interface Definition<ProviderSettings extends Settings = Settings> {
+    readonly model: (modelID: string, settings: ProviderSettings) => Model;
+}
+export * as ProviderPackage from "./provider-package";

package/dist/provider-package.js

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

package/dist/provider.d.ts

@@ -0,0 +1,23 @@
+import type { Model, ModelID, ProviderID } from "./schema";
+export type ModelOptions = Pick<Model.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 ModelFactory<Options extends ModelOptions = ModelOptions> = (id: string | ModelID, options?: Options) => Model;
+type AnyModelFactory = (...args: never[]) => Model;
+export interface Definition<Factory extends AnyModelFactory = ModelFactory> {
+    readonly id: ProviderID;
+    readonly model: Factory;
+    readonly apis?: Record<string, AnyModelFactory>;
+}
+type DefinitionShape = {
+    readonly id: ProviderID;
+    readonly model: (...args: never[]) => Model;
+    readonly apis?: Record<string, (...args: never[]) => Model>;
+};
+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";

package/dist/provider.js

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

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

@@ -0,0 +1,150 @@
+import type { RouteDefaultsInput } from "../route/client";
+import type { ProviderPackage } from "../provider-package";
+import { type ModelID } from "../schema";
+import type { BedrockCredentials } from "../protocols/bedrock-converse";
+export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export type Config = RouteDefaultsInput & {
+    readonly apiKey?: string;
+    readonly headers?: Record<string, string>;
+    readonly credentials?: BedrockCredentials;
+    /** AWS region. Defaults to `us-east-1` when neither this nor `credentials.region` is set. */
+    readonly region?: string;
+    /** Override the computed `https://bedrock-runtime.<region>.amazonaws.com` URL. */
+    readonly baseURL?: string;
+};
+export interface Settings extends ProviderPackage.Settings {
+    readonly apiKey?: string;
+    readonly auth?: "bearer" | "sigv4";
+    readonly baseURL?: string;
+    readonly credentials?: BedrockCredentials;
+    readonly region?: string;
+    readonly topP?: number;
+}
+export declare const routes: import("../route").Route<{
+    readonly modelId: string;
+    readonly messages: readonly ({
+        readonly role: "user";
+        readonly content: readonly ({
+            readonly cachePoint: {
+                readonly type: "default";
+                readonly ttl?: "1h" | "5m" | undefined;
+            };
+        } | {
+            readonly image: {
+                readonly format: "png" | "jpeg" | "gif" | "webp";
+                readonly source: {
+                    readonly bytes: string;
+                };
+            };
+        } | {
+            readonly document: {
+                readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+                readonly name: string;
+                readonly source: {
+                    readonly bytes: string;
+                };
+            };
+        } | {
+            readonly text: string;
+        } | {
+            readonly toolResult: {
+                readonly toolUseId: string;
+                readonly content: readonly ({
+                    readonly image: {
+                        readonly format: "png" | "jpeg" | "gif" | "webp";
+                        readonly source: {
+                            readonly bytes: string;
+                        };
+                    };
+                } | {
+                    readonly text: string;
+                } | {
+                    readonly json: unknown;
+                })[];
+                readonly status?: "error" | "success" | undefined;
+            };
+        })[];
+    } | {
+        readonly role: "assistant";
+        readonly content: readonly ({
+            readonly cachePoint: {
+                readonly type: "default";
+                readonly ttl?: "1h" | "5m" | undefined;
+            };
+        } | {
+            readonly text: string;
+        } | {
+            readonly toolUse: {
+                readonly toolUseId: string;
+                readonly name: string;
+                readonly input: unknown;
+            };
+        } | {
+            readonly reasoningContent: {
+                readonly reasoningText?: {
+                    readonly text: string;
+                    readonly signature?: string | undefined;
+                } | undefined;
+            };
+        })[];
+    })[];
+    readonly system?: readonly ({
+        readonly cachePoint: {
+            readonly type: "default";
+            readonly ttl?: "1h" | "5m" | undefined;
+        };
+    } | {
+        readonly text: string;
+    })[] | undefined;
+    readonly inferenceConfig?: {
+        readonly maxTokens?: number | undefined;
+        readonly temperature?: number | undefined;
+        readonly topP?: number | undefined;
+        readonly stopSequences?: readonly string[] | undefined;
+    } | undefined;
+    readonly toolConfig?: {
+        readonly tools: readonly ({
+            readonly cachePoint: {
+                readonly type: "default";
+                readonly ttl?: "1h" | "5m" | undefined;
+            };
+        } | {
+            readonly toolSpec: {
+                readonly name: string;
+                readonly description: string;
+                readonly inputSchema: {
+                    readonly json: {
+                        readonly [x: string]: unknown;
+                    };
+                };
+            };
+        })[];
+        readonly toolChoice?: {
+            readonly auto: {};
+        } | {
+            readonly any: {};
+        } | {
+            readonly tool: {
+                readonly name: string;
+            };
+        } | undefined;
+    } | undefined;
+    readonly additionalModelRequestFields?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+}, import("../route/transport/http").HttpPrepared<object>>[];
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").Model;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").Model;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").Model;
+        configure: /*elided*/ any;
+    };
+};
+export declare const model: ProviderPackage.Definition<Settings>["model"];

package/dist/providers/amazon-bedrock.js

@@ -0,0 +1,41 @@
+import { Auth } from "../route/auth";
+import { ProviderID } from "../schema";
+import * as BedrockConverse from "../protocols/bedrock-converse";
+export const id = ProviderID.make("amazon-bedrock");
+export const routes = [BedrockConverse.route];
+const bedrockBaseURL = (region) => `https://bedrock-runtime.${region}.amazonaws.com`;
+const configuredRoute = (input) => {
+    const { apiKey, credentials, region, baseURL, ...rest } = input;
+    const resolvedRegion = region ?? credentials?.region ?? "us-east-1";
+    return BedrockConverse.route.with({
+        ...rest,
+        provider: id,
+        endpoint: { baseURL: baseURL ?? bedrockBaseURL(resolvedRegion) },
+        auth: apiKey === undefined ? BedrockConverse.sigV4Auth(credentials) : Auth.bearer(apiKey),
+    });
+};
+export const configure = (input = {}) => {
+    const route = configuredRoute(input);
+    return {
+        id,
+        model: (modelID) => route.model({ id: modelID }),
+        configure,
+    };
+};
+export const provider = configure();
+export const model = (modelID, settings) => {
+    if (settings.auth === "bearer" && settings.apiKey === undefined)
+        throw new Error("Amazon Bedrock bearer auth requires apiKey");
+    if (settings.auth === "sigv4" && settings.apiKey !== undefined)
+        throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey");
+    return configure({
+        apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
+        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 } },
+        limits: settings.limits,
+        region: settings.region,
+    }).model(modelID);
+};

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

@@ -0,0 +1,183 @@
+import type { ProviderPackage } from "../provider-package";
+import type { ProviderAuthOption } from "../route/auth-options";
+import type { RouteDefaultsInput } from "../route/client";
+import { type ModelID } from "../schema";
+export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
+    readonly provider?: string;
+    readonly baseURL: string;
+};
+export type Settings = ProviderPackage.Settings & ({
+    readonly apiKey?: string;
+    readonly authToken?: never;
+} | {
+    readonly apiKey?: never;
+    readonly authToken?: string;
+}) & {
+    readonly baseURL: string;
+    readonly provider?: string;
+};
+export declare const routes: import("../route").Route<{
+    readonly model: string;
+    readonly messages: readonly ({
+        readonly role: "user";
+        readonly content: readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image";
+            readonly source: {
+                readonly type: "base64";
+                readonly media_type: string;
+                readonly data: string;
+            };
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        } | {
+            readonly type: "tool_result";
+            readonly tool_use_id: string;
+            readonly content: string | readonly ({
+                readonly type: "text";
+                readonly text: string;
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                    readonly ttl?: "1h" | "5m" | undefined;
+                } | undefined;
+            } | {
+                readonly type: "image";
+                readonly source: {
+                    readonly type: "base64";
+                    readonly media_type: string;
+                    readonly data: string;
+                };
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                    readonly ttl?: "1h" | "5m" | undefined;
+                } | undefined;
+            })[];
+            readonly is_error?: boolean | undefined;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        })[];
+    } | {
+        readonly role: "assistant";
+        readonly content: readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        } | {
+            readonly type: "tool_use";
+            readonly id: string;
+            readonly name: string;
+            readonly input: unknown;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        } | {
+            readonly type: "server_tool_use";
+            readonly id: string;
+            readonly name: string;
+            readonly input: unknown;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        } | {
+            readonly type: "web_search_tool_result" | "code_execution_tool_result" | "web_fetch_tool_result";
+            readonly tool_use_id: string;
+            readonly content: unknown;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        } | {
+            readonly type: "thinking";
+            readonly thinking: string;
+            readonly signature?: string | undefined;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        })[];
+    } | {
+        readonly role: "system";
+        readonly content: readonly {
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        }[];
+    })[];
+    readonly stream: true;
+    readonly max_tokens: number;
+    readonly system?: readonly {
+        readonly type: "text";
+        readonly text: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: "1h" | "5m" | undefined;
+        } | undefined;
+    }[] | undefined;
+    readonly tools?: readonly {
+        readonly name: string;
+        readonly description: string;
+        readonly input_schema: {
+            readonly [x: string]: unknown;
+        };
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: "1h" | "5m" | undefined;
+        } | undefined;
+    }[] | undefined;
+    readonly tool_choice?: {
+        readonly type: "auto" | "any";
+    } | {
+        readonly type: "tool";
+        readonly name: string;
+    } | undefined;
+    readonly temperature?: number | undefined;
+    readonly top_p?: number | undefined;
+    readonly top_k?: number | undefined;
+    readonly stop_sequences?: readonly string[] | undefined;
+    readonly thinking?: {
+        readonly type: "enabled";
+        readonly budget_tokens: number;
+    } | {
+        readonly type: "adaptive";
+        readonly display?: "summarized" | "omitted" | undefined;
+    } | {
+        readonly type: "disabled";
+    } | undefined;
+    readonly output_config?: {
+        readonly effort?: string | undefined;
+    } | undefined;
+}, import("../route/transport/http").HttpPrepared<string>>[];
+export declare const configure: (input: Config) => {
+    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").Model;
+    configure: (input: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    configure: (input: Config) => {
+        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").Model;
+        configure: /*elided*/ any;
+    };
+};
+export declare const model: ProviderPackage.Definition<Settings>["model"];
+export * as AnthropicCompatible from "./anthropic-compatible";

package/dist/providers/anthropic-compatible.js

@@ -0,0 +1,44 @@
+import { AnthropicMessages } from "../protocols/anthropic-messages";
+import { Auth } from "../route/auth";
+import { ProviderID } from "../schema";
+export const id = ProviderID.make("anthropic-compatible");
+export const routes = [AnthropicMessages.route];
+const auth = (input) => {
+    if ("auth" in input && input.auth)
+        return input.auth;
+    return Auth.optional("apiKey" in input ? input.apiKey : undefined, "apiKey").pipe(Auth.header("x-api-key"));
+};
+export const configure = (input) => {
+    if (!input.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,
+        provider,
+        endpoint: { baseURL },
+        auth: auth(input),
+    });
+    return {
+        id: ProviderID.make(provider),
+        model: (modelID) => route.model({ id: modelID }),
+        configure,
+    };
+};
+export const provider = {
+    id,
+    configure,
+};
+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({
+        ...(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 } },
+        limits: settings.limits,
+        provider: settings.provider,
+    }).model(modelID);
+};
+export * as AnthropicCompatible from "./anthropic-compatible";