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

package/dist/providers/cloudflare.d.ts

@@ -0,0 +1,232 @@
+import type { Config, Redacted } from "effect";
+import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options";
+import type { RouteDefaultsInput } from "../route/client";
+import { type ModelID } from "../schema";
+export declare const aiGatewayID: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export declare const workersAIID: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export declare const aiGatewayAuthEnvVars: readonly ["CLOUDFLARE_API_TOKEN", "CF_AIG_TOKEN"];
+export declare const workersAIAuthEnvVars: readonly ["CLOUDFLARE_API_KEY", "CLOUDFLARE_WORKERS_AI_TOKEN"];
+type CloudflareSecret = string | Redacted.Redacted | Config.Config<string | Redacted.Redacted>;
+type GatewayURL = AtLeastOne<{
+    readonly accountId: string;
+    readonly baseURL: string;
+}> & {
+    readonly gatewayId?: string;
+};
+export type AIGatewayOptions = GatewayURL & RouteDefaultsInput & ProviderAuthOption<"optional"> & {
+    /** Cloudflare AI Gateway authentication token. Sent as `cf-aig-authorization`. */
+    readonly gatewayApiKey?: CloudflareSecret;
+};
+type WorkersAIURL = AtLeastOne<{
+    readonly accountId: string;
+    readonly baseURL: string;
+}>;
+export type WorkersAIOptions = WorkersAIURL & RouteDefaultsInput & ProviderAuthOption<"optional">;
+export declare const aiGatewayBaseURL: (input: GatewayURL) => string;
+export declare const workersAIBaseURL: (input: WorkersAIURL) => string;
+export declare const aiGatewayRoute: import("../route").Route<{
+    readonly model: string;
+    readonly messages: readonly ({
+        readonly role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly role: "assistant";
+        readonly content: string | null;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly reasoning_content?: string | undefined;
+    } | {
+        readonly role: "tool";
+        readonly tool_call_id: string;
+        readonly content: string;
+    })[];
+    readonly stream: true;
+    readonly tools?: readonly {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+            readonly description: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+        };
+    }[] | undefined;
+    readonly tool_choice?: "required" | "none" | "auto" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly store?: boolean | undefined;
+    readonly reasoning_effort?: string | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly temperature?: number | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly stop?: readonly string[] | undefined;
+}, import("../route/transport/http").HttpPrepared<string>>;
+export declare const workersAIRoute: import("../route").Route<{
+    readonly model: string;
+    readonly messages: readonly ({
+        readonly role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly role: "assistant";
+        readonly content: string | null;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly reasoning_content?: string | undefined;
+    } | {
+        readonly role: "tool";
+        readonly tool_call_id: string;
+        readonly content: string;
+    })[];
+    readonly stream: true;
+    readonly tools?: readonly {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+            readonly description: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+        };
+    }[] | undefined;
+    readonly tool_choice?: "required" | "none" | "auto" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly store?: boolean | undefined;
+    readonly reasoning_effort?: string | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly temperature?: number | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly stop?: readonly string[] | undefined;
+}, import("../route/transport/http").HttpPrepared<string>>;
+export declare const routes: import("../route").Route<{
+    readonly model: string;
+    readonly messages: readonly ({
+        readonly role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly role: "assistant";
+        readonly content: string | null;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly reasoning_content?: string | undefined;
+    } | {
+        readonly role: "tool";
+        readonly tool_call_id: string;
+        readonly content: string;
+    })[];
+    readonly stream: true;
+    readonly tools?: readonly {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+            readonly description: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+        };
+    }[] | undefined;
+    readonly tool_choice?: "required" | "none" | "auto" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly store?: boolean | undefined;
+    readonly reasoning_effort?: string | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly temperature?: number | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly stop?: readonly string[] | undefined;
+}, import("../route/transport/http").HttpPrepared<string>>[];
+export declare const CloudflareAIGateway: {
+    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    configure: (options: AIGatewayOptions) => {
+        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").Model;
+        configure: /*elided*/ any;
+    };
+};
+export declare const CloudflareWorkersAI: {
+    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    configure: (options: WorkersAIOptions) => {
+        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").Model;
+        configure: /*elided*/ any;
+    };
+};
+export {};

package/dist/providers/cloudflare.js

@@ -0,0 +1,87 @@
+import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat";
+import { Auth } from "../route/auth";
+import { AuthOptions } from "../route/auth-options";
+import { ProviderID } from "../schema";
+export const aiGatewayID = ProviderID.make("cloudflare-ai-gateway");
+export const workersAIID = ProviderID.make("cloudflare-workers-ai");
+export const aiGatewayAuthEnvVars = ["CLOUDFLARE_API_TOKEN", "CF_AIG_TOKEN"];
+export const workersAIAuthEnvVars = ["CLOUDFLARE_API_KEY", "CLOUDFLARE_WORKERS_AI_TOKEN"];
+export const aiGatewayBaseURL = (input) => {
+    if (input.baseURL)
+        return input.baseURL;
+    if (!input.accountId)
+        throw new Error("CloudflareAIGateway.configure requires accountId unless baseURL is supplied");
+    return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(input.accountId)}/${encodeURIComponent(input.gatewayId?.trim() || "default")}/compat`;
+};
+const aiGatewayAuth = (input) => {
+    if ("auth" in input && input.auth)
+        return input.auth;
+    const gateway = Auth.optional(input.gatewayApiKey, "gatewayApiKey")
+        .orElse(Auth.config("CLOUDFLARE_API_TOKEN"))
+        .orElse(Auth.config("CF_AIG_TOKEN"))
+        .pipe(Auth.bearerHeader("cf-aig-authorization"));
+    if (!("apiKey" in input) || input.apiKey === undefined)
+        return gateway;
+    if (input.gatewayApiKey === undefined)
+        return Auth.bearer(input.apiKey);
+    return Auth.bearerHeader("cf-aig-authorization", input.gatewayApiKey).andThen(Auth.bearer(input.apiKey));
+};
+export const workersAIBaseURL = (input) => {
+    if (input.baseURL)
+        return input.baseURL;
+    if (!input.accountId)
+        throw new Error("CloudflareWorkersAI.configure requires accountId unless baseURL is supplied");
+    return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(input.accountId)}/ai/v1`;
+};
+const workersAIAuth = (input) => {
+    return AuthOptions.bearer(input, workersAIAuthEnvVars);
+};
+export const aiGatewayRoute = OpenAICompatibleChat.route.with({
+    id: "cloudflare-ai-gateway",
+    provider: aiGatewayID,
+});
+export const workersAIRoute = OpenAICompatibleChat.route.with({
+    id: "cloudflare-workers-ai",
+    provider: workersAIID,
+});
+export const routes = [aiGatewayRoute, workersAIRoute];
+const aiGatewayDefaults = (options) => {
+    const { accountId: _accountId, gatewayId: _gatewayId, apiKey: _apiKey, gatewayApiKey: _gatewayApiKey, baseURL: _baseURL, auth: _auth, ...rest } = options;
+    return rest;
+};
+const workersAIDefaults = (options) => {
+    const { accountId: _accountId, apiKey: _apiKey, auth: _auth, baseURL: _baseURL, ...rest } = options;
+    return rest;
+};
+const configureAIGateway = (options) => {
+    const route = aiGatewayRoute.with({
+        ...aiGatewayDefaults(options),
+        endpoint: { baseURL: aiGatewayBaseURL(options) },
+        auth: aiGatewayAuth(options),
+    });
+    return {
+        id: aiGatewayID,
+        model: (modelID) => route.model({ id: modelID }),
+        configure: configureAIGateway,
+    };
+};
+const configureWorkersAI = (options) => {
+    const route = workersAIRoute.with({
+        ...workersAIDefaults(options),
+        endpoint: { baseURL: workersAIBaseURL(options) },
+        auth: workersAIAuth(options),
+    });
+    return {
+        id: workersAIID,
+        model: (modelID) => route.model({ id: modelID }),
+        configure: configureWorkersAI,
+    };
+};
+export const CloudflareAIGateway = {
+    id: aiGatewayID,
+    configure: configureAIGateway,
+};
+export const CloudflareWorkersAI = {
+    id: workersAIID,
+    configure: configureWorkersAI,
+};

package/dist/providers/github-copilot.d.ts

@@ -0,0 +1,167 @@
+import { type ProviderAuthOption } from "../route/auth-options";
+import type { RouteDefaultsInput } from "../route/client";
+import { type ModelID } from "../schema";
+import { type OpenAIProviderOptionsInput } from "./openai-options";
+export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export type ModelOptions = Omit<RouteDefaultsInput, "providerOptions"> & ProviderAuthOption<"optional"> & {
+    readonly baseURL: string;
+    readonly endpoint?: "chat" | "responses";
+    readonly providerOptions?: OpenAIProviderOptionsInput;
+};
+export declare const shouldUseResponsesApi: (modelID: string | ModelID, endpoint?: ModelOptions["endpoint"]) => boolean;
+export declare const routes: (import("../route").Route<{
+    readonly model: string;
+    readonly messages: readonly ({
+        readonly role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly role: "assistant";
+        readonly content: string | null;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly reasoning_content?: string | undefined;
+    } | {
+        readonly role: "tool";
+        readonly tool_call_id: string;
+        readonly content: string;
+    })[];
+    readonly stream: true;
+    readonly tools?: readonly {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+            readonly description: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+        };
+    }[] | undefined;
+    readonly tool_choice?: "required" | "none" | "auto" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly store?: boolean | undefined;
+    readonly reasoning_effort?: string | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly temperature?: number | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly stop?: readonly string[] | undefined;
+}, import("../route/transport/http").HttpPrepared<string>> | import("../route").Route<{
+    readonly stream: true;
+    readonly model: string;
+    readonly input: readonly ({
+        readonly role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "user";
+        readonly content: readonly ({
+            readonly type: "input_text";
+            readonly text: string;
+        } | {
+            readonly type: "input_image";
+            readonly image_url: string;
+        })[];
+    } | {
+        readonly role: "assistant";
+        readonly content: readonly {
+            readonly type: "output_text";
+            readonly text: string;
+        }[];
+    } | {
+        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: "item_reference";
+        readonly id: string;
+    } | {
+        readonly type: "function_call";
+        readonly call_id: string;
+        readonly name: string;
+        readonly arguments: string;
+    } | {
+        readonly type: "function_call_output";
+        readonly call_id: string;
+        readonly output: string | readonly ({
+            readonly type: "input_text";
+            readonly text: string;
+        } | {
+            readonly type: "input_image";
+            readonly image_url: string;
+        })[];
+    })[];
+    readonly instructions?: string | undefined;
+    readonly tools?: readonly {
+        readonly type: "function";
+        readonly name: string;
+        readonly description: string;
+        readonly parameters: {
+            readonly [x: string]: unknown;
+        };
+        readonly strict?: boolean | undefined;
+    }[] | undefined;
+    readonly tool_choice?: "required" | "none" | "auto" | {
+        readonly type: "function";
+        readonly name: string;
+    } | undefined;
+    readonly store?: boolean | undefined;
+    readonly service_tier?: "auto" | "default" | "flex" | "priority" | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly include?: readonly ("file_search_call.results" | "web_search_call.results" | "web_search_call.action.sources" | "message.input_image.image_url" | "computer_call_output.output.image_url" | "code_interpreter_call.outputs" | "reasoning.encrypted_content" | "message.output_text.logprobs")[] | undefined;
+    readonly reasoning?: {
+        readonly effort?: string | undefined;
+        readonly summary?: "auto" | undefined;
+    } | undefined;
+    readonly text?: {
+        readonly verbosity?: "low" | "medium" | "high" | undefined;
+    } | undefined;
+    readonly max_output_tokens?: number | undefined;
+    readonly temperature?: number | undefined;
+    readonly top_p?: number | undefined;
+}, import("../route/transport/http").HttpPrepared<string>>)[];
+export declare const configure: (options: ModelOptions) => {
+    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    model: (modelID: string | ModelID) => import("..").Model;
+    responses: (modelID: string | ModelID) => import("..").Model;
+    chat: (modelID: string | ModelID) => import("..").Model;
+    configure: (options: ModelOptions) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+    configure: (options: ModelOptions) => {
+        id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+        model: (modelID: string | ModelID) => import("..").Model;
+        responses: (modelID: string | ModelID) => import("..").Model;
+        chat: (modelID: string | ModelID) => import("..").Model;
+        configure: /*elided*/ any;
+    };
+};

package/dist/providers/github-copilot.js

@@ -0,0 +1,47 @@
+import { AuthOptions } from "../route/auth-options";
+import { ProviderID } from "../schema";
+import * as OpenAIChat from "../protocols/openai-chat";
+import * as OpenAIResponses from "../protocols/openai-responses";
+import { withOpenAIOptions } from "./openai-options";
+export const id = ProviderID.make("github-copilot");
+export const shouldUseResponsesApi = (modelID, endpoint) => {
+    if (endpoint)
+        return endpoint === "responses";
+    const model = String(modelID);
+    const match = /^gpt-(\d+)/.exec(model);
+    if (!match)
+        return false;
+    return Number(match[1]) >= 5 && !model.startsWith("gpt-5-mini");
+};
+export const routes = [OpenAIResponses.route, OpenAIChat.route];
+const chatRoute = OpenAIChat.route.with({ provider: id });
+const responsesRoute = OpenAIResponses.route.with({ provider: id });
+const defaults = (options) => {
+    const { apiKey: _, auth: _auth, baseURL: _baseURL, endpoint: _endpoint, ...rest } = options;
+    return rest;
+};
+const configuredResponsesRoute = (options) => responsesRoute.with({
+    endpoint: { baseURL: options.baseURL },
+    auth: AuthOptions.bearer(options, []),
+});
+const configuredChatRoute = (options) => chatRoute.with({
+    endpoint: { baseURL: options.baseURL },
+    auth: AuthOptions.bearer(options, []),
+});
+export const configure = (options) => {
+    const responsesRoute = configuredResponsesRoute(options);
+    const chatRoute = configuredChatRoute(options);
+    const responses = (modelID) => responsesRoute.with(withOpenAIOptions(modelID, defaults(options))).model({ id: modelID });
+    const chat = (modelID) => chatRoute.with(withOpenAIOptions(modelID, defaults(options))).model({ id: modelID });
+    return {
+        id,
+        model: (modelID) => shouldUseResponsesApi(modelID, options.endpoint) ? responses(modelID) : chat(modelID),
+        responses,
+        chat,
+        configure,
+    };
+};
+export const provider = {
+    id,
+    configure,
+};

package/dist/providers/google-vertex/anthropic.d.ts

@@ -0,0 +1,2 @@
+export { model } from "../google-vertex-anthropic";
+export type { Settings } from "../google-vertex-anthropic";

package/dist/providers/google-vertex/anthropic.js

@@ -0,0 +1 @@
+export { model } from "../google-vertex-anthropic";