@opencode-ai/ai 0.0.0-beta-17492

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

@@ -0,0 +1,122 @@
+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 { OpenResponsesProviderOptionsInput } from "./open-responses-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?: OpenResponsesProviderOptionsInput;
+};
+export interface Settings extends ProviderPackage.Settings {
+    readonly accessToken?: string;
+    readonly apiKey?: never;
+    readonly baseURL?: string;
+    readonly location?: string;
+    readonly project?: string;
+    readonly providerOptions?: OpenResponsesProviderOptionsInput;
+}
+export declare const routes: import("../route/client.js").Route<{
+    readonly input: readonly ({
+        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 role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "user";
+        readonly content: readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly file_data: string;
+            readonly mime_type?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        })[];
+    } | {
+        readonly content: readonly {
+            readonly type: "output_text";
+            readonly text: string;
+        }[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | undefined;
+    } | {
+        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_image";
+            readonly image_url: string;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly file_data: string;
+            readonly mime_type?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        })[];
+    })[];
+    readonly model: string;
+    readonly stream: true;
+    readonly instructions?: string | undefined;
+    readonly reasoning?: {
+        readonly summary?: "auto" | "concise" | "detailed" | undefined;
+        readonly effort?: string | 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?: "low" | "medium" | "high" | undefined;
+    } | undefined;
+    readonly temperature?: number | undefined;
+    readonly tool_choice?: "required" | "none" | "auto" | {
+        readonly type: "function";
+        readonly name: string;
+    } | undefined;
+    readonly top_p?: number | 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 store?: boolean | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly max_output_tokens?: 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<OpenResponsesProviderOptionsInput>;
+    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<OpenResponsesProviderOptionsInput>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"];

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

@@ -0,0 +1,51 @@
+import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses.js";
+import { ProviderID } from "../schema/index.js";
+import { GoogleVertexShared } from "./google-vertex-shared.js";
+export const id = ProviderID.make("google-vertex");
+const route = OpenAICompatibleResponses.route.with({
+    id: "google-vertex-responses",
+    provider: id,
+    providerOptions: { openresponses: { store: false } },
+});
+export const routes = [route];
+const configuredRoute = (input) => {
+    if ("apiKey" in input && input.apiKey !== undefined)
+        throw new Error("Google Vertex Responses 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 Responses 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.js";
+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.js";

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

@@ -0,0 +1,61 @@
+import { Effect, Redacted } from "effect";
+import { Auth, MissingCredentialError } from "../route/auth.js";
+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.js";

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

@@ -0,0 +1,115 @@
+import type { ProviderPackage } from "../provider-package.js";
+import { Gemini } from "../protocols/gemini.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 GeminiOptionsInput = Gemini.OptionsInput;
+export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput;
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export type Config = RouteDefaultsInput & GoogleVertexShared.ApiKeyOptions & {
+    readonly baseURL?: string;
+    readonly location?: string;
+    readonly project?: string;
+    readonly providerOptions?: Gemini.ProviderOptionsInput;
+};
+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?: Gemini.ProviderOptionsInput;
+};
+export declare const routes: Route<{
+    readonly contents: readonly {
+        readonly role: "user" | "model";
+        readonly parts: readonly ({
+            readonly inlineData: {
+                readonly mimeType: string;
+                readonly data: string;
+            };
+        } | {
+            readonly text: string;
+            readonly thought?: boolean | undefined;
+            readonly thoughtSignature?: string | undefined;
+        } | {
+            readonly functionCall: {
+                readonly name: string;
+                readonly args: unknown;
+                readonly id?: string | undefined;
+            };
+            readonly thoughtSignature?: string | undefined;
+        } | {
+            readonly functionResponse: {
+                readonly name: string;
+                readonly response: unknown;
+                readonly id?: string | undefined;
+                readonly parts?: readonly {
+                    readonly inlineData: {
+                        readonly mimeType: string;
+                        readonly data: string;
+                    };
+                }[] | undefined;
+            };
+        })[];
+    }[];
+    readonly tools?: readonly {
+        readonly functionDeclarations: readonly {
+            readonly description: string;
+            readonly name: 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 cachedContent?: string | undefined;
+    readonly safetySettings?: readonly {
+        readonly category: string;
+        readonly threshold: string;
+    }[] | undefined;
+    readonly serviceTier?: string | undefined;
+    readonly systemInstruction?: {
+        readonly parts: readonly {
+            readonly text: string;
+        }[];
+    } | undefined;
+    readonly generationConfig?: {
+        readonly temperature?: number | undefined;
+        readonly topP?: number | undefined;
+        readonly topK?: number | undefined;
+        readonly frequencyPenalty?: number | undefined;
+        readonly presencePenalty?: number | undefined;
+        readonly seed?: number | undefined;
+        readonly stopSequences?: readonly string[] | undefined;
+        readonly thinkingConfig?: {
+            readonly thinkingBudget?: number | undefined;
+            readonly includeThoughts?: boolean | undefined;
+            readonly thinkingLevel?: string | undefined;
+        } | undefined;
+        readonly maxOutputTokens?: number | 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<Gemini.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<Gemini.ProviderOptionsInput>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"];

package/dist/providers/google-vertex.js

@@ -0,0 +1,64 @@
+import { Gemini } from "../protocols/gemini.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 { ProviderID } from "../schema/index.js";
+import { GoogleVertexShared } from "./google-vertex-shared.js";
+export const id = ProviderID.make("google-vertex");
+const route = Route.make({
+    id: "google-vertex-gemini",
+    provider: id,
+    providerMetadataKey: "google",
+    protocol: Gemini.protocol,
+    endpoint: Endpoint.path(({ request }) => {
+        const model = String(request.model.id);
+        return `/${model.startsWith("endpoints/") ? model : `models/${model}`}:streamGenerateContent?alt=sse`;
+    }),
+    auth: Auth.none,
+    framing: Framing.sse,
+});
+export const routes = [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 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,112 @@
+import type { RouteDefaultsInput } from "../route/client.js";
+import type { ProviderAuthOption } from "../route/auth-options.js";
+import type { ProviderPackage } from "../provider-package.js";
+import { type ModelID } from "../schema/index.js";
+import { Gemini } from "../protocols/gemini.js";
+export type { GoogleImageOptions } from "../protocols/google-images.js";
+export type GeminiOptionsInput = Gemini.OptionsInput;
+export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput;
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export declare const routes: import("../route/client.js").Route<{
+    readonly contents: readonly {
+        readonly role: "user" | "model";
+        readonly parts: readonly ({
+            readonly inlineData: {
+                readonly mimeType: string;
+                readonly data: string;
+            };
+        } | {
+            readonly text: string;
+            readonly thought?: boolean | undefined;
+            readonly thoughtSignature?: string | undefined;
+        } | {
+            readonly functionCall: {
+                readonly name: string;
+                readonly args: unknown;
+                readonly id?: string | undefined;
+            };
+            readonly thoughtSignature?: string | undefined;
+        } | {
+            readonly functionResponse: {
+                readonly name: string;
+                readonly response: unknown;
+                readonly id?: string | undefined;
+                readonly parts?: readonly {
+                    readonly inlineData: {
+                        readonly mimeType: string;
+                        readonly data: string;
+                    };
+                }[] | undefined;
+            };
+        })[];
+    }[];
+    readonly tools?: readonly {
+        readonly functionDeclarations: readonly {
+            readonly description: string;
+            readonly name: 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 cachedContent?: string | undefined;
+    readonly safetySettings?: readonly {
+        readonly category: string;
+        readonly threshold: string;
+    }[] | undefined;
+    readonly serviceTier?: string | undefined;
+    readonly systemInstruction?: {
+        readonly parts: readonly {
+            readonly text: string;
+        }[];
+    } | undefined;
+    readonly generationConfig?: {
+        readonly temperature?: number | undefined;
+        readonly topP?: number | undefined;
+        readonly topK?: number | undefined;
+        readonly frequencyPenalty?: number | undefined;
+        readonly presencePenalty?: number | undefined;
+        readonly seed?: number | undefined;
+        readonly stopSequences?: readonly string[] | undefined;
+        readonly thinkingConfig?: {
+            readonly thinkingBudget?: number | undefined;
+            readonly includeThoughts?: boolean | undefined;
+            readonly thinkingLevel?: string | undefined;
+        } | undefined;
+        readonly maxOutputTokens?: number | undefined;
+    } | undefined;
+}, import("../route/transport/http.js").HttpPrepared<string>>[];
+export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly providerOptions?: Gemini.ProviderOptionsInput;
+};
+export interface Settings extends ProviderPackage.Settings {
+    readonly apiKey?: string;
+    readonly baseURL?: string;
+    readonly providerOptions?: Gemini.ProviderOptionsInput;
+}
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.ProviderOptionsInput>;
+    image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
+    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<Gemini.ProviderOptionsInput>;
+    image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
+    configure: (input?: Config) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.ProviderOptionsInput>;
+        image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"];
+export declare const image: (modelID: string | ModelID) => import("../image.js").ImageModel<import("../protocols/google-images.js").GoogleImageOptions>;

package/dist/providers/google.js

@@ -0,0 +1,43 @@
+import { Auth } from "../route/auth.js";
+import { HttpOptions, ProviderID, mergeHttpOptions } from "../schema/index.js";
+import { Gemini } from "../protocols/gemini.js";
+import { GoogleImages } from "../protocols/google-images.js";
+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);
+    const image = (modelID) => GoogleImages.model({
+        id: modelID,
+        auth: auth(input),
+        baseURL: input.baseURL,
+        headers: input.headers,
+        http: mergeHttpOptions(input.http === undefined ? undefined : HttpOptions.make(input.http)),
+    });
+    return {
+        id,
+        model: (modelID) => route.model({ id: modelID }),
+        image,
+        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);
+export const image = provider.image;

package/dist/providers/index.d.ts

@@ -0,0 +1,18 @@
+export * as Anthropic from "./anthropic.js";
+export * as AnthropicCompatible from "./anthropic-compatible.js";
+export * as AmazonBedrock from "./amazon-bedrock.js";
+export * as AmazonBedrockMantle from "./amazon-bedrock-mantle.js";
+export * as Azure from "./azure.js";
+export * as Cloudflare from "./cloudflare.js";
+export { CloudflareAIGateway, CloudflareWorkersAI } from "./cloudflare.js";
+export * as Google from "./google.js";
+export * as GoogleVertex from "./google-vertex.js";
+export * as GoogleVertexChat from "./google-vertex-chat.js";
+export * as GoogleVertexMessages from "./google-vertex-messages.js";
+export * as GoogleVertexResponses from "./google-vertex-responses.js";
+export * as OpenAI from "./openai.js";
+export * as OpenAICompatible from "./openai-compatible.js";
+export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";
+export * as OpenRouter from "./openrouter.js";
+export * as XAI from "./xai.js";
+export * as ZAI from "./zai.js";

package/dist/providers/index.js

@@ -0,0 +1,18 @@
+export * as Anthropic from "./anthropic.js";
+export * as AnthropicCompatible from "./anthropic-compatible.js";
+export * as AmazonBedrock from "./amazon-bedrock.js";
+export * as AmazonBedrockMantle from "./amazon-bedrock-mantle.js";
+export * as Azure from "./azure.js";
+export * as Cloudflare from "./cloudflare.js";
+export { CloudflareAIGateway, CloudflareWorkersAI } from "./cloudflare.js";
+export * as Google from "./google.js";
+export * as GoogleVertex from "./google-vertex.js";
+export * as GoogleVertexChat from "./google-vertex-chat.js";
+export * as GoogleVertexMessages from "./google-vertex-messages.js";
+export * as GoogleVertexResponses from "./google-vertex-responses.js";
+export * as OpenAI from "./openai.js";
+export * as OpenAICompatible from "./openai-compatible.js";
+export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";
+export * as OpenRouter from "./openrouter.js";
+export * as XAI from "./xai.js";
+export * as ZAI from "./zai.js";

package/dist/providers/open-responses-options.d.ts

@@ -0,0 +1,16 @@
+import type { ResponseIncludable, ServiceTier } from "../protocols/utils/open-responses-options.js";
+import type { ProviderOptions, ReasoningEffort, TextVerbosity } from "../schema/index.js";
+export interface OpenResponsesOptionsInput {
+    readonly [key: string]: unknown;
+    readonly instructions?: string;
+    readonly store?: boolean;
+    readonly reasoningEffort?: ReasoningEffort;
+    readonly reasoningSummary?: "auto" | "concise" | "detailed";
+    readonly include?: ReadonlyArray<ResponseIncludable>;
+    readonly textVerbosity?: TextVerbosity;
+    readonly serviceTier?: ServiceTier;
+}
+export type OpenResponsesProviderOptionsInput = ProviderOptions & {
+    readonly openresponses?: OpenResponsesOptionsInput;
+};
+export * as OpenResponsesProviderOptions from "./open-responses-options.js";

package/dist/providers/open-responses-options.js

@@ -0,0 +1 @@
+export * as OpenResponsesProviderOptions from "./open-responses-options.js";

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

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

package/dist/providers/openai/chat.js

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

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

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

package/dist/providers/openai/responses.js

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