@opencode-ai/ai 0.0.0-beta-17492

package/dist/providers/cloudflare.js

@@ -0,0 +1,87 @@
+import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js";
+import { Auth } from "../route/auth.js";
+import { AuthOptions } from "../route/auth-options.js";
+import { ProviderID } from "../schema/index.js";
+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/google-vertex/chat.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,131 @@
+import type { ProviderPackage } from "../provider-package.js";
+import type { RouteDefaultsInput } from "../route/client.js";
+import { type ModelID } from "../schema/index.js";
+import { GoogleVertexShared } from "./google-vertex-shared.js";
+import type { OpenAIProviderOptionsInput } from "./openai-options.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = RouteDefaultsInput & GoogleVertexShared.OAuthOptions & {
+    readonly baseURL?: string;
+    readonly location?: string;
+    readonly project?: string;
+    readonly providerOptions?: OpenAIProviderOptionsInput;
+};
+export interface Settings extends ProviderPackage.Settings {
+    readonly accessToken?: string;
+    readonly apiKey?: never;
+    readonly baseURL?: string;
+    readonly location?: string;
+    readonly project?: string;
+    readonly providerOptions?: OpenAIProviderOptionsInput;
+}
+export declare const routes: import("../route/client.js").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 stop?: readonly string[] | undefined;
+    readonly max_completion_tokens?: number | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly tools?: readonly {
+        readonly function: {
+            readonly name: string;
+            readonly description: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+        };
+        readonly type: "function";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    readonly temperature?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly tool_choice?: "required" | "none" | "auto" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly reasoning_effort?: string | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+}, import("../route/transport/http.js").HttpPrepared<string>>[];
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<OpenAIProviderOptionsInput>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"];

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

@@ -0,0 +1,50 @@
+import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js";
+import { ProviderID } from "../schema/index.js";
+import { GoogleVertexShared } from "./google-vertex-shared.js";
+export const id = ProviderID.make("google-vertex");
+const route = OpenAICompatibleChat.route.with({
+    id: "google-vertex-chat",
+    provider: id,
+});
+export const routes = [route];
+const configuredRoute = (input) => {
+    if ("apiKey" in input && input.apiKey !== undefined)
+        throw new Error("Google Vertex Chat does not support API keys");
+    const { accessToken: _accessToken, auth: _auth, baseURL, location: inputLocation, project: inputProject, ...rest } = input;
+    const location = GoogleVertexShared.location(inputLocation, "global");
+    const project = GoogleVertexShared.project(inputProject);
+    return route.with({
+        ...rest,
+        endpoint: {
+            baseURL: baseURL ??
+                `https://aiplatform.googleapis.com/v1/projects/${GoogleVertexShared.requireProject(project)}/locations/${location}/endpoints/openapi`,
+        },
+        auth: GoogleVertexShared.oauth(input, project),
+    });
+};
+export const configure = (input = {}) => {
+    const route = configuredRoute(input);
+    return {
+        id,
+        model: (modelID) => route.model({ id: modelID }),
+        configure,
+    };
+};
+export const provider = {
+    id,
+    configure,
+};
+export const model = (modelID, settings) => {
+    if (settings.apiKey !== undefined)
+        throw new Error("Google Vertex Chat does not support API keys");
+    return configure({
+        accessToken: settings.accessToken,
+        baseURL: settings.baseURL,
+        headers: settings.headers === undefined ? undefined : { ...settings.headers },
+        http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+        limits: settings.limits,
+        location: settings.location,
+        project: settings.project,
+        providerOptions: settings.providerOptions,
+    }).model(modelID);
+};

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

@@ -0,0 +1,215 @@
+import type { ProviderPackage } from "../provider-package.js";
+import { AnthropicMessages } from "../protocols/anthropic-messages.js";
+import { Route, type RouteDefaultsInput } from "../route/client.js";
+import { type ModelID } from "../schema/index.js";
+import { GoogleVertexShared } from "./google-vertex-shared.js";
+export type AnthropicOptionsInput = AnthropicMessages.OptionsInput;
+export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInput;
+export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput;
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = RouteDefaultsInput & GoogleVertexShared.OAuthOptions & {
+    readonly baseURL?: string;
+    readonly location?: string;
+    readonly project?: string;
+    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
+};
+export interface Settings extends ProviderPackage.Settings {
+    readonly accessToken?: string;
+    readonly apiKey?: never;
+    readonly baseURL?: string;
+    readonly location?: string;
+    readonly project?: string;
+    readonly providerOptions?: AnthropicMessages.ProviderOptionsInput;
+}
+export declare const routes: Route<{
+    anthropic_version: "vertex-2023-10-16";
+    system?: readonly {
+        readonly type: "text";
+        readonly text: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: "1h" | "5m" | undefined;
+        } | undefined;
+    }[] | undefined;
+    max_tokens: number;
+    tools?: readonly {
+        readonly description: string;
+        readonly name: string;
+        readonly input_schema: {
+            readonly [x: string]: unknown;
+        };
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: "1h" | "5m" | undefined;
+        } | undefined;
+    }[] | undefined;
+    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: "document";
+            readonly source: {
+                readonly type: "base64";
+                readonly media_type: "application/pdf";
+                readonly data: string;
+            };
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        } | {
+            readonly type: "tool_result";
+            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 type: "document";
+                readonly source: {
+                    readonly type: "base64";
+                    readonly media_type: "application/pdf";
+                    readonly data: string;
+                };
+                readonly cache_control?: {
+                    readonly type: "ephemeral";
+                    readonly ttl?: "1h" | "5m" | undefined;
+                } | undefined;
+            })[];
+            readonly tool_use_id: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+            readonly is_error?: boolean | 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 id: string;
+            readonly type: "tool_use";
+            readonly name: string;
+            readonly input: unknown;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        } | {
+            readonly id: string;
+            readonly type: "server_tool_use";
+            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 content: unknown;
+            readonly tool_use_id: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+        } | {
+            readonly type: "thinking";
+            readonly thinking: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: "1h" | "5m" | undefined;
+            } | undefined;
+            readonly signature?: string | undefined;
+        } | {
+            readonly data: string;
+            readonly type: "redacted_thinking";
+            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;
+        }[];
+    })[];
+    temperature?: number | undefined;
+    stream: true;
+    thinking?: {
+        readonly type: "enabled";
+        readonly budget_tokens: number;
+    } | {
+        readonly type: "adaptive";
+        readonly display?: "summarized" | "omitted" | undefined;
+    } | {
+        readonly type: "disabled";
+    } | undefined;
+    tool_choice?: {
+        readonly type: "none" | "auto" | "any";
+    } | {
+        readonly type: "tool";
+        readonly name: string;
+    } | undefined;
+    top_p?: number | undefined;
+    top_k?: number | undefined;
+    stop_sequences?: readonly string[] | undefined;
+    output_config?: {
+        readonly effort?: string | undefined;
+    } | undefined;
+}, import("../route/transport/http.js").HttpPrepared<string>>[];
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
+    configure: (input?: Config) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<AnthropicMessages.ProviderOptionsInput>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"];

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

@@ -0,0 +1,75 @@
+import { Effect, Schema, Struct } from "effect";
+import { AnthropicMessages } from "../protocols/anthropic-messages.js";
+import { Auth } from "../route/auth.js";
+import { Route } from "../route/client.js";
+import { Endpoint } from "../route/endpoint.js";
+import { Framing } from "../route/framing.js";
+import { Protocol } from "../route/protocol.js";
+import { ProviderID } from "../schema/index.js";
+import { GoogleVertexShared } from "./google-vertex-shared.js";
+const VERSION = "vertex-2023-10-16";
+export const id = ProviderID.make("google-vertex");
+const route = Route.make({
+    id: "google-vertex-messages",
+    provider: id,
+    providerMetadataKey: "anthropic",
+    protocol: Protocol.make({
+        id: AnthropicMessages.protocol.id,
+        body: {
+            schema: Schema.Struct({
+                ...Struct.omit(AnthropicMessages.AnthropicMessagesBody.fields, ["model"]),
+                anthropic_version: Schema.Literal(VERSION),
+            }),
+            from: (request) => AnthropicMessages.protocol.body.from(request).pipe(Effect.map((body) => ({
+                ...Struct.omit(body, ["model"]),
+                anthropic_version: VERSION,
+            }))),
+        },
+        stream: AnthropicMessages.protocol.stream,
+    }),
+    endpoint: Endpoint.path(({ request }) => `/${request.model.id}:streamRawPredict`),
+    auth: Auth.none,
+    framing: Framing.sse,
+});
+export const routes = [route];
+const configuredRoute = (input) => {
+    if ("apiKey" in input && input.apiKey !== undefined)
+        throw new Error("Google Vertex Messages does not support API keys");
+    const { accessToken: _accessToken, auth: _auth, baseURL, location: inputLocation, project: inputProject, ...rest } = input;
+    const location = GoogleVertexShared.location(inputLocation, "global");
+    const project = GoogleVertexShared.project(inputProject);
+    return route.with({
+        ...rest,
+        endpoint: {
+            baseURL: baseURL ??
+                `https://${GoogleVertexShared.host(location)}/v1/projects/${GoogleVertexShared.requireProject(project)}/locations/${location}/publishers/anthropic/models`,
+        },
+        auth: GoogleVertexShared.oauth(input, project),
+    });
+};
+export const configure = (input = {}) => {
+    const route = configuredRoute(input);
+    return {
+        id,
+        model: (modelID) => route.model({ id: modelID }),
+        configure,
+    };
+};
+export const provider = {
+    id,
+    configure,
+};
+export const model = (modelID, settings) => {
+    if (settings.apiKey !== undefined)
+        throw new Error("Google Vertex Messages does not support API keys");
+    return configure({
+        accessToken: settings.accessToken,
+        baseURL: settings.baseURL,
+        headers: settings.headers === undefined ? undefined : { ...settings.headers },
+        http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+        limits: settings.limits,
+        location: settings.location,
+        project: settings.project,
+        providerOptions: settings.providerOptions,
+    }).model(modelID);
+};