@node-llm/core 0.3.0 → 0.4.1

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"}

package/dist/providers/gemini/Streaming.js

@@ -0,0 +1,70 @@
+import { Capabilities } from "./Capabilities.js";
+import { handleGeminiError } from "./Errors.js";
+import { GeminiChatUtils } from "./ChatUtils.js";
+export class GeminiStreaming {
+    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}:streamGenerateContent?alt=sse&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 };
+        }
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            await handleGeminiError(response, request.model);
+        }
+        if (!response.body) {
+            throw new Error("No response body for streaming");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let lineEnd;
+            while ((lineEnd = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.substring(0, lineEnd).trim();
+                buffer = buffer.substring(lineEnd + 1);
+                if (line.startsWith("data: ")) {
+                    const data = line.substring(6).trim();
+                    if (!data)
+                        continue;
+                    try {
+                        const json = JSON.parse(data);
+                        const parts = json.candidates?.[0]?.content?.parts || [];
+                        for (const part of parts) {
+                            if (part.text) {
+                                yield { content: part.text };
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // Ignore parse errors
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { TranscriptionRequest, TranscriptionResponse } from "../Provider.js";
+export declare class GeminiTranscription {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private static readonly DEFAULT_PROMPT;
+    constructor(baseUrl: string, apiKey: string);
+    execute(request: TranscriptionRequest): Promise<TranscriptionResponse>;
+}
+//# sourceMappingURL=Transcription.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Transcription.d.ts","sourceRoot":"","sources":["../../../src/providers/gemini/Transcription.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAK7E,qBAAa,mBAAmB;IAGlB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAAU,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFrE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAA8E;gBAEvF,OAAO,EAAE,MAAM,EAAmB,MAAM,EAAE,MAAM;IAEvE,OAAO,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;CA2D7E"}

package/dist/providers/gemini/Transcription.js

@@ -0,0 +1,63 @@
+import { handleGeminiError } from "./Errors.js";
+import { BinaryUtils } from "../../utils/Binary.js";
+export class GeminiTranscription {
+    baseUrl;
+    apiKey;
+    static DEFAULT_PROMPT = "Transcribe the provided audio and respond with only the transcript text.";
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async execute(request) {
+        const model = request.model || "gemini-2.0-flash";
+        const url = `${this.baseUrl}/models/${model}:generateContent?key=${this.apiKey}`;
+        const result = await BinaryUtils.toBase64(request.file);
+        if (!result) {
+            throw new Error(`Failed to load audio file: ${request.file}`);
+        }
+        const { data: base64Data, mimeType } = result;
+        let prompt = GeminiTranscription.DEFAULT_PROMPT;
+        if (request.language) {
+            prompt += ` Respond in the ${request.language} language.`;
+        }
+        if (request.prompt) {
+            prompt += ` ${request.prompt}`;
+        }
+        const payload = {
+            contents: [
+                {
+                    role: "user",
+                    parts: [
+                        { text: prompt },
+                        {
+                            inlineData: {
+                                mimeType,
+                                data: base64Data,
+                            },
+                        },
+                    ],
+                },
+            ],
+            generationConfig: {
+                responseMimeType: "text/plain",
+            },
+        };
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            await handleGeminiError(response, model);
+        }
+        const json = (await response.json());
+        const text = json.candidates?.[0]?.content?.parts?.map(p => p.text).join("") || "";
+        return {
+            text,
+            model,
+            segments: [], // Gemini's generateContent doesn't return segments by default
+        };
+    }
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Idempotent registration of the Gemini provider.
+ * Automatically called by LLM.configure({ provider: 'gemini' })
+ */
+export declare function registerGeminiProvider(): void;
+/**
+ * Alias for registerGeminiProvider for internal use.
+ */
+export declare const ensureGeminiRegistered: typeof registerGeminiProvider;
+export * from "./GeminiProvider.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/gemini/index.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,wBAAgB,sBAAsB,SAcrC;AAED;;GAEG;AACH,eAAO,MAAM,sBAAsB,+BAAyB,CAAC;AAE7D,cAAc,qBAAqB,CAAC"}

package/dist/providers/gemini/index.js

@@ -0,0 +1,24 @@
+import { providerRegistry } from "../registry.js";
+import { GeminiProvider } from "./GeminiProvider.js";
+let registered = false;
+/**
+ * Idempotent registration of the Gemini provider.
+ * Automatically called by LLM.configure({ provider: 'gemini' })
+ */
+export function registerGeminiProvider() {
+    if (registered)
+        return;
+    providerRegistry.register("gemini", () => {
+        const apiKey = process.env.GEMINI_API_KEY;
+        if (!apiKey) {
+            throw new Error("GEMINI_API_KEY is not set");
+        }
+        return new GeminiProvider({ apiKey });
+    });
+    registered = true;
+}
+/**
+ * Alias for registerGeminiProvider for internal use.
+ */
+export const ensureGeminiRegistered = registerGeminiProvider;
+export * from "./GeminiProvider.js";