@opencode/ai 0.0.0-reserved → 2.0.0

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

@@ -0,0 +1,72 @@
+import { Effect, Redacted } from "effect";
+import { Auth, MissingCredentialError } from "../route/auth.js";
+import { ProviderConfigurationError, ProviderID } from "../schema/index.js";
+const SCOPE = "https://www.googleapis.com/auth/cloud-platform";
+const id = ProviderID.make("google-vertex");
+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 ProviderConfigurationError({
+        provider: id,
+        message: "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 ProviderConfigurationError({
+            provider: id,
+            message: "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 ProviderConfigurationError({
+            provider: id,
+            message: "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,119 @@
+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 interface GeminiOptionsInput extends Gemini.OptionsInput {
+    readonly labels?: Readonly<Record<string, string>>;
+}
+export type GeminiProviderOptionsInput = GeminiOptionsInput;
+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?: GeminiProviderOptionsInput;
+};
+export type Settings = ProviderPackage.Settings & GeminiProviderOptionsInput & ({
+    readonly accessToken?: string;
+    readonly apiKey?: never;
+} | {
+    readonly accessToken?: never;
+    readonly apiKey?: string;
+}) & {
+    readonly baseURL?: string;
+    readonly location?: string;
+    readonly project?: string;
+};
+export declare const routes: Route<{
+    readonly contents: readonly {
+        readonly parts?: readonly ({
+            readonly inlineData: {
+                readonly mimeType: string;
+                readonly data: string;
+            };
+        } | {
+            readonly text: string;
+            readonly thought?: boolean | null | undefined;
+            readonly thoughtSignature?: string | null | undefined;
+        } | {
+            readonly functionCall: {
+                readonly name: string;
+                readonly id?: string | null | undefined;
+                readonly args?: unknown;
+            };
+            readonly thoughtSignature?: string | null | 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;
+            };
+        })[] | null | undefined;
+        readonly role?: "model" | "user" | null | undefined;
+    }[];
+    readonly tools?: readonly {
+        readonly functionDeclarations: readonly {
+            readonly description: string;
+            readonly name: string;
+            readonly parameters?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        }[];
+    }[] | undefined;
+    readonly serviceTier?: string | 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 labels?: {
+        readonly [x: string]: 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>, import("../route/client.js").CompactionOperations | undefined>[];
+export declare const configure: (input?: Config) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<GeminiOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    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<GeminiOptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+        configure: /*elided*/ any;
+    };
+};
+export declare const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsInput>["model"];

package/dist/providers/google-vertex.js

@@ -0,0 +1,98 @@
+import { Effect } from "effect";
+import { Gemini } from "../protocols/gemini.js";
+import { ProviderShared } from "../protocols/shared.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 { ProviderConfigurationError, ProviderID } from "../schema/index.js";
+import { GoogleVertexShared } from "./google-vertex-shared.js";
+export const id = ProviderID.make("google-vertex");
+const fromRequest = Effect.fn("GoogleVertex.fromRequest")(function* (request) {
+    const body = yield* Gemini.protocol.body.from(request);
+    // Vertex's native REST schema rejects `id` on FunctionCall/FunctionResponse parts with HTTP 400,
+    // unlike AI Studio, so history minted there cannot be lowered verbatim.
+    const contents = body.contents.map((content) => ({
+        ...content,
+        parts: (content.parts ?? []).map((part) => {
+            if ("functionCall" in part)
+                return { ...part, functionCall: { ...part.functionCall, id: undefined } };
+            if ("functionResponse" in part)
+                return { ...part, functionResponse: { ...part.functionResponse, id: undefined } };
+            return part;
+        }),
+    }));
+    const value = request.providerOptions?.labels;
+    const labels = ProviderShared.isRecord(value)
+        ? Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"))
+        : undefined;
+    return { ...body, contents, labels };
+});
+const protocol = {
+    ...Gemini.protocol,
+    body: {
+        ...Gemini.protocol.body,
+        from: fromRequest,
+    },
+};
+const route = Route.make({
+    id: "google-vertex-gemini",
+    provider: id,
+    providerMetadataKey: "vertex",
+    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 ProviderConfigurationError({
+            provider: id,
+            message: "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, { accessToken, apiKey, baseURL, body, headers, location, project, ...providerOptions }) => {
+    if (apiKey !== undefined && accessToken !== undefined)
+        throw new ProviderConfigurationError({
+            provider: id,
+            message: "Google Vertex apiKey cannot be combined with accessToken or auth",
+        });
+    return configure({
+        ...(apiKey === undefined ? { accessToken: accessToken } : { apiKey: apiKey }),
+        baseURL,
+        headers: headers === undefined ? undefined : { ...headers },
+        http: body === undefined ? undefined : { body: { ...body } },
+        location,
+        project,
+        providerOptions,
+    }).model(modelID);
+};

package/dist/providers/google.d.ts

@@ -0,0 +1,114 @@
+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 parts?: readonly ({
+            readonly inlineData: {
+                readonly mimeType: string;
+                readonly data: string;
+            };
+        } | {
+            readonly text: string;
+            readonly thought?: boolean | null | undefined;
+            readonly thoughtSignature?: string | null | undefined;
+        } | {
+            readonly functionCall: {
+                readonly name: string;
+                readonly id?: string | null | undefined;
+                readonly args?: unknown;
+            };
+            readonly thoughtSignature?: string | null | 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;
+            };
+        })[] | null | undefined;
+        readonly role?: "model" | "user" | null | undefined;
+    }[];
+    readonly tools?: readonly {
+        readonly functionDeclarations: readonly {
+            readonly description: string;
+            readonly name: string;
+            readonly parameters?: {
+                readonly [x: string]: unknown;
+            } | undefined;
+        }[];
+    }[] | undefined;
+    readonly serviceTier?: string | 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 labels?: {
+        readonly [x: string]: 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>, import("../route/client.js").CompactionOperations | undefined>[];
+export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly providerOptions?: Gemini.ProviderOptionsInput;
+};
+export type Settings = ProviderPackage.Settings & Gemini.ProviderOptionsInput & {
+    readonly apiKey?: string;
+    readonly baseURL?: 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.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    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.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+    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.OptionsInput, import("../route/client.js").CompactionOperations | undefined>;
+        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,42 @@
+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, { apiKey, baseURL, body, headers, ...providerOptions }) => configure({
+    apiKey,
+    baseURL,
+    headers: headers === undefined ? undefined : { ...headers },
+    http: body === undefined ? undefined : { body: { ...body } },
+    providerOptions,
+}).model(modelID);
+export const image = provider.image;