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

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

@@ -0,0 +1,181 @@
+import type { ProviderPackage } from "../provider-package";
+import type { RouteDefaultsInput } from "../route/client";
+import { type ModelID, type ProviderOptions } from "../schema";
+import { GoogleVertexShared } from "./google-vertex-shared";
+export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export type Config = RouteDefaultsInput & GoogleVertexShared.OAuthOptions & {
+    readonly baseURL?: string;
+    readonly location?: string;
+    readonly project?: string;
+};
+export interface Settings extends ProviderPackage.Settings {
+    readonly accessToken?: string;
+    readonly apiKey?: never;
+    readonly baseURL?: string;
+    readonly location?: string;
+    readonly project?: string;
+    readonly providerOptions?: ProviderOptions;
+}
+export declare const routes: import("../route").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;
+    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;
+        }[];
+    })[];
+    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;
+    temperature?: number | undefined;
+    stream: true;
+    max_tokens: number;
+    stop_sequences?: readonly string[] | undefined;
+    thinking?: {
+        readonly type: "enabled";
+        readonly budget_tokens: number;
+    } | {
+        readonly type: "adaptive";
+        readonly display?: "summarized" | "omitted" | undefined;
+    } | {
+        readonly type: "disabled";
+    } | undefined;
+    tool_choice?: {
+        readonly type: "auto" | "any";
+    } | {
+        readonly type: "tool";
+        readonly name: string;
+    } | undefined;
+    top_k?: number | undefined;
+    top_p?: number | undefined;
+    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"];

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

@@ -0,0 +1,46 @@
+import { GoogleVertexAnthropic } from "../protocols/google-vertex-anthropic";
+import { ProviderID } from "../schema";
+import { GoogleVertexShared } from "./google-vertex-shared";
+export const id = ProviderID.make("google-vertex-anthropic");
+export const routes = [GoogleVertexAnthropic.route];
+const configuredRoute = (input) => {
+    if ("apiKey" in input && input.apiKey !== undefined)
+        throw new Error("Google Vertex Anthropic 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 GoogleVertexAnthropic.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 Anthropic 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-shared.d.ts

@@ -0,0 +1,22 @@
+import { Auth } from "../route/auth";
+export type OAuthOptions = {
+    readonly accessToken?: string;
+    readonly auth?: never;
+} | {
+    readonly accessToken?: never;
+    readonly auth?: Auth.Definition;
+};
+export type ApiKeyOptions = (OAuthOptions & {
+    readonly apiKey?: never;
+}) | {
+    readonly accessToken?: never;
+    readonly apiKey?: string;
+    readonly auth?: never;
+};
+export declare const project: (value?: string) => string | undefined;
+export declare const location: (value: string | undefined, fallback: string) => string;
+export declare const host: (location: string) => string;
+export declare const requireProject: (value: string | undefined) => string;
+export declare const apiKey: (input: ApiKeyOptions) => string | undefined;
+export declare const oauth: (input: OAuthOptions, project?: string) => Auth.Definition;
+export * as GoogleVertexShared from "./google-vertex-shared";

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

@@ -0,0 +1,61 @@
+import { Effect, Redacted } from "effect";
+import { Auth, MissingCredentialError } from "../route/auth";
+const SCOPE = "https://www.googleapis.com/auth/cloud-platform";
+export const project = (value) => value ??
+    process.env.GOOGLE_VERTEX_PROJECT ??
+    process.env.GOOGLE_CLOUD_PROJECT ??
+    process.env.GCP_PROJECT ??
+    process.env.GCLOUD_PROJECT;
+export const location = (value, fallback) => value ??
+    process.env.GOOGLE_VERTEX_LOCATION ??
+    process.env.GOOGLE_CLOUD_LOCATION ??
+    process.env.VERTEX_LOCATION ??
+    fallback;
+export const host = (location) => {
+    if (location === "global")
+        return "aiplatform.googleapis.com";
+    // Jurisdictional multi-regions use Regional Endpoint Platform domains.
+    if (location === "eu" || location === "us")
+        return `aiplatform.${location}.rep.googleapis.com`;
+    return `${location}-aiplatform.googleapis.com`;
+};
+export const requireProject = (value) => {
+    if (value)
+        return value;
+    throw new Error("Google Vertex requires a project when baseURL is not configured");
+};
+export const apiKey = (input) => {
+    if (input.apiKey !== undefined && (input.accessToken !== undefined || input.auth !== undefined))
+        throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth");
+    if (input.accessToken !== undefined || input.auth !== undefined)
+        return undefined;
+    return input.apiKey ?? process.env.GOOGLE_VERTEX_API_KEY;
+};
+const adc = (project) => {
+    let client;
+    const loadClient = () => {
+        if (client)
+            return client;
+        client = import("google-auth-library").then(({ GoogleAuth }) => new GoogleAuth({ projectId: project, scopes: [SCOPE] }).getClient());
+        return client;
+    };
+    return Auth.effect(Effect.tryPromise({
+        try: async () => {
+            const token = await (await loadClient()).getAccessToken();
+            if (!token.token)
+                throw new Error("Google ADC returned an empty access token");
+            return Redacted.make(token.token);
+        },
+        catch: () => new MissingCredentialError("Google Application Default Credentials"),
+    })).bearer();
+};
+export const oauth = (input, project) => {
+    if (input.accessToken !== undefined && input.auth !== undefined)
+        throw new Error("Google Vertex accessToken cannot be combined with auth");
+    if (input.auth)
+        return input.auth;
+    if (input.accessToken !== undefined)
+        return Auth.bearer(input.accessToken);
+    return adc(project);
+};
+export * as GoogleVertexShared from "./google-vertex-shared";

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

@@ -0,0 +1,93 @@
+import type { ProviderPackage } from "../provider-package";
+import type { RouteDefaultsInput } from "../route/client";
+import { type ModelID, type ProviderOptions } from "../schema";
+import { GoogleVertexShared } from "./google-vertex-shared";
+export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export type Config = RouteDefaultsInput & GoogleVertexShared.ApiKeyOptions & {
+    readonly baseURL?: string;
+    readonly location?: string;
+    readonly project?: string;
+};
+export type Settings = ProviderPackage.Settings & ({
+    readonly accessToken?: string;
+    readonly apiKey?: never;
+} | {
+    readonly accessToken?: never;
+    readonly apiKey?: string;
+}) & {
+    readonly baseURL?: string;
+    readonly location?: string;
+    readonly project?: string;
+    readonly providerOptions?: ProviderOptions;
+};
+export declare const routes: import("../route").Route<{
+    readonly contents: readonly {
+        readonly role: "user" | "model";
+        readonly parts: readonly ({
+            readonly text: string;
+            readonly thought?: boolean | undefined;
+            readonly thoughtSignature?: string | undefined;
+        } | {
+            readonly inlineData: {
+                readonly mimeType: string;
+                readonly data: string;
+            };
+        } | {
+            readonly functionCall: {
+                readonly name: string;
+                readonly args: unknown;
+            };
+            readonly thoughtSignature?: string | undefined;
+        } | {
+            readonly functionResponse: {
+                readonly name: string;
+                readonly response: unknown;
+            };
+        })[];
+    }[];
+    readonly systemInstruction?: {
+        readonly parts: readonly {
+            readonly text: string;
+        }[];
+    } | undefined;
+    readonly tools?: readonly {
+        readonly functionDeclarations: readonly {
+            readonly name: string;
+            readonly description: string;
+            readonly parameters?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        }[];
+    }[] | undefined;
+    readonly toolConfig?: {
+        readonly functionCallingConfig: {
+            readonly mode: "AUTO" | "NONE" | "ANY";
+            readonly allowedFunctionNames?: readonly string[] | undefined;
+        };
+    } | undefined;
+    readonly generationConfig?: {
+        readonly maxOutputTokens?: number | undefined;
+        readonly temperature?: number | undefined;
+        readonly topP?: number | undefined;
+        readonly topK?: number | undefined;
+        readonly stopSequences?: readonly string[] | undefined;
+        readonly thinkingConfig?: {
+            readonly thinkingBudget?: number | undefined;
+            readonly includeThoughts?: boolean | undefined;
+        } | 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"];

package/dist/providers/google-vertex.js

@@ -0,0 +1,49 @@
+import { GoogleVertexGemini } from "../protocols/google-vertex-gemini";
+import { Auth } from "../route/auth";
+import { ProviderID } from "../schema";
+import { GoogleVertexShared } from "./google-vertex-shared";
+export const id = ProviderID.make("google-vertex");
+export const routes = [GoogleVertexGemini.route];
+const configuredRoute = (input, modelID) => {
+    const { accessToken: _accessToken, apiKey: _apiKey, auth: _auth, baseURL, location: inputLocation, project: inputProject, ...rest } = input;
+    const apiKey = GoogleVertexShared.apiKey(input);
+    const endpointModel = String(modelID).startsWith("endpoints/");
+    if (apiKey !== undefined && endpointModel)
+        throw new Error("Google Vertex tuned models do not support Express Mode API keys");
+    const location = GoogleVertexShared.location(inputLocation, "us-central1");
+    const project = GoogleVertexShared.project(inputProject);
+    const endpoint = baseURL ??
+        (apiKey
+            ? "https://aiplatform.googleapis.com/v1/publishers/google"
+            : `https://${GoogleVertexShared.host(location)}/v1beta1/projects/${GoogleVertexShared.requireProject(project)}/locations/${location}${endpointModel ? "" : "/publishers/google"}`);
+    return GoogleVertexGemini.route.with({
+        ...rest,
+        endpoint: { baseURL: endpoint },
+        auth: apiKey === undefined ? GoogleVertexShared.oauth(input, project) : Auth.header("x-goog-api-key", apiKey),
+    });
+};
+export const configure = (input = {}) => {
+    return {
+        id,
+        model: (modelID) => configuredRoute(input, modelID).model({ id: modelID }),
+        configure,
+    };
+};
+export const provider = {
+    id,
+    configure,
+};
+export const model = (modelID, settings) => {
+    if (settings.apiKey !== undefined && settings.accessToken !== undefined)
+        throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth");
+    return configure({
+        ...(settings.apiKey === undefined ? { accessToken: settings.accessToken } : { apiKey: settings.apiKey }),
+        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.d.ts

@@ -0,0 +1,85 @@
+import type { RouteDefaultsInput } from "../route/client";
+import type { ProviderAuthOption } from "../route/auth-options";
+import type { ProviderPackage } from "../provider-package";
+import { type ModelID, type ProviderOptions } from "../schema";
+export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
+export declare const routes: import("../route").Route<{
+    readonly contents: readonly {
+        readonly role: "user" | "model";
+        readonly parts: readonly ({
+            readonly text: string;
+            readonly thought?: boolean | undefined;
+            readonly thoughtSignature?: string | undefined;
+        } | {
+            readonly inlineData: {
+                readonly mimeType: string;
+                readonly data: string;
+            };
+        } | {
+            readonly functionCall: {
+                readonly name: string;
+                readonly args: unknown;
+            };
+            readonly thoughtSignature?: string | undefined;
+        } | {
+            readonly functionResponse: {
+                readonly name: string;
+                readonly response: unknown;
+            };
+        })[];
+    }[];
+    readonly systemInstruction?: {
+        readonly parts: readonly {
+            readonly text: string;
+        }[];
+    } | undefined;
+    readonly tools?: readonly {
+        readonly functionDeclarations: readonly {
+            readonly name: string;
+            readonly description: string;
+            readonly parameters?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        }[];
+    }[] | undefined;
+    readonly toolConfig?: {
+        readonly functionCallingConfig: {
+            readonly mode: "AUTO" | "NONE" | "ANY";
+            readonly allowedFunctionNames?: readonly string[] | undefined;
+        };
+    } | undefined;
+    readonly generationConfig?: {
+        readonly maxOutputTokens?: number | undefined;
+        readonly temperature?: number | undefined;
+        readonly topP?: number | undefined;
+        readonly topK?: number | undefined;
+        readonly stopSequences?: readonly string[] | undefined;
+        readonly thinkingConfig?: {
+            readonly thinkingBudget?: number | undefined;
+            readonly includeThoughts?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+}, import("../route/transport/http").HttpPrepared<string>>[];
+export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+};
+export interface Settings extends ProviderPackage.Settings {
+    readonly apiKey?: string;
+    readonly baseURL?: string;
+    readonly providerOptions?: ProviderOptions;
+}
+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/google.js

@@ -0,0 +1,33 @@
+import { Auth } from "../route/auth";
+import { ProviderID } from "../schema";
+import * as Gemini from "../protocols/gemini";
+export const id = ProviderID.make("google");
+export const routes = [Gemini.route];
+const auth = (options) => {
+    if ("auth" in options && options.auth)
+        return options.auth;
+    return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
+        .orElse(Auth.config("GOOGLE_GENERATIVE_AI_API_KEY"))
+        .pipe(Auth.header("x-goog-api-key"));
+};
+const configuredRoute = (input) => {
+    const { apiKey: _, auth: _auth, baseURL, ...rest } = input;
+    return Gemini.route.with({ ...rest, endpoint: { baseURL }, auth: auth(input) });
+};
+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) => configure({
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
+    providerOptions: settings.providerOptions,
+}).model(modelID);

package/dist/providers/index.d.ts

@@ -0,0 +1,15 @@
+export * as Anthropic from "./anthropic";
+export * as AnthropicCompatible from "./anthropic-compatible";
+export * as AmazonBedrock from "./amazon-bedrock";
+export * as Azure from "./azure";
+export * as Cloudflare from "./cloudflare";
+export { CloudflareAIGateway, CloudflareWorkersAI } from "./cloudflare";
+export * as GitHubCopilot from "./github-copilot";
+export * as Google from "./google";
+export * as GoogleVertex from "./google-vertex";
+export * as GoogleVertexAnthropic from "./google-vertex-anthropic";
+export * as OpenAI from "./openai";
+export * as OpenAICompatible from "./openai-compatible";
+export * as OpenAICompatibleResponses from "./openai-compatible-responses";
+export * as OpenRouter from "./openrouter";
+export * as XAI from "./xai";

package/dist/providers/index.js

@@ -0,0 +1,15 @@
+export * as Anthropic from "./anthropic";
+export * as AnthropicCompatible from "./anthropic-compatible";
+export * as AmazonBedrock from "./amazon-bedrock";
+export * as Azure from "./azure";
+export * as Cloudflare from "./cloudflare";
+export { CloudflareAIGateway, CloudflareWorkersAI } from "./cloudflare";
+export * as GitHubCopilot from "./github-copilot";
+export * as Google from "./google";
+export * as GoogleVertex from "./google-vertex";
+export * as GoogleVertexAnthropic from "./google-vertex-anthropic";
+export * as OpenAI from "./openai";
+export * as OpenAICompatible from "./openai-compatible";
+export * as OpenAICompatibleResponses from "./openai-compatible-responses";
+export * as OpenRouter from "./openrouter";
+export * as XAI from "./xai";

package/dist/providers/openai/chat.d.ts

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

package/dist/providers/openai/chat.js

@@ -0,0 +1 @@
+export { chatModel as model } from "../openai";

package/dist/providers/openai/responses.d.ts

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

package/dist/providers/openai/responses.js

@@ -0,0 +1 @@
+export { model } from "../openai";

package/dist/providers/openai-compatible/responses.d.ts

@@ -0,0 +1 @@
+export * from "../openai-compatible-responses";

package/dist/providers/openai-compatible/responses.js

@@ -0,0 +1 @@
+export * from "../openai-compatible-responses";

package/dist/providers/openai-compatible-profile.d.ts

@@ -0,0 +1,43 @@
+export interface OpenAICompatibleProfile {
+    readonly provider: string;
+    readonly baseURL: string;
+}
+export declare const profiles: {
+    readonly baseten: {
+        readonly provider: "baseten";
+        readonly baseURL: "https://inference.baseten.co/v1";
+    };
+    readonly cerebras: {
+        readonly provider: "cerebras";
+        readonly baseURL: "https://api.cerebras.ai/v1";
+    };
+    readonly deepinfra: {
+        readonly provider: "deepinfra";
+        readonly baseURL: "https://api.deepinfra.com/v1/openai";
+    };
+    readonly deepseek: {
+        readonly provider: "deepseek";
+        readonly baseURL: "https://api.deepseek.com/v1";
+    };
+    readonly fireworks: {
+        readonly provider: "fireworks";
+        readonly baseURL: "https://api.fireworks.ai/inference/v1";
+    };
+    readonly groq: {
+        readonly provider: "groq";
+        readonly baseURL: "https://api.groq.com/openai/v1";
+    };
+    readonly openrouter: {
+        readonly provider: "openrouter";
+        readonly baseURL: "https://openrouter.ai/api/v1";
+    };
+    readonly togetherai: {
+        readonly provider: "togetherai";
+        readonly baseURL: "https://api.together.xyz/v1";
+    };
+    readonly xai: {
+        readonly provider: "xai";
+        readonly baseURL: "https://api.x.ai/v1";
+    };
+};
+export declare const byProvider: Record<string, OpenAICompatibleProfile>;