@node-llm/core 1.4.1 → 1.4.3

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

@@ -0,0 +1,9 @@
+import { ModelInfo } from "../Provider.js";
+export declare class GeminiModels {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    execute(): Promise<ModelInfo[]>;
+    find(modelId: string): import("../../models/types.js").Model | undefined;
+}
+//# 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;AAK3C,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;IAkDrC,IAAI,CAAC,OAAO,EAAE,MAAM;CAGrB"}

package/dist/providers/gemini/Models.js

@@ -0,0 +1,58 @@
+import { Capabilities } from "./Capabilities.js";
+import { ModelRegistry } from "../../models/ModelRegistry.js";
+export class GeminiModels {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async execute() {
+        try {
+            const response = await fetch(`${this.baseUrl}/models?key=${this.apiKey}`, {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            if (response.ok) {
+                const { models } = await response.json();
+                return models.map(m => {
+                    const modelId = m.name.replace("models/", "");
+                    const registryModel = ModelRegistry.find(modelId, "gemini");
+                    const info = {
+                        id: modelId,
+                        name: registryModel?.name || m.displayName || modelId,
+                        provider: "gemini",
+                        family: registryModel?.family || modelId,
+                        context_window: registryModel?.context_window || Capabilities.getContextWindow(modelId),
+                        max_output_tokens: registryModel?.max_output_tokens || Capabilities.getMaxOutputTokens(modelId),
+                        modalities: registryModel?.modalities || Capabilities.getModalities(modelId),
+                        capabilities: Capabilities.getCapabilities(modelId),
+                        pricing: registryModel?.pricing || Capabilities.getPricing(modelId),
+                        metadata: {
+                            ...(registryModel?.metadata || {}),
+                            description: m.description,
+                            input_token_limit: m.inputTokenLimit,
+                            output_token_limit: m.outputTokenLimit,
+                            supported_generation_methods: m.supportedGenerationMethods
+                        }
+                    };
+                    return info;
+                });
+            }
+        }
+        catch (_error) {
+            // Fallback
+        }
+        return ModelRegistry.all()
+            .filter(m => m.provider === "gemini")
+            .map(m => ({
+            ...m,
+            capabilities: Capabilities.getCapabilities(m.id)
+        }));
+    }
+    find(modelId) {
+        return ModelRegistry.find(modelId, "gemini");
+    }
+}

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

@@ -0,0 +1,9 @@
+import { ChatRequest, ChatChunk } from "../Provider.js";
+export declare class GeminiStreaming {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    execute(request: ChatRequest, controller?: AbortController): AsyncGenerator<ChatChunk>;
+    private sanitizeSchema;
+}
+//# 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;AAOxD,qBAAa,eAAe;IACd,OAAO,CAAC,QAAQ,CAAC,OAAO;IAAU,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAxC,OAAO,EAAE,MAAM,EAAmB,MAAM,EAAE,MAAM;IAEtE,OAAO,CACZ,OAAO,EAAE,WAAW,EACpB,UAAU,CAAC,EAAE,eAAe,GAC3B,cAAc,CAAC,SAAS,CAAC;IAyI5B,OAAO,CAAC,cAAc;CAwBvB"}

package/dist/providers/gemini/Streaming.js

@@ -0,0 +1,154 @@
+import { Capabilities } from "./Capabilities.js";
+import { handleGeminiError } from "./Errors.js";
+import { GeminiChatUtils } from "./ChatUtils.js";
+import { logger } from "../../utils/logger.js";
+export class GeminiStreaming {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async *execute(request, controller) {
+        const abortController = controller || new AbortController();
+        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 generationConfig = {
+            temperature: temperature ?? undefined,
+            maxOutputTokens: request.max_tokens,
+        };
+        if (request.response_format?.type === "json_object") {
+            generationConfig.responseMimeType = "application/json";
+        }
+        else if (request.response_format?.type === "json_schema") {
+            generationConfig.responseMimeType = "application/json";
+            if (request.response_format.json_schema?.schema) {
+                generationConfig.responseSchema = this.sanitizeSchema(request.response_format.json_schema.schema);
+            }
+        }
+        const payload = {
+            contents,
+            generationConfig,
+        };
+        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,
+                    })),
+                },
+            ];
+        }
+        let done = false;
+        const toolCalls = [];
+        try {
+            logger.logRequest("Gemini", "POST", url, payload);
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(payload),
+                signal: abortController.signal,
+            });
+            if (!response.ok) {
+                await handleGeminiError(response, request.model);
+            }
+            logger.debug("Gemini streaming started", { status: response.status, statusText: response.statusText });
+            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: readerDone } = await reader.read();
+                if (readerDone) {
+                    // Yield tool calls if any were collected
+                    if (toolCalls.length > 0) {
+                        yield { content: "", tool_calls: toolCalls, done: true };
+                    }
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                let lineEnd;
+                while ((lineEnd = buffer.indexOf("\n")) !== -1) {
+                    let line = buffer.substring(0, lineEnd).trim();
+                    buffer = buffer.substring(lineEnd + 1);
+                    // Handle carriage returns
+                    if (line.endsWith('\r')) {
+                        line = line.substring(0, line.length - 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 };
+                                }
+                                // Handle function calls
+                                if (part.functionCall) {
+                                    toolCalls.push({
+                                        id: part.functionCall.name, // Gemini uses name as ID
+                                        type: "function",
+                                        function: {
+                                            name: part.functionCall.name,
+                                            arguments: JSON.stringify(part.functionCall.args || {})
+                                        }
+                                    });
+                                }
+                            }
+                        }
+                        catch (e) {
+                            // Ignore parse errors
+                        }
+                    }
+                }
+            }
+            done = true;
+        }
+        catch (e) {
+            // Graceful exit on abort
+            if (e instanceof Error && e.name === 'AbortError') {
+                return;
+            }
+            throw e;
+        }
+        finally {
+            // Cleanup: abort if user breaks early
+            if (!done) {
+                abortController.abort();
+            }
+        }
+    }
+    sanitizeSchema(schema) {
+        if (typeof schema !== "object" || schema === null)
+            return schema;
+        const sanitized = { ...schema };
+        // Remove unsupported fields
+        delete sanitized.additionalProperties;
+        delete sanitized.$schema;
+        delete sanitized.$id;
+        delete sanitized.definitions;
+        // Recursively sanitize
+        if (sanitized.properties) {
+            for (const key in sanitized.properties) {
+                sanitized.properties[key] = this.sanitizeSchema(sanitized.properties[key]);
+            }
+        }
+        if (sanitized.items) {
+            sanitized.items = this.sanitizeSchema(sanitized.items);
+        }
+        return sanitized;
+    }
+}

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;AAM7E,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;CA8D7E"}

package/dist/providers/gemini/Transcription.js

@@ -0,0 +1,66 @@
+import { handleGeminiError } from "./Errors.js";
+import { BinaryUtils } from "../../utils/Binary.js";
+import { logger } from "../../utils/logger.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",
+            },
+        };
+        logger.logRequest("Gemini", "POST", url, payload);
+        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());
+        logger.logResponse("Gemini", response.status, response.statusText, 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 NodeLLM.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":"AAMA;;;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,25 @@
+import { config } from "../../config.js";
+import { providerRegistry } from "../registry.js";
+import { GeminiProvider } from "./GeminiProvider.js";
+let registered = false;
+/**
+ * Idempotent registration of the Gemini provider.
+ * Automatically called by NodeLLM.configure({ provider: 'gemini' })
+ */
+export function registerGeminiProvider() {
+    if (registered)
+        return;
+    providerRegistry.register("gemini", () => {
+        const apiKey = config.geminiApiKey;
+        if (!apiKey) {
+            throw new Error("geminiApiKey is not set in config or GEMINI_API_KEY environment variable");
+        }
+        return new GeminiProvider({ apiKey });
+    });
+    registered = true;
+}
+/**
+ * Alias for registerGeminiProvider for internal use.
+ */
+export const ensureGeminiRegistered = registerGeminiProvider;
+export * from "./GeminiProvider.js";

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

@@ -0,0 +1,118 @@
+export interface GeminiPart {
+    text?: string;
+    inlineData?: {
+        mimeType: string;
+        data: string;
+    };
+    functionCall?: {
+        name: string;
+        args: Record<string, any>;
+    };
+    functionResponse?: {
+        name: string;
+        response: Record<string, any>;
+    };
+}
+export interface GeminiContent {
+    role?: "user" | "model";
+    parts: GeminiPart[];
+}
+export interface GeminiGenerateContentRequest {
+    contents: GeminiContent[];
+    systemInstruction?: {
+        parts: GeminiPart[];
+    };
+    tools?: {
+        functionDeclarations: Array<{
+            name: string;
+            description?: string;
+            parameters?: Record<string, any>;
+        }>;
+    }[];
+    generationConfig?: {
+        temperature?: number;
+        maxOutputTokens?: number;
+        stopSequences?: string[];
+        topP?: number;
+        topK?: number;
+        responseMimeType?: string;
+        responseSchema?: Record<string, any>;
+    };
+    safetySettings?: Array<{
+        category: string;
+        threshold: string;
+    }>;
+}
+export interface GeminiGenerateContentResponse {
+    candidates?: Array<{
+        content: GeminiContent;
+        finishReason?: string;
+        index?: number;
+        safetyRatings?: Array<{
+            category: string;
+            probability: string;
+        }>;
+    }>;
+    usageMetadata?: {
+        promptTokenCount: number;
+        candidatesTokenCount: number;
+        totalTokenCount: number;
+    };
+    modelVersion?: string;
+}
+export interface GeminiModel {
+    name: string;
+    version: string;
+    displayName: string;
+    description: string;
+    inputTokenLimit: number;
+    outputTokenLimit: number;
+    supportedGenerationMethods: string[];
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+}
+export interface GeminiListModelsResponse {
+    models: GeminiModel[];
+    nextPageToken?: string;
+}
+export interface GeminiImageRequest {
+    prompt: string;
+    numberOfImages?: number;
+    aspectRatio?: string;
+    safetySetting?: Array<{
+        category: string;
+        threshold: string;
+    }>;
+}
+export interface GeminiImageResponse {
+    images: Array<{
+        image: {
+            mimeType: string;
+            data: string;
+        };
+    }>;
+}
+export interface GeminiEmbedRequest {
+    model: string;
+    content: {
+        parts: Array<{
+            text: string;
+        }>;
+    };
+    outputDimensionality?: number;
+}
+export interface GeminiEmbedResponse {
+    embedding: {
+        values: number[];
+    };
+}
+export interface GeminiBatchEmbedRequest {
+    requests: GeminiEmbedRequest[];
+}
+export interface GeminiBatchEmbedResponse {
+    embeddings: Array<{
+        values: number[];
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/providers/gemini/types.ts"],"names":[],"mappings":"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"}

package/dist/providers/gemini/types.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/ollama/Capabilities.d.ts

@@ -0,0 +1,13 @@
+export declare class OllamaCapabilities {
+    static findModel(modelId: string): import("../../models/types.js").Model | undefined;
+    static getContextWindow(modelId: string): number | null;
+    static supportsVision(modelId: string): boolean;
+    static supportsTools(modelId: string): boolean;
+    static supportsStructuredOutput(modelId: string): boolean;
+    static supportsEmbeddings(modelId: string): boolean;
+    static supportsReasoning(modelId: string): boolean;
+    static supportsImageGeneration(modelId: string): boolean;
+    static supportsTranscription(modelId: string): boolean;
+    static supportsModeration(modelId: string): boolean;
+}
+//# sourceMappingURL=Capabilities.d.ts.map

package/dist/providers/ollama/Capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Capabilities.d.ts","sourceRoot":"","sources":["../../../src/providers/ollama/Capabilities.ts"],"names":[],"mappings":"AAEA,qBAAa,kBAAkB;IAC7B,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM;IAYhC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAKvD,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAU/C,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAK9C,MAAM,CAAC,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKzD,MAAM,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKnD,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKlD,MAAM,CAAC,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKxD,MAAM,CAAC,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKtD,MAAM,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;CAIpD"}

package/dist/providers/ollama/Capabilities.js

@@ -0,0 +1,54 @@
+import { ModelRegistry } from "../../models/ModelRegistry.js";
+export class OllamaCapabilities {
+    static findModel(modelId) {
+        // Ollama specific: try exact match first, then strip tags
+        let model = ModelRegistry.find(modelId, "ollama");
+        if (!model && modelId?.includes(":")) {
+            const baseId = modelId.split(":")[0];
+            if (baseId) {
+                model = ModelRegistry.find(baseId, "ollama");
+            }
+        }
+        return model;
+    }
+    static getContextWindow(modelId) {
+        const model = this.findModel(modelId);
+        return model?.context_window || 8192;
+    }
+    static supportsVision(modelId) {
+        const model = this.findModel(modelId);
+        if (model) {
+            return model.modalities?.input?.includes("image") || model.capabilities?.includes("vision") || false;
+        }
+        // Fallback for custom models not in registry
+        return /vision|llava|moondream|bakllava/.test(modelId.toLowerCase());
+    }
+    static supportsTools(modelId) {
+        const model = this.findModel(modelId);
+        return model?.capabilities?.includes("tools") || false;
+    }
+    static supportsStructuredOutput(modelId) {
+        const model = this.findModel(modelId);
+        return model?.capabilities?.includes("structured_output") || false;
+    }
+    static supportsEmbeddings(modelId) {
+        const model = this.findModel(modelId);
+        return model?.modalities?.output?.includes("embeddings") || model?.capabilities?.includes("embeddings") || false;
+    }
+    static supportsReasoning(modelId) {
+        const model = this.findModel(modelId);
+        return model?.capabilities?.includes("reasoning") || false;
+    }
+    static supportsImageGeneration(modelId) {
+        const model = this.findModel(modelId);
+        return model?.modalities?.output?.includes("image") || false;
+    }
+    static supportsTranscription(modelId) {
+        const model = this.findModel(modelId);
+        return model?.modalities?.input?.includes("audio") || false;
+    }
+    static supportsModeration(modelId) {
+        const model = this.findModel(modelId);
+        return model?.modalities?.output?.includes("moderation") || false;
+    }
+}

package/dist/providers/ollama/Embedding.d.ts

@@ -0,0 +1,6 @@
+import { OpenAIEmbedding } from "../openai/Embedding.js";
+export declare class OllamaEmbedding extends OpenAIEmbedding {
+    protected getProviderName(): string;
+    protected validateModel(model: string): void;
+}
+//# sourceMappingURL=Embedding.d.ts.map

package/dist/providers/ollama/Embedding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Embedding.d.ts","sourceRoot":"","sources":["../../../src/providers/ollama/Embedding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD,qBAAa,eAAgB,SAAQ,eAAe;cAC/B,eAAe,IAAI,MAAM;cAIzB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAKtD"}

package/dist/providers/ollama/Embedding.js

@@ -0,0 +1,12 @@
+import { OpenAIEmbedding } from "../openai/Embedding.js";
+import { OllamaCapabilities } from "./Capabilities.js";
+export class OllamaEmbedding extends OpenAIEmbedding {
+    getProviderName() {
+        return "ollama";
+    }
+    validateModel(model) {
+        if (!OllamaCapabilities.supportsEmbeddings(model)) {
+            throw new Error(`Model ${model} does not support embeddings.`);
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+import { OpenAIModels } from "../openai/Models.js";
+export declare class OllamaModels extends OpenAIModels {
+    protected getProviderName(): string;
+    protected formatDisplayName(modelId: string): string;
+    protected getContextWindow(modelId: string): number | null;
+    protected getCapabilities(modelId: string): string[];
+}
+//# sourceMappingURL=Models.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Models.d.ts","sourceRoot":"","sources":["../../../src/providers/ollama/Models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAInD,qBAAa,YAAa,SAAQ,YAAY;cACzB,eAAe,IAAI,MAAM;cAIzB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;cAO1C,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;cAIhD,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;CAW9D"}

package/dist/providers/ollama/Models.js

@@ -0,0 +1,31 @@
+import { OpenAIModels } from "../openai/Models.js";
+import { OllamaCapabilities } from "./Capabilities.js";
+export class OllamaModels extends OpenAIModels {
+    getProviderName() {
+        return "ollama";
+    }
+    formatDisplayName(modelId) {
+        const model = OllamaCapabilities.findModel(modelId);
+        if (model?.name && model.name !== modelId)
+            return model.name;
+        const baseId = modelId.split(":")[0] || modelId;
+        return baseId.replace(/-/g, " ").replace(/\b\w/g, c => c.toUpperCase());
+    }
+    getContextWindow(modelId) {
+        return OllamaCapabilities.getContextWindow(modelId);
+    }
+    getCapabilities(modelId) {
+        const model = OllamaCapabilities.findModel(modelId);
+        if (model)
+            return model.capabilities;
+        // Fallback for custom pulled models
+        const caps = ["streaming"];
+        if (OllamaCapabilities.supportsTools(modelId))
+            caps.push("tools");
+        if (OllamaCapabilities.supportsVision(modelId))
+            caps.push("vision");
+        if (OllamaCapabilities.supportsEmbeddings(modelId))
+            caps.push("embeddings");
+        return caps;
+    }
+}

package/dist/providers/ollama/OllamaProvider.d.ts

@@ -0,0 +1,10 @@
+import { OpenAIProvider } from "../openai/OpenAIProvider.js";
+export interface OllamaProviderOptions {
+    baseUrl?: string;
+}
+export declare class OllamaProvider extends OpenAIProvider {
+    constructor(options?: OllamaProviderOptions);
+    protected providerName(): string;
+    defaultModel(feature?: string): string;
+}
+//# sourceMappingURL=OllamaProvider.d.ts.map

package/dist/providers/ollama/OllamaProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OllamaProvider.d.ts","sourceRoot":"","sources":["../../../src/providers/ollama/OllamaProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAM7D,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,cAAe,SAAQ,cAAc;gBACpC,OAAO,GAAE,qBAA0B;IAwB/C,SAAS,CAAC,YAAY,IAAI,MAAM;IAIhB,YAAY,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;CAGvD"}