@opencode/ai 0.0.0-reserved → 2.0.0

package/dist/providers/alibaba.js

@@ -0,0 +1,94 @@
+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";
+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 { ProviderConfigurationError, ProviderID, ToolDefinition } from "../schema/index.js";
+export const id = ProviderID.make("alibaba");
+const hosts = new Map([
+    ["ap-southeast-1", "dashscope-intl.aliyuncs.com"],
+    ["cn-beijing", "dashscope.aliyuncs.com"],
+    ["cn-hongkong", "cn-hongkong.dashscope.aliyuncs.com"],
+    ["us-east-1", "dashscope-us.aliyuncs.com"],
+]);
+const chatRoute = Route.make({
+    id: "alibaba-chat",
+    provider: id,
+    providerMetadataKey: "alibaba",
+    protocol: AlibabaChat.protocol,
+    endpoint: Endpoint.path("/chat/completions"),
+    framing: Framing.sse,
+});
+const messagesRoute = Route.make({
+    id: "alibaba-messages",
+    provider: id,
+    providerMetadataKey: "alibaba",
+    protocol: AlibabaMessages.protocol,
+    endpoint: Endpoint.path("/messages"),
+    framing: Framing.sse,
+    headers: () => ({ "anthropic-version": "2023-06-01" }),
+});
+const responsesRoute = Route.make({
+    id: "alibaba-responses",
+    provider: id,
+    providerMetadataKey: "alibaba",
+    protocol: AlibabaResponses.protocol,
+    endpoint: Endpoint.path("/responses"),
+    framing: Framing.sse,
+});
+export const routes = [chatRoute, messagesRoute, responsesRoute];
+export const configure = (input) => {
+    const { apiKey: _key, auth: _auth, region, workspaceID, baseURL, ...rest } = input;
+    const host = region === undefined
+        ? undefined
+        : workspaceID === undefined
+            ? hosts.get(region)
+            : `${workspaceID}.${region}.maas.aliyuncs.com`;
+    if (baseURL === undefined) {
+        if (region === undefined)
+            throw new ProviderConfigurationError({ provider: id, message: "Alibaba requires region or baseURL" });
+        if (host === undefined)
+            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` } };
+    const chat = (id) => chatRoute.with(common).model({ id, compatibility: AlibabaChat.compatibility });
+    const messages = (id) => messagesRoute
+        .with({
+        ...opts,
+        endpoint: { baseURL: baseURL ?? `https://${host}/apps/anthropic/v1` },
+    })
+        .model({ id, compatibility: { requireSignature: false } });
+    const responses = (id) => responsesRoute.with(common).model({ id });
+    return { id, model: chat, chat, messages, responses, configure };
+};
+export const provider = { id, configure };
+export const model = (id, input) => fromSettings(input).chat(id);
+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 },
+        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.");
+export const codeInterpreter = () => hostedTool("code_interpreter", "Execute code with Alibaba's hosted interpreter.");
+function hostedTool(type, description) {
+    return ToolDefinition.make({
+        name: type,
+        description,
+        inputSchema: { type: "object", properties: {} },
+        native: { alibaba: { type } },
+    });
+}
+export * as Alibaba from "./alibaba.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 { responsesModel 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 { responsesModel as model } from "../amazon-bedrock-mantle.js";

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

@@ -0,0 +1,313 @@
+import { Route, type RouteDefaultsInput } from "../route/client.js";
+import type { ProviderPackage } from "../provider-package.js";
+import { type Credentials } from "../protocols/utils/bedrock-auth.js";
+import { type ModelID } from "../schema/index.js";
+import { type OpenAIProviderOptionsInput } from "./openai-options.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = RouteDefaultsInput & {
+    /** Bedrock API key. Falls back to `AWS_BEARER_TOKEN_BEDROCK`; bearer auth takes precedence over SigV4. */
+    readonly apiKey?: string;
+    /** `sigv4` ignores `apiKey` fallbacks from the environment; `bearer` requires a token. */
+    readonly auth?: "bearer" | "sigv4";
+    readonly baseURL?: string;
+    /** Static SigV4 credentials. When omitted the AWS default credential chain resolves them per request. */
+    readonly credentials?: Credentials;
+    /** Shared config profile for the default credential chain. */
+    readonly profile?: string;
+    readonly region?: string;
+    readonly providerOptions?: OpenAIProviderOptionsInput;
+};
+export type Settings = ProviderPackage.Settings & OpenAIProviderOptionsInput & {
+    readonly apiKey?: string;
+    readonly auth?: "bearer" | "sigv4";
+    readonly baseURL?: string;
+    readonly credentials?: Credentials;
+    readonly profile?: string;
+    readonly region?: string;
+    readonly topP?: number;
+};
+export declare const routes: (Route<{
+    readonly model: string;
+    readonly messages: readonly ({
+        readonly role: "system";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly [x: string]: unknown;
+        readonly content: string | null;
+        readonly role: "assistant";
+        readonly reasoning?: string | undefined;
+        readonly reasoning_content?: string | undefined;
+        readonly reasoning_text?: string | undefined;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly reasoning_details?: unknown;
+    } | {
+        readonly content: string;
+        readonly role: "tool";
+        readonly tool_call_id: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    })[];
+    readonly stream: true;
+    readonly max_completion_tokens?: number | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly tools?: readonly {
+        readonly function: {
+            readonly description: string;
+            readonly name: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+            readonly strict?: boolean | undefined;
+        };
+        readonly type: "function";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    readonly stop?: readonly string[] | undefined;
+    readonly temperature?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly reasoning_effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
+    readonly store?: boolean | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly tool_stream?: boolean | undefined;
+}, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined> | Route<{
+    readonly input: readonly ({
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "web_search_call";
+        readonly status?: string | undefined;
+        readonly action?: {
+            readonly [x: string]: unknown;
+        } | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "file_search_call";
+        readonly status?: string | undefined;
+        readonly queries?: readonly string[] | undefined;
+        readonly results?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "code_interpreter_call";
+        readonly status?: string | undefined;
+        readonly code?: string | null | undefined;
+        readonly container_id?: string | null | undefined;
+        readonly outputs?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "mcp_call";
+        readonly status?: string | undefined;
+        readonly name?: string | undefined;
+        readonly output?: string | null | undefined;
+        readonly error?: unknown;
+        readonly arguments?: string | undefined;
+        readonly server_label?: string | undefined;
+    } | {
+        readonly type: "reasoning";
+        readonly summary: readonly {
+            readonly type: "summary_text";
+            readonly text: string;
+        }[];
+        readonly id?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+    } | {
+        readonly type: "compaction";
+        readonly encrypted_content: string;
+        readonly id?: string | null | undefined;
+    } | {
+        readonly role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "developer";
+        readonly content: string;
+    } | {
+        readonly content: readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+            readonly detail?: string | undefined;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
+            readonly file_url?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        })[];
+        readonly role: "user";
+        readonly id?: string | undefined;
+        readonly type?: "message" | undefined;
+        readonly status?: string | undefined;
+    } | {
+        readonly type: "message";
+        readonly content: readonly {
+            readonly type: "output_text";
+            readonly text: string;
+        }[];
+        readonly role: "assistant";
+        readonly id?: string | undefined;
+        readonly status?: string | undefined;
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    } | {
+        readonly type: "function_call";
+        readonly name: string;
+        readonly arguments: string;
+        readonly call_id: string;
+        readonly id?: string | undefined;
+        readonly namespace?: string | undefined;
+    } | {
+        readonly type: "function_call_output";
+        readonly call_id: string;
+        readonly output: string | readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+            readonly detail?: string | undefined;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
+            readonly file_url?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        } | {
+            readonly type: "input_video";
+            readonly video_url: string;
+        })[];
+    })[];
+    readonly model: string;
+    readonly stream: true;
+    readonly metadata?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly instructions?: string | undefined;
+    readonly reasoning?: {
+        readonly summary?: "auto" | "concise" | "detailed" | undefined;
+        readonly effort?: import("../protocols/utils/open-responses-options.js").ReasoningEffort | undefined;
+    } | undefined;
+    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 tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly name: string;
+    } | {
+        readonly type: "allowed_tools";
+        readonly mode: "required" | "auto" | "none";
+        readonly tools: readonly {
+            readonly type: "function";
+            readonly name: string;
+        }[];
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly parallel_tool_calls?: boolean | undefined;
+    readonly store?: boolean | undefined;
+    readonly include?: readonly import("../protocols/utils/open-responses-options.js").ResponseIncludable[] | undefined;
+    readonly truncation?: "auto" | "disabled" | undefined;
+    readonly stream_options?: {
+        readonly include_obfuscation?: boolean | undefined;
+    } | undefined;
+    readonly safety_identifier?: string | undefined;
+    readonly top_logprobs?: number | undefined;
+    readonly max_output_tokens?: number | undefined;
+    readonly max_tool_calls?: number | undefined;
+}, import("../route/transport/http.js").HttpPrepared<string>, import("../route/client.js").CompactionOperations | undefined>)[];
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+        chat: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+        responses: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
+export declare const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];
+export declare const model: (modelID: string, settings: Settings) => import("../schema/options.js").LanguageModel<import("./openai-options.js").OpenAIOptionsInput, import("../route/client.js").CompactionOperations | undefined>;

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

@@ -0,0 +1,79 @@
+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 { BedrockAuth } from "../protocols/utils/bedrock-auth.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: 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",
+    provider: id,
+    providerMetadataKey: "mantle",
+});
+export const routes = [responsesRoute, chatRoute];
+const configuredRoute = (route, input) => {
+    const region = BedrockAuth.resolveRegion(input);
+    return route.with({
+        endpoint: { baseURL: input.baseURL ?? `https://bedrock-mantle.${region}.api.aws/v1` },
+        auth: BedrockAuth.resolveAuth(input, region, {
+            service: "bedrock-mantle",
+            name: "Bedrock Mantle",
+            mode: input.auth,
+        }),
+    });
+};
+const defaults = (input) => {
+    const { apiKey: _, auth: _auth, baseURL: _baseURL, credentials: _credentials, profile: _profile, region: _region, ...rest } = input;
+    return rest;
+};
+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" });
+    if (input.auth === "sigv4" && input.apiKey !== undefined)
+        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);
+    const responses = (modelID) => configuredResponsesRoute
+        .with(withOpenAIOptions(modelID, modelDefaults))
+        .model({ id: modelID });
+    const chat = (modelID) => configuredChatRoute
+        .with(withOpenAIOptions(modelID, modelDefaults))
+        .model({ id: modelID });
+    return {
+        id,
+        model: responses,
+        chat,
+        responses,
+        configure,
+    };
+};
+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,
+});
+export const chatModel = (modelID, settings) => fromSettings(settings).chat(modelID);
+export const responsesModel = (modelID, settings) => fromSettings(settings).responses(modelID);
+export const model = responsesModel;