@node-llm/core 0.2.2 → 0.4.0

package/dist/providers/gemini/Capabilities.js

@@ -0,0 +1,148 @@
+export class Capabilities {
+    static getContextWindow(modelId) {
+        const id = this.normalizeModelId(modelId);
+        if (id.match(/gemini-2\.5-pro-exp-03-25|gemini-2\.0-flash|gemini-2\.0-flash-lite|gemini-1\.5-flash|gemini-1\.5-flash-8b/)) {
+            return 1_048_576;
+        }
+        if (id.match(/gemini-1\.5-pro/)) {
+            return 2_097_152;
+        }
+        if (id.match(/gemini-embedding-exp/)) {
+            return 8_192;
+        }
+        if (id.match(/text-embedding-004|embedding-001/)) {
+            return 2_048;
+        }
+        if (id.match(/aqa/)) {
+            return 7_168;
+        }
+        return 32_768;
+    }
+    static getMaxOutputTokens(modelId) {
+        const id = this.normalizeModelId(modelId);
+        if (id.match(/gemini-2\.5-pro-exp-03-25/)) {
+            return 64_000;
+        }
+        if (id.match(/gemini-2\.0-flash|gemini-2\.0-flash-lite|gemini-1\.5-flash|gemini-1\.5-flash-8b|gemini-1\.5-pro/)) {
+            return 8_192;
+        }
+        if (id.match(/text-embedding-004|embedding-001/)) {
+            return 768;
+        }
+        if (id.match(/imagen-3/)) {
+            return 4;
+        }
+        return 4_096;
+    }
+    static supportsVision(modelId) {
+        const id = this.normalizeModelId(modelId);
+        if (id.match(/text-embedding|embedding-001|aqa/)) {
+            return false;
+        }
+        return !!id.match(/gemini|flash|pro|imagen/);
+    }
+    static supportsTools(modelId) {
+        const id = this.normalizeModelId(modelId);
+        if (id.match(/text-embedding|embedding-001|aqa|flash-lite|imagen|gemini-2\.0-flash-lite/)) {
+            return false;
+        }
+        return !!id.match(/gemini|pro|flash/);
+    }
+    static supportsStructuredOutput(modelId) {
+        // Explicitly disabled until implementation is validated
+        return false;
+    }
+    static supportsJsonMode(modelId) {
+        return this.supportsStructuredOutput(modelId);
+    }
+    static supportsEmbeddings(modelId) {
+        const id = this.normalizeModelId(modelId);
+        return !!id.match(/text-embedding|embedding|gemini-embedding/);
+    }
+    static supportsImageGeneration(modelId) {
+        const id = this.normalizeModelId(modelId);
+        return !!id.match(/imagen/);
+    }
+    static supportsTranscription(modelId) {
+        const id = this.normalizeModelId(modelId);
+        return !!id.match(/gemini|flash|pro/);
+    }
+    static supportsModeration(modelId) {
+        return false;
+    }
+    static normalizeTemperature(temperature, _modelId) {
+        return temperature;
+    }
+    static getFamily(modelId) {
+        const id = this.normalizeModelId(modelId);
+        if (id.startsWith("gemini-1.5-pro"))
+            return "gemini-1.5-pro";
+        if (id.startsWith("gemini-1.5-flash"))
+            return "gemini-1.5-flash";
+        if (id.startsWith("gemini-2.0-flash"))
+            return "gemini-2.0-flash";
+        if (id.startsWith("gemini-2.0-flash-lite"))
+            return "gemini-2.0-flash-lite";
+        if (id.startsWith("text-embedding"))
+            return "text-embedding";
+        if (id.startsWith("imagen"))
+            return "imagen";
+        return "other";
+    }
+    static getModalities(modelId) {
+        const input = ["text"];
+        const output = ["text"];
+        const id = this.normalizeModelId(modelId);
+        if (this.supportsVision(id))
+            input.push("image", "video", "audio", "pdf");
+        if (this.supportsImageGeneration(id))
+            output.push("image");
+        if (this.supportsEmbeddings(id))
+            output.push("embeddings");
+        return { input, output };
+    }
+    static getCapabilities(modelId) {
+        const caps = ["streaming"];
+        const id = this.normalizeModelId(modelId);
+        if (this.supportsTools(id))
+            caps.push("function_calling");
+        if (this.supportsStructuredOutput(id))
+            caps.push("structured_output");
+        if (this.supportsEmbeddings(id))
+            caps.push("embeddings");
+        if (this.supportsImageGeneration(id))
+            caps.push("image_generation");
+        return caps;
+    }
+    static getPricing(modelId) {
+        const id = this.normalizeModelId(modelId);
+        let input = 0;
+        let output = 0;
+        if (id.match(/gemini-1\.5-flash/)) {
+            input = 0.075;
+            output = 0.3;
+        }
+        else if (id.match(/gemini-1\.5-pro/)) {
+            input = 3.5;
+            output = 10.5;
+        }
+        else if (id.match(/gemini-2\.0-flash/)) {
+            input = 0.10;
+            output = 0.40;
+        }
+        return {
+            text_tokens: {
+                standard: {
+                    input_per_million: input,
+                    output_per_million: output
+                }
+            }
+        };
+    }
+    static formatDisplayName(modelId) {
+        return modelId.replace("models/", "").replace(/-/g, " ").replace(/\b\w/g, l => l.toUpperCase());
+    }
+    static normalizeModelId(modelId) {
+        return modelId.replace("models/", "");
+    }
+}

package/dist/providers/gemini/Chat.d.ts

@@ -0,0 +1,8 @@
+import { ChatRequest, ChatResponse } from "../Provider.js";
+export declare class GeminiChat {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    execute(request: ChatRequest): Promise<ChatResponse>;
+}
+//# sourceMappingURL=Chat.d.ts.map

package/dist/providers/gemini/Chat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Chat.d.ts","sourceRoot":"","sources":["../../../src/providers/gemini/Chat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAM3D,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,OAAO;IAAU,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAxC,OAAO,EAAE,MAAM,EAAmB,MAAM,EAAE,MAAM;IAEvE,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;CAqE3D"}

package/dist/providers/gemini/Chat.js

@@ -0,0 +1,69 @@
+import { Capabilities } from "./Capabilities.js";
+import { handleGeminiError } from "./Errors.js";
+import { GeminiChatUtils } from "./ChatUtils.js";
+export class GeminiChat {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async execute(request) {
+        const temperature = Capabilities.normalizeTemperature(request.temperature, request.model);
+        const url = `${this.baseUrl}/models/${request.model}:generateContent?key=${this.apiKey}`;
+        const { contents, systemInstructionParts } = await GeminiChatUtils.convertMessages(request.messages);
+        const payload = {
+            contents,
+            generationConfig: {
+                temperature: temperature ?? undefined,
+                maxOutputTokens: request.max_tokens,
+            },
+        };
+        if (systemInstructionParts.length > 0) {
+            payload.systemInstruction = { parts: systemInstructionParts };
+        }
+        if (request.tools && request.tools.length > 0) {
+            payload.tools = [
+                {
+                    functionDeclarations: request.tools.map((t) => ({
+                        name: t.function.name,
+                        description: t.function.description,
+                        parameters: t.function.parameters,
+                    })),
+                },
+            ];
+        }
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            await handleGeminiError(response, request.model);
+        }
+        const json = (await response.json());
+        const candidate = json.candidates?.[0];
+        const content = candidate?.content?.parts
+            ?.filter(p => p.text)
+            .map(p => p.text)
+            .join("\n") || null;
+        const tool_calls = candidate?.content?.parts
+            ?.filter((p) => p.functionCall)
+            .map((p) => ({
+            id: p.functionCall.name,
+            type: "function",
+            function: {
+                name: p.functionCall.name,
+                arguments: JSON.stringify(p.functionCall.args),
+            },
+        }));
+        const usage = json.usageMetadata ? {
+            input_tokens: json.usageMetadata.promptTokenCount,
+            output_tokens: json.usageMetadata.candidatesTokenCount,
+            total_tokens: json.usageMetadata.totalTokenCount,
+        } : undefined;
+        return { content, tool_calls, usage };
+    }
+}

package/dist/providers/gemini/ChatUtils.d.ts

@@ -0,0 +1,9 @@
+import { Message } from "../../chat/Message.js";
+import { GeminiContent, GeminiPart } from "./types.js";
+export declare class GeminiChatUtils {
+    static convertMessages(messages: Message[]): Promise<{
+        contents: GeminiContent[];
+        systemInstructionParts: GeminiPart[];
+    }>;
+}
+//# sourceMappingURL=ChatUtils.d.ts.map

package/dist/providers/gemini/ChatUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatUtils.d.ts","sourceRoot":"","sources":["../../../src/providers/gemini/ChatUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGvD,qBAAa,eAAe;WACb,eAAe,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,aAAa,EAAE,CAAC;QAAC,sBAAsB,EAAE,UAAU,EAAE,CAAA;KAAE,CAAC;CAgFhI"}

package/dist/providers/gemini/ChatUtils.js

@@ -0,0 +1,83 @@
+import { BinaryUtils } from "../../utils/Binary.js";
+export class GeminiChatUtils {
+    static async convertMessages(messages) {
+        const contents = [];
+        const systemInstructionParts = [];
+        for (const msg of messages) {
+            if (msg.role === "system") {
+                if (typeof msg.content === "string") {
+                    systemInstructionParts.push({ text: msg.content });
+                }
+            }
+            else if (msg.role === "user" || msg.role === "assistant" || msg.role === "tool") {
+                const parts = [];
+                if (msg.role === "tool") {
+                    parts.push({
+                        functionResponse: {
+                            name: msg.tool_call_id || "unknown",
+                            response: { result: msg.content },
+                        },
+                    });
+                    contents.push({ role: "user", parts });
+                }
+                else {
+                    const role = msg.role === "assistant" ? "model" : "user";
+                    if (typeof msg.content === "string" && msg.content) {
+                        parts.push({ text: msg.content });
+                    }
+                    else if (Array.isArray(msg.content)) {
+                        for (const part of msg.content) {
+                            if (part.type === "text") {
+                                parts.push({ text: part.text });
+                            }
+                            else if (part.type === "image_url") {
+                                const binary = await BinaryUtils.toBase64(part.image_url.url);
+                                if (binary) {
+                                    parts.push({
+                                        inlineData: {
+                                            mimeType: binary.mimeType,
+                                            data: binary.data,
+                                        },
+                                    });
+                                }
+                            }
+                            else if (part.type === "input_audio") {
+                                parts.push({
+                                    inlineData: {
+                                        mimeType: `audio/${part.input_audio.format}`,
+                                        data: part.input_audio.data,
+                                    },
+                                });
+                            }
+                            else if (part.type === "video_url") {
+                                const binary = await BinaryUtils.toBase64(part.video_url.url);
+                                if (binary) {
+                                    parts.push({
+                                        inlineData: {
+                                            mimeType: binary.mimeType,
+                                            data: binary.data,
+                                        },
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    if (msg.role === "assistant" && msg.tool_calls) {
+                        for (const call of msg.tool_calls) {
+                            parts.push({
+                                functionCall: {
+                                    name: call.function.name,
+                                    args: JSON.parse(call.function.arguments),
+                                },
+                            });
+                        }
+                    }
+                    if (parts.length > 0) {
+                        contents.push({ role, parts });
+                    }
+                }
+            }
+        }
+        return { contents, systemInstructionParts };
+    }
+}

package/dist/providers/gemini/Embeddings.d.ts

@@ -0,0 +1,8 @@
+import { EmbeddingRequest, EmbeddingResponse } from "../Embedding.js";
+export declare class GeminiEmbeddings {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    execute(request: EmbeddingRequest): Promise<EmbeddingResponse>;
+}
+//# sourceMappingURL=Embeddings.d.ts.map

package/dist/providers/gemini/Embeddings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Embeddings.d.ts","sourceRoot":"","sources":["../../../src/providers/gemini/Embeddings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAItE,qBAAa,gBAAgB;IACf,OAAO,CAAC,QAAQ,CAAC,OAAO;IAAU,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAxC,OAAO,EAAE,MAAM,EAAmB,MAAM,EAAE,MAAM;IAEvE,OAAO,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAwCrE"}

package/dist/providers/gemini/Embeddings.js

@@ -0,0 +1,44 @@
+import { handleGeminiError } from "./Errors.js";
+export class GeminiEmbeddings {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async execute(request) {
+        const modelId = request.model || "text-embedding-004";
+        const url = `${this.baseUrl}/models/${modelId}:batchEmbedContents?key=${this.apiKey}`;
+        const inputs = Array.isArray(request.input) ? request.input : [request.input];
+        const payload = {
+            requests: inputs.map(text => {
+                const item = {
+                    model: `models/${modelId}`,
+                    content: {
+                        parts: [{ text: String(text) }]
+                    }
+                };
+                if (request.dimensions) {
+                    item.outputDimensionality = request.dimensions;
+                }
+                return item;
+            })
+        };
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload)
+        });
+        if (!response.ok) {
+            await handleGeminiError(response, modelId);
+        }
+        const json = (await response.json());
+        const vectors = json.embeddings?.map(e => e.values) || [];
+        return {
+            model: modelId,
+            vectors: vectors,
+            input_tokens: 0,
+            dimensions: vectors[0]?.length || 0
+        };
+    }
+}

package/dist/providers/gemini/Errors.d.ts

@@ -0,0 +1,2 @@
+export declare function handleGeminiError(response: Response, model?: string): Promise<never>;
+//# sourceMappingURL=Errors.d.ts.map

package/dist/providers/gemini/Errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.d.ts","sourceRoot":"","sources":["../../../src/providers/gemini/Errors.ts"],"names":[],"mappings":"AASA,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAuC1F"}

package/dist/providers/gemini/Errors.js

@@ -0,0 +1,34 @@
+import { BadRequestError, AuthenticationError, RateLimitError, ServerError, ServiceUnavailableError, APIError } from "../../errors/index.js";
+export async function handleGeminiError(response, model) {
+    const status = response.status;
+    let body;
+    let message = `Gemini error (${status})`;
+    try {
+        body = await response.json();
+        if (body?.error?.message) {
+            message = body.error.message;
+        }
+    }
+    catch {
+        // If not JSON, use the status text
+        body = await response.text().catch(() => "Unknown error");
+        message = `Gemini error (${status}): ${body}`;
+    }
+    const provider = "gemini";
+    if (status === 400) {
+        throw new BadRequestError(message, body, provider, model);
+    }
+    if (status === 401 || status === 403) {
+        throw new AuthenticationError(message, status, body, provider);
+    }
+    if (status === 429) {
+        throw new RateLimitError(message, body, provider, model);
+    }
+    if (status === 502 || status === 503 || status === 504) {
+        throw new ServiceUnavailableError(message, status, body, provider, model);
+    }
+    if (status >= 500) {
+        throw new ServerError(message, status, body, provider, model);
+    }
+    throw new APIError(message, status, body, provider, model);
+}

package/dist/providers/gemini/GeminiProvider.d.ts

@@ -0,0 +1,34 @@
+import { Provider, ChatRequest, ChatResponse, ModelInfo, ChatChunk, ImageRequest, ImageResponse, TranscriptionRequest, TranscriptionResponse } from "../Provider.js";
+import { EmbeddingRequest, EmbeddingResponse } from "../Embedding.js";
+export interface GeminiProviderOptions {
+    apiKey: string;
+    baseUrl?: string;
+}
+export declare class GeminiProvider implements Provider {
+    private readonly options;
+    private readonly baseUrl;
+    private readonly chatHandler;
+    private readonly streamingHandler;
+    private readonly modelsHandler;
+    private readonly imageHandler;
+    private readonly embeddingHandler;
+    private readonly transcriptionHandler;
+    capabilities: {
+        supportsVision: (model: string) => boolean;
+        supportsTools: (model: string) => boolean;
+        supportsStructuredOutput: (model: string) => boolean;
+        supportsEmbeddings: (model: string) => boolean;
+        supportsImageGeneration: (model: string) => boolean;
+        supportsTranscription: (model: string) => boolean;
+        supportsModeration: (model: string) => boolean;
+        getContextWindow: (model: string) => number | null;
+    };
+    constructor(options: GeminiProviderOptions);
+    chat(request: ChatRequest): Promise<ChatResponse>;
+    stream(request: ChatRequest): AsyncGenerator<ChatChunk>;
+    listModels(): Promise<ModelInfo[]>;
+    paint(request: ImageRequest): Promise<ImageResponse>;
+    embed(request: EmbeddingRequest): Promise<EmbeddingResponse>;
+    transcribe(request: TranscriptionRequest): Promise<TranscriptionResponse>;
+}
+//# sourceMappingURL=GeminiProvider.d.ts.map

package/dist/providers/gemini/GeminiProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeminiProvider.d.ts","sourceRoot":"","sources":["../../../src/providers/gemini/GeminiProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAQrK,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEtE,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,cAAe,YAAW,QAAQ;IAoBjC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAnBpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAa;IACzC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAkB;IACnD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAe;IAC7C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAC3C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IACpD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAsB;IAEpD,YAAY;gCACO,MAAM;+BACP,MAAM;0CACK,MAAM;oCACZ,MAAM;yCACD,MAAM;uCACR,MAAM;oCACT,MAAM;kCACR,MAAM;MAChC;gBAE2B,OAAO,EAAE,qBAAqB;IAUrD,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAIhD,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc,CAAC,SAAS,CAAC;IAIxD,UAAU,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAIlC,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IAIpD,KAAK,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAI5D,UAAU,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAGhF"}

package/dist/providers/gemini/GeminiProvider.js

@@ -0,0 +1,55 @@
+import { Capabilities } from "./Capabilities.js";
+import { GeminiChat } from "./Chat.js";
+import { GeminiStreaming } from "./Streaming.js";
+import { GeminiModels } from "./Models.js";
+import { GeminiImage } from "./Image.js";
+import { GeminiEmbeddings } from "./Embeddings.js";
+import { GeminiTranscription } from "./Transcription.js";
+export class GeminiProvider {
+    options;
+    baseUrl;
+    chatHandler;
+    streamingHandler;
+    modelsHandler;
+    imageHandler;
+    embeddingHandler;
+    transcriptionHandler;
+    capabilities = {
+        supportsVision: (model) => Capabilities.supportsVision(model),
+        supportsTools: (model) => Capabilities.supportsTools(model),
+        supportsStructuredOutput: (model) => Capabilities.supportsStructuredOutput(model),
+        supportsEmbeddings: (model) => Capabilities.supportsEmbeddings(model),
+        supportsImageGeneration: (model) => Capabilities.supportsImageGeneration(model),
+        supportsTranscription: (model) => Capabilities.supportsTranscription(model),
+        supportsModeration: (model) => Capabilities.supportsModeration(model),
+        getContextWindow: (model) => Capabilities.getContextWindow(model),
+    };
+    constructor(options) {
+        this.options = options;
+        this.baseUrl = options.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta";
+        this.chatHandler = new GeminiChat(this.baseUrl, options.apiKey);
+        this.streamingHandler = new GeminiStreaming(this.baseUrl, options.apiKey);
+        this.modelsHandler = new GeminiModels(this.baseUrl, options.apiKey);
+        this.imageHandler = new GeminiImage(this.baseUrl, options.apiKey);
+        this.embeddingHandler = new GeminiEmbeddings(this.baseUrl, options.apiKey);
+        this.transcriptionHandler = new GeminiTranscription(this.baseUrl, options.apiKey);
+    }
+    async chat(request) {
+        return this.chatHandler.execute(request);
+    }
+    async *stream(request) {
+        yield* this.streamingHandler.execute(request);
+    }
+    async listModels() {
+        return this.modelsHandler.execute();
+    }
+    async paint(request) {
+        return this.imageHandler.execute(request);
+    }
+    async embed(request) {
+        return this.embeddingHandler.execute(request);
+    }
+    async transcribe(request) {
+        return this.transcriptionHandler.execute(request);
+    }
+}

package/dist/providers/gemini/Image.d.ts

@@ -0,0 +1,8 @@
+import { ImageRequest, ImageResponse } from "../Provider.js";
+export declare class GeminiImage {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    execute(request: ImageRequest): Promise<ImageResponse>;
+}
+//# sourceMappingURL=Image.d.ts.map

package/dist/providers/gemini/Image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Image.d.ts","sourceRoot":"","sources":["../../../src/providers/gemini/Image.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAG7D,qBAAa,WAAW;IACV,OAAO,CAAC,QAAQ,CAAC,OAAO;IAAU,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAxC,OAAO,EAAE,MAAM,EAAmB,MAAM,EAAE,MAAM;IAEvE,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;CA8C7D"}

package/dist/providers/gemini/Image.js

@@ -0,0 +1,47 @@
+import { handleGeminiError } from "./Errors.js";
+export class GeminiImage {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async execute(request) {
+        const modelId = request.model || "imagen-4.0-generate-001";
+        const url = `${this.baseUrl}/models/${modelId}:predict?key=${this.apiKey}`;
+        if (request.size) {
+            console.log(`[Gemini] Ignoring size ${request.size}. Gemini does not support image size customization.`);
+        }
+        const body = {
+            instances: [
+                {
+                    prompt: request.prompt,
+                },
+            ],
+            parameters: {
+                sampleCount: 1,
+            },
+        };
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            await handleGeminiError(response, modelId);
+        }
+        const json = await response.json();
+        const imageData = json.predictions?.[0];
+        if (!imageData || !imageData.bytesBase64Encoded) {
+            throw new Error("Unexpected response format from Gemini image generation API");
+        }
+        const mimeType = imageData.mimeType || "image/png";
+        const base64Data = imageData.bytesBase64Encoded;
+        return {
+            data: base64Data,
+            mime_type: mimeType,
+        };
+    }
+}

package/dist/providers/gemini/Models.d.ts

@@ -0,0 +1,8 @@
+import { ModelInfo } from "../Provider.js";
+export declare class GeminiModels {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    execute(): Promise<ModelInfo[]>;
+}
+//# sourceMappingURL=Models.d.ts.map

package/dist/providers/gemini/Models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Models.d.ts","sourceRoot":"","sources":["../../../src/providers/gemini/Models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAI3C,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,OAAO;IAAU,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAxC,OAAO,EAAE,MAAM,EAAmB,MAAM,EAAE,MAAM;IAEvE,OAAO,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;CAgCtC"}

package/dist/providers/gemini/Models.js

@@ -0,0 +1,38 @@
+import { Capabilities } from "./Capabilities.js";
+export class GeminiModels {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async execute() {
+        const url = `${this.baseUrl}/models?key=${this.apiKey}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Gemini error (${response.status}): ${errorText}`);
+        }
+        const json = (await response.json());
+        return json.models
+            .filter(m => m.supportedGenerationMethods.includes("generateContent"))
+            .map((model) => {
+            const id = model.name.replace("models/", "");
+            return {
+                id: id,
+                name: model.displayName || Capabilities.formatDisplayName(id),
+                provider: "gemini",
+                family: Capabilities.getFamily(id),
+                context_window: model.inputTokenLimit || Capabilities.getContextWindow(id),
+                max_output_tokens: model.outputTokenLimit || Capabilities.getMaxOutputTokens(id),
+                modalities: Capabilities.getModalities(id),
+                capabilities: Capabilities.getCapabilities(id),
+                pricing: Capabilities.getPricing(id),
+                metadata: {
+                    description: model.description,
+                    version: model.version,
+                },
+            };
+        });
+    }
+}

package/dist/providers/gemini/Streaming.d.ts

@@ -0,0 +1,8 @@
+import { ChatRequest, ChatChunk } from "../Provider.js";
+export declare class GeminiStreaming {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    execute(request: ChatRequest): AsyncGenerator<ChatChunk>;
+}
+//# sourceMappingURL=Streaming.d.ts.map

package/dist/providers/gemini/Streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Streaming.d.ts","sourceRoot":"","sources":["../../../src/providers/gemini/Streaming.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAMxD,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,OAAO;IAAU,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAxC,OAAO,EAAE,MAAM,EAAmB,MAAM,EAAE,MAAM;IAEtE,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc,CAAC,SAAS,CAAC;CAoEhE"}