ag-common 0.0.908 → 0.0.910

package/dist/api/helpers/ai/adapters/google.js

@@ -0,0 +1,429 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetGoogleAdapterForTests = exports.resetModelBackoff = exports.listGoogleModels = exports.generateGoogle = void 0;
+const genai_1 = require("@google/genai");
+const log_1 = require("../../../../common/helpers/log");
+const node_cache_1 = require("../../../../common/helpers/node-cache");
+const retryOnError_1 = require("../../retryOnError");
+const quota_1 = require("../quota");
+Object.defineProperty(exports, "resetModelBackoff", { enumerable: true, get: function () { return quota_1.resetModelBackoff; } });
+const apikey_1 = require("../../google/apikey");
+const FALLBACK_GEMINI_MODELS = [
+    "gemini-3-flash-preview",
+    "gemini-3-pro-preview",
+    "gemini-2.5-pro",
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-lite",
+];
+const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+const NON_TEXT_MODEL_CAPABILITIES = [
+    "audio",
+    "computer-use",
+    "embedding",
+    "image",
+    "live",
+    "robotics",
+    "tts",
+];
+let genAIs = new Map();
+const geminiModelsCache = new node_cache_1.TypedNodeCache({ stdTTL: 86400 });
+const geminiModelsCacheKey = "gemini-models-v3";
+const normalizeModelName = (name) => name.replace(/^models\//, "");
+const isTextGenerationModel = (name) => {
+    const normalizedName = name.toLowerCase();
+    return (normalizedName.startsWith("gemini") &&
+        !NON_TEXT_MODEL_CAPABILITIES.some((capability) => normalizedName.includes(capability)));
+};
+const sortModelsByPreference = (models, prefer) => {
+    const modelArray = [...models];
+    if (prefer === "quality") {
+        return modelArray.sort((a, b) => Number(b.includes("pro")) - Number(a.includes("pro")));
+    }
+    if (prefer === "fast") {
+        return modelArray.sort((a, b) => Number(b.includes("flash")) - Number(a.includes("flash")));
+    }
+    return modelArray;
+};
+const getFetch = (dependencies) => dependencies?.fetch ?? globalThis.fetch;
+const createAbortError = () => {
+    const error = new Error("Google AI request aborted");
+    error.name = "AbortError";
+    return error;
+};
+const awaitWithSignal = async (promise, signal) => {
+    if (signal === undefined)
+        return promise;
+    if (signal.aborted)
+        throw createAbortError();
+    const abort = new Promise((_, reject) => {
+        const onAbort = () => reject(createAbortError());
+        signal.addEventListener("abort", onAbort, { once: true });
+        void promise.then(() => signal.removeEventListener("abort", onAbort), () => signal.removeEventListener("abort", onAbort));
+    });
+    return Promise.race([promise, abort]);
+};
+const parseGoogleModalities = (value) => {
+    if (!Array.isArray(value))
+        return undefined;
+    const modalities = value.filter((item) => item === "text" ||
+        item === "image" ||
+        item === "audio" ||
+        item === "video" ||
+        item === "file");
+    return [...new Set(modalities)];
+};
+const parseGoogleStrings = (value) => {
+    if (!Array.isArray(value))
+        return undefined;
+    return [
+        ...new Set(value.flatMap((item) => {
+            if (typeof item === "string")
+                return item.trim().length > 0 ? [item.trim()] : [];
+            if (typeof item === "object" &&
+                item !== null &&
+                "reasoningEffort" in item &&
+                typeof item.reasoningEffort === "string") {
+                return item.reasoningEffort.trim().length > 0 ? [item.reasoningEffort.trim()] : [];
+            }
+            return [];
+        })),
+    ];
+};
+const googleModelMetadata = (model) => {
+    const id = normalizeModelName(model.name ?? "");
+    const metadata = { id };
+    const inputModalities = parseGoogleModalities(model.inputModalities);
+    const outputModalities = parseGoogleModalities(model.outputModalities);
+    const supportedReasoningEfforts = parseGoogleStrings(model.supportedReasoningEfforts);
+    const defaultReasoningEffort = typeof model.defaultReasoningEffort === "string"
+        ? model.defaultReasoningEffort.trim()
+        : undefined;
+    const prefer = Array.isArray(model.prefer)
+        ? model.prefer.filter((item) => item === "fast" || item === "quality")
+        : undefined;
+    if (inputModalities !== undefined)
+        metadata.inputModalities = inputModalities;
+    if (outputModalities !== undefined)
+        metadata.outputModalities = outputModalities;
+    if (supportedReasoningEfforts !== undefined) {
+        metadata.supportedReasoningEfforts = supportedReasoningEfforts;
+    }
+    if (defaultReasoningEffort !== undefined && defaultReasoningEffort.length > 0) {
+        metadata.defaultReasoningEffort = defaultReasoningEffort;
+    }
+    if (prefer !== undefined)
+        metadata.prefer = [...new Set(prefer)];
+    for (const key of ["webSearch", "isDefault", "ready"]) {
+        const value = model[key];
+        if (typeof value === "boolean")
+            metadata[key] = value;
+    }
+    return metadata;
+};
+const getAvailableGoogleModels = async (dependencies, signal) => {
+    const cachedModels = geminiModelsCache.get(geminiModelsCacheKey);
+    if (cachedModels && cachedModels.length > 0)
+        return cachedModels;
+    const key = (0, apikey_1.getAvailableCombinations)("gemini")[0]?.key;
+    if (!key) {
+        (0, log_1.warn)("No GOOGLE_API_KEY available. Falling back to default model list.");
+        return FALLBACK_GEMINI_MODELS.map((id) => ({ id }));
+    }
+    try {
+        const response = await awaitWithSignal(getFetch(dependencies)(`https://generativelanguage.googleapis.com/v1beta/models?key=${encodeURIComponent(key)}`, { redirect: "manual", ...(signal === undefined ? {} : { signal }) }), signal);
+        if (!response.ok)
+            throw new Error(`model list fetch failed with status ${response.status}`);
+        const payload = (await awaitWithSignal(response.json(), signal));
+        const discoveredModels = [
+            ...new Set((payload.models ?? [])
+                .filter((model) => (model.supportedGenerationMethods ?? []).includes("generateContent"))
+                .map(googleModelMetadata)
+                .filter((model) => model.id.length > 0)),
+        ];
+        if (discoveredModels.length === 0)
+            throw new Error("no generateContent models discovered");
+        geminiModelsCache.set(geminiModelsCacheKey, discoveredModels);
+        (0, log_1.info)(`loaded ${discoveredModels.length} Google AI models from API`);
+        return discoveredModels;
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw createAbortError();
+        (0, log_1.warn)(`Failed to load Google AI models. Falling back to defaults. ${String(error)}`);
+        return FALLBACK_GEMINI_MODELS.map((id) => ({ id }));
+    }
+};
+const getAvailableGeminiModels = async (dependencies, signal) => (await getAvailableGoogleModels(dependencies, signal)).map((model) => model.id);
+const getClients = (createAI = (apiKey) => new genai_1.GoogleGenAI({ apiKey })) => {
+    const combinations = (0, apikey_1.getAvailableCombinations)("gemini");
+    for (const { key } of combinations) {
+        if (!genAIs.has(key))
+            genAIs.set(key, createAI(key));
+    }
+    return combinations.flatMap(({ key }) => {
+        const ai = genAIs.get(key);
+        return ai === undefined ? [] : [[key, ai]];
+    });
+};
+const getCombinations = async (model, prefer, output, signal, config) => {
+    const clients = getClients(config.createAI);
+    const requiresNonTextModel = (output ?? ["text"]).some((modality) => modality !== "text");
+    if (model === undefined && requiresNonTextModel) {
+        throw new Error("Google AI requires an explicit model for non-text output");
+    }
+    const models = model
+        ? [model]
+        : sortModelsByPreference((await getAvailableGeminiModels(config.dependencies, signal)).filter(isTextGenerationModel), prefer);
+    if (models.length === 0)
+        throw new Error("No text generation models are available");
+    const combinations = [];
+    for (const [key, ai] of clients) {
+        for (const selectedModel of models) {
+            const available = (0, apikey_1.getAvailableCombinations)(`gemini-${selectedModel}`, false);
+            if (available.some((entry) => entry.key === key)) {
+                combinations.push([key, ai, selectedModel]);
+            }
+        }
+    }
+    return combinations;
+};
+const mediaType = (mimeType) => {
+    const normalized = mimeType.toLowerCase();
+    if (normalized.startsWith("image/"))
+        return "image";
+    if (normalized.startsWith("audio/"))
+        return "audio";
+    if (normalized.startsWith("video/"))
+        return "video";
+    return "file";
+};
+const toGeminiPart = (part) => {
+    if (part.type === "text")
+        return { text: part.text };
+    if (part.name !== undefined) {
+        throw new Error("Google AI inline media does not support media names");
+    }
+    return {
+        inlineData: {
+            data: part.data,
+            mimeType: part.mimeType,
+        },
+    };
+};
+const toGeminiContents = (request) => {
+    const contents = [];
+    const systemParts = request.instructions === undefined ? [] : [{ text: request.instructions }];
+    for (const input of request.input) {
+        const parts = input.content.map(toGeminiPart);
+        if (input.role === "system" || input.role === "developer") {
+            systemParts.push(...parts);
+            continue;
+        }
+        contents.push({ role: input.role === "assistant" ? "model" : "user", parts });
+    }
+    return {
+        contents,
+        ...(systemParts.length === 0
+            ? {}
+            : { systemInstruction: { role: "user", parts: systemParts } }),
+    };
+};
+const responseModalities = (request) => {
+    const output = request.output ?? ["text"];
+    if (output.length === 0)
+        throw new Error("AI output modalities cannot be empty");
+    for (const modality of output) {
+        if (modality !== "text" && modality !== "image" && modality !== "audio") {
+            throw new Error(`Google AI does not support ${modality} output`);
+        }
+    }
+    return output.map((modality) => modality.toUpperCase());
+};
+const toOutputSchema = (outputSchema) => {
+    if (outputSchema.name.trim().length === 0)
+        throw new Error("AI output schema name is required");
+    const rawSchema = outputSchema.schema;
+    if (typeof rawSchema !== "object" || rawSchema === null || Array.isArray(rawSchema)) {
+        throw new Error("Google AI output schema must be an object");
+    }
+    const schema = rawSchema;
+    const existingTitle = schema.title;
+    if (existingTitle !== undefined && existingTitle !== outputSchema.name) {
+        throw new Error("Google AI output schema name conflicts with its title");
+    }
+    return existingTitle === outputSchema.name ? schema : { ...schema, title: outputSchema.name };
+};
+const toRequestConfig = (request) => {
+    if (request.reasoningEffort !== undefined) {
+        throw new Error("Google AI adapter does not support reasoningEffort");
+    }
+    const { contents, systemInstruction } = toGeminiContents(request);
+    if (contents.length === 0)
+        throw new Error("AI request must contain user or assistant input");
+    const config = {
+        responseModalities: responseModalities(request),
+        ...(systemInstruction === undefined ? {} : { systemInstruction }),
+        ...(request.maxOutputTokens === undefined ? {} : { maxOutputTokens: request.maxOutputTokens }),
+        ...(request.outputSchema === undefined
+            ? {}
+            : {
+                responseMimeType: "application/json",
+                responseJsonSchema: toOutputSchema(request.outputSchema),
+            }),
+        ...(request.webSearch === true ? { tools: [{ googleSearch: {} }] } : {}),
+        ...(request.signal === undefined ? {} : { abortSignal: request.signal }),
+    };
+    return {
+        model: "",
+        contents,
+        config,
+    };
+};
+const responseOutput = (response) => {
+    const candidate = response.candidates?.[0];
+    if (candidate === undefined)
+        throw new Error("Google AI returned no output");
+    const parts = candidate.content?.parts ?? [];
+    if (parts.length === 0) {
+        const finishReason = candidate.finishReason;
+        if (finishReason === undefined || String(finishReason) === "STOP") {
+            return [];
+        }
+        throw new Error(`Google AI returned no output (${String(finishReason)})`);
+    }
+    return parts.flatMap((part) => {
+        if (part.thought === true)
+            return [];
+        if (typeof part.text === "string")
+            return [{ type: "text", text: part.text }];
+        if (part.inlineData?.data === undefined || part.inlineData.mimeType === undefined) {
+            throw new Error("Google AI returned an unsupported output part");
+        }
+        const type = mediaType(part.inlineData.mimeType);
+        const name = part.inlineData.displayName;
+        return [
+            name === undefined
+                ? {
+                    type,
+                    mimeType: part.inlineData.mimeType,
+                    data: part.inlineData.data,
+                }
+                : {
+                    type,
+                    mimeType: part.inlineData.mimeType,
+                    data: part.inlineData.data,
+                    name,
+                },
+        ];
+    });
+};
+const responseUsage = (response) => {
+    const usage = response.usageMetadata;
+    if (!usage)
+        return undefined;
+    return {
+        inputTokens: usage.promptTokenCount ?? 0,
+        outputTokens: usage.candidatesTokenCount ?? 0,
+        totalTokens: usage.totalTokenCount ?? 0,
+    };
+};
+const generateGoogle = async (request, config = {}) => {
+    const timeoutMs = request.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+        throw new Error("generation timeout must be positive");
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const onAbort = () => controller.abort();
+    request.signal?.addEventListener("abort", onAbort, { once: true });
+    const effectiveRequest = { ...request, signal: controller.signal };
+    try {
+        const requestConfig = toRequestConfig(effectiveRequest);
+        const result = await (0, retryOnError_1.retryOnError)(`generation:${request.ident ?? "unknown"}`, async () => {
+            const combinations = await getCombinations(request.model, request.prefer, request.output, controller.signal, config);
+            if (combinations.length === 0)
+                throw new Error("No available model for this request");
+            let lastFailure;
+            for (const [key, ai, selectedModel] of combinations) {
+                if (!(0, apikey_1.getAvailableCombinations)(`gemini-${selectedModel}`, false).some((entry) => entry.key === key)) {
+                    continue;
+                }
+                // Reactive per-model backoff: a 429 skips the model until its window
+                // elapses while every other model keeps serving.
+                if ((0, quota_1.isModelBackedOff)(selectedModel)) {
+                    (0, log_1.debug)("skipping rate-limited model", {
+                        model: selectedModel,
+                        remainingMs: (0, quota_1.modelBackoffRemainingMs)(selectedModel),
+                    });
+                    continue;
+                }
+                const selectedRequest = {
+                    ...requestConfig,
+                    model: selectedModel,
+                };
+                (0, log_1.info)("generation request", { model: selectedModel, ident: request.ident });
+                try {
+                    // oxlint-disable-next-line no-await-in-loop -- model fallback is sequential by design
+                    const response = await awaitWithSignal(ai.models.generateContent(selectedRequest), controller.signal);
+                    const usage = responseUsage(response);
+                    const result = {
+                        output: responseOutput(response),
+                        model: response.modelVersion || selectedModel,
+                        generatedAt: config.dependencies?.now?.() ?? Date.now(),
+                        ...(usage === undefined ? {} : { usage }),
+                    };
+                    (0, log_1.debug)("generation completed", request.ident);
+                    return result;
+                }
+                catch (error) {
+                    if (controller.signal.aborted)
+                        throw createAbortError();
+                    const status = error.status;
+                    const message = error instanceof Error ? error.message : String(error);
+                    const rateLimited = status === 429 || (0, retryOnError_1.isOverloadedApiKeyError)(error);
+                    const unavailableModel = status === 404 && message.includes(selectedModel);
+                    // Fallback only; per-model backoff below is keyed by rate limiting.
+                    if (rateLimited || unavailableModel) {
+                        (0, log_1.warn)("generation attempt failed; trying next available combination", {
+                            model: selectedModel,
+                            status,
+                        });
+                        (0, apikey_1.blockKeyService)(key, `gemini-${selectedModel}`);
+                        if (rateLimited) {
+                            (0, quota_1.recordModelRateLimit)(selectedModel, {
+                                cause: error,
+                                nowMs: config.dependencies?.now?.(),
+                            });
+                        }
+                        lastFailure = error;
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+            throw lastFailure ?? new Error("No available model for this request");
+        }, 1, 5000, undefined, controller.signal);
+        return result;
+    }
+    catch (error) {
+        if (controller.signal.aborted) {
+            throw request.signal?.aborted
+                ? new Error("generation aborted")
+                : new Error("generation timed out");
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+        request.signal?.removeEventListener("abort", onAbort);
+    }
+};
+exports.generateGoogle = generateGoogle;
+const listGoogleModels = async (dependencies) => getAvailableGoogleModels(dependencies);
+exports.listGoogleModels = listGoogleModels;
+/** Test seam: reset adapter clients, model cache, and per-model rate-limit backoff. */
+const resetGoogleAdapterForTests = () => {
+    genAIs = new Map();
+    geminiModelsCache.flushAll();
+    (0, quota_1.resetModelBackoff)();
+};
+exports.resetGoogleAdapterForTests = resetGoogleAdapterForTests;

package/dist/api/helpers/ai/client.d.ts

@@ -0,0 +1,11 @@
+import type { AIClient, AIClientDefaults, AIClientDependencies, AIEndpoint, AIInput, AIModel, AIModelPreference, AIPart, AIRequest, BinaryMedia, GenerateTextOptions, GenerationResult, PromptDirectOptions, PromptImageOptions } from "./types";
+export declare const createAIClient: (defaults?: AIClientDefaults) => AIClient;
+export declare const generate: (request: AIRequest) => Promise<GenerationResult>;
+export declare function generateText(prompt: string, options?: GenerateTextOptions): Promise<string>;
+export declare function generateText(options: GenerateTextOptions): Promise<string>;
+export declare const promptDirect: (options: PromptDirectOptions) => Promise<string>;
+export declare const promptImage: (options: PromptImageOptions) => Promise<string>;
+export declare const models: (options?: {
+    endpoint?: AIEndpoint;
+}) => Promise<AIModel[]>;
+export type { AIClient, AIClientDefaults, AIClientDependencies, AIEndpoint, AIInput, AIModel, AIModelPreference, AIPart, AIRequest, BinaryMedia, GenerateTextOptions, GenerationResult, PromptDirectOptions, PromptImageOptions, };

package/dist/api/helpers/ai/client.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.models = exports.promptImage = exports.promptDirect = exports.generate = exports.createAIClient = void 0;
+exports.generateText = generateText;
+const codex_1 = require("./adapters/codex");
+const google_1 = require("./adapters/google");
+const MAX_DOWNLOAD_BYTES = 25 * 1024 * 1024;
+const DOWNLOAD_TIMEOUT_MS = 30 * 1000;
+const defaultSleep = (milliseconds) => new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+});
+const createAbortError = () => {
+    const error = new Error("AI media download aborted");
+    error.name = "AbortError";
+    return error;
+};
+const awaitWithSignal = async (promise, signal) => {
+    if (signal === undefined)
+        return promise;
+    if (signal.aborted)
+        throw createAbortError();
+    const abort = new Promise((_, reject) => {
+        const onAbort = () => reject(createAbortError());
+        signal.addEventListener("abort", onAbort, { once: true });
+        void promise.then(() => signal.removeEventListener("abort", onAbort), () => signal.removeEventListener("abort", onAbort));
+    });
+    return Promise.race([promise, abort]);
+};
+const getDependencies = (defaults) => ({
+    fetch: defaults.fetch ?? defaults.dependencies?.fetch ?? globalThis.fetch,
+    sleep: defaults.sleep ?? defaults.dependencies?.sleep ?? defaultSleep,
+    now: defaults.now ?? defaults.dependencies?.now ?? (() => Date.now()),
+    createIdempotencyKey: defaults.createIdempotencyKey ?? defaults.dependencies?.createIdempotencyKey,
+});
+const mediaType = (mimeType) => {
+    const normalized = mimeType.toLowerCase();
+    if (normalized.startsWith("image/"))
+        return "image";
+    if (normalized.startsWith("audio/"))
+        return "audio";
+    if (normalized.startsWith("video/"))
+        return "video";
+    return "file";
+};
+const bytesToPart = (media) => {
+    if (media.type.trim().length === 0)
+        throw new Error("AI media MIME type is required");
+    const part = {
+        type: mediaType(media.type),
+        mimeType: media.type,
+        data: Buffer.from(media.arraybuffer).toString("base64"),
+    };
+    return media.name === undefined ? part : { ...part, name: media.name };
+};
+const downloadURL = async (url, fetch, signal, timeoutMs) => {
+    const controller = new AbortController();
+    const downloadTimeout = timeoutMs === undefined || !Number.isFinite(timeoutMs)
+        ? DOWNLOAD_TIMEOUT_MS
+        : Math.max(0, Math.min(DOWNLOAD_TIMEOUT_MS, timeoutMs));
+    const timeout = setTimeout(() => controller.abort(), downloadTimeout);
+    const onAbort = () => controller.abort();
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+        const response = await awaitWithSignal(fetch(url, { redirect: "follow", signal: controller.signal }), controller.signal);
+        if (!response.ok)
+            return undefined;
+        const contentLength = response.headers.get("content-length");
+        if (contentLength !== null && Number(contentLength) > MAX_DOWNLOAD_BYTES)
+            return undefined;
+        let type = response.headers.get("content-type") ?? "";
+        if (type.includes(";"))
+            type = type.split(";", 1)[0] ?? type;
+        if (type.length === 0 || type.includes("octet"))
+            return undefined;
+        const arraybuffer = await awaitWithSignal(response.arrayBuffer(), controller.signal);
+        if (arraybuffer.byteLength > MAX_DOWNLOAD_BYTES)
+            return undefined;
+        return { type, arraybuffer };
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
+        return undefined;
+    }
+    finally {
+        clearTimeout(timeout);
+        signal?.removeEventListener("abort", onAbort);
+    }
+};
+const downloadURLs = async (urls, fetch, signal, timeoutMs) => {
+    if (urls === undefined || urls.length === 0)
+        return [];
+    const images = await Promise.all(urls.map((url) => downloadURL(url, fetch, signal, timeoutMs)));
+    if (images.some((image) => image === undefined))
+        throw new Error("image not downloaded correctly");
+    return images.filter((image) => image !== undefined);
+};
+const textInput = (prompt, images) => ({
+    role: "user",
+    content: [{ type: "text", text: prompt }, ...images.map(bytesToPart)],
+});
+const textOutput = (output) => output.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("");
+const mergeRequest = (defaults, request) => ({
+    ...request,
+    instructions: request.instructions ?? defaults.instructions,
+    output: request.output ?? defaults.output,
+    endpoint: request.endpoint ?? defaults.endpoint,
+    model: request.model ?? defaults.model,
+    prefer: request.prefer ?? defaults.prefer,
+    reasoningEffort: request.reasoningEffort ?? defaults.reasoningEffort,
+    maxOutputTokens: request.maxOutputTokens ?? defaults.maxOutputTokens,
+    outputSchema: request.outputSchema ?? defaults.outputSchema,
+    webSearch: request.webSearch ?? defaults.webSearch,
+    onGenerated: request.onGenerated ?? defaults.onGenerated,
+    signal: request.signal ?? defaults.signal,
+    timeoutMs: request.timeoutMs ?? defaults.timeoutMs,
+});
+const requestInput = async (options, dependencies, signal, timeoutMs) => {
+    const images = options.images ?? [];
+    const downloaded = await downloadURLs(options.urls, dependencies.fetch ?? globalThis.fetch, signal, timeoutMs);
+    if (options.input !== undefined) {
+        if (options.prompt !== undefined || images.length > 0 || downloaded.length > 0) {
+            throw new Error("AI text options cannot combine input with prompt or media convenience fields");
+        }
+        return options.input;
+    }
+    if (options.prompt === undefined)
+        throw new Error("AI text prompt or multimodal input is required");
+    return [textInput(options.prompt, [...images, ...downloaded])];
+};
+const createAIClient = (defaults = {}) => {
+    const dependencies = getDependencies(defaults);
+    const generate = async (request) => {
+        const merged = mergeRequest(defaults, request);
+        const result = merged.endpoint === undefined
+            ? await (0, google_1.generateGoogle)(merged, { dependencies })
+            : await (0, codex_1.generateCodex)(merged, {
+                endpoint: merged.endpoint,
+                dependencies,
+                timeoutMs: defaults.timeoutMs,
+                pollIntervalMs: defaults.pollIntervalMs,
+                maxPollIntervalMs: defaults.maxPollIntervalMs,
+            });
+        merged.onGenerated?.({ model: result.model, generatedAt: result.generatedAt });
+        return result;
+    };
+    async function generateText(promptOrOptions, options) {
+        const textOptions = typeof promptOrOptions === "string"
+            ? { ...options, prompt: promptOrOptions }
+            : promptOrOptions;
+        const { prompt: _prompt, input: _input, images: _images, urls: _urls, ...requestOptions } = textOptions;
+        const input = await requestInput(textOptions, dependencies, textOptions.signal ?? defaults.signal, textOptions.timeoutMs ?? defaults.timeoutMs);
+        const result = await generate({
+            ...requestOptions,
+            input,
+            output: requestOptions.output ?? ["text"],
+        });
+        return textOutput(result.output);
+    }
+    const promptDirect = async (options) => {
+        const { prompt, images = [], ...requestOptions } = options;
+        return generateText({ ...requestOptions, prompt, images });
+    };
+    const promptImage = async (options) => {
+        const { prompt, urls, images = [], ...requestOptions } = options;
+        const downloaded = await downloadURLs(urls, dependencies.fetch ?? globalThis.fetch, requestOptions.signal ?? defaults.signal, requestOptions.timeoutMs ?? defaults.timeoutMs);
+        return promptDirect({ ...requestOptions, prompt, images: [...images, ...downloaded] });
+    };
+    const models = async (options) => {
+        const endpoint = options?.endpoint ?? defaults.endpoint;
+        return endpoint === undefined
+            ? (0, google_1.listGoogleModels)(dependencies)
+            : (0, codex_1.listCodexModels)(endpoint, dependencies);
+    };
+    return { generate, generateText, promptDirect, promptImage, models };
+};
+exports.createAIClient = createAIClient;
+const defaultClient = (0, exports.createAIClient)();
+const generate = (request) => defaultClient.generate(request);
+exports.generate = generate;
+function generateText(promptOrOptions, options) {
+    return typeof promptOrOptions === "string"
+        ? defaultClient.generateText(promptOrOptions, options)
+        : defaultClient.generateText(promptOrOptions);
+}
+const promptDirect = (options) => defaultClient.promptDirect(options);
+exports.promptDirect = promptDirect;
+const promptImage = (options) => defaultClient.promptImage(options);
+exports.promptImage = promptImage;
+const models = (options) => defaultClient.models(options);
+exports.models = models;

package/dist/api/helpers/ai/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./client";
+export * from "./quota";
+export type * from "./types";

package/dist/api/helpers/ai/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./quota"), exports);