@hazeljs/ai 0.2.0-alpha.1

package/dist/providers/gemini.provider.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiProvider = void 0;
+const core_1 = __importDefault(require("@hazeljs/core"));
+const generative_ai_1 = require("@google/generative-ai");
+/**
+ * Google Gemini AI Provider
+ *
+ * Production-ready implementation using Google Generative AI SDK.
+ *
+ * Setup:
+ * 1. Install the SDK: `npm install @google/generative-ai`
+ * 2. Set GEMINI_API_KEY environment variable
+ * 3. Use the provider in your application
+ *
+ * Supported models:
+ * - gemini-pro: Text generation
+ * - gemini-pro-vision: Multimodal (text + images)
+ * - gemini-1.5-pro: Latest model with extended context
+ * - text-embedding-004: Text embeddings
+ */
+class GeminiProvider {
+    constructor(apiKey, endpoint) {
+        this.name = 'gemini';
+        this.apiKey = apiKey || process.env.GEMINI_API_KEY || '';
+        this.endpoint = endpoint || 'https://generativelanguage.googleapis.com/v1';
+        if (!this.apiKey) {
+            core_1.default.warn('Gemini API key not provided. Set GEMINI_API_KEY environment variable.');
+        }
+        this.genAI = new generative_ai_1.GoogleGenerativeAI(this.apiKey);
+        core_1.default.info('Gemini provider initialized');
+    }
+    /**
+     * Generate completion
+     */
+    async complete(request) {
+        const modelName = request.model || 'gemini-pro';
+        core_1.default.debug(`Gemini completion request for model: ${modelName}`);
+        try {
+            const model = this.genAI.getGenerativeModel({ model: modelName });
+            // Convert messages to Gemini format
+            const prompt = request.messages
+                .map((m) => {
+                const role = m.role === 'assistant' ? 'model' : m.role;
+                return `${role}: ${m.content}`;
+            })
+                .join('\n\n');
+            // Generate content
+            const result = await model.generateContent(prompt);
+            const response = result.response;
+            const text = response.text();
+            return {
+                id: `gemini-${Date.now()}`,
+                content: text,
+                role: 'assistant',
+                model: modelName,
+                usage: {
+                    promptTokens: response.usageMetadata?.promptTokenCount || 0,
+                    completionTokens: response.usageMetadata?.candidatesTokenCount || 0,
+                    totalTokens: response.usageMetadata?.totalTokenCount || 0,
+                },
+                finishReason: response.candidates?.[0]?.finishReason || 'STOP',
+            };
+        }
+        catch (error) {
+            core_1.default.error('Gemini completion error:', error);
+            throw new Error(`Gemini API error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Generate streaming completion
+     */
+    async *streamComplete(request) {
+        const modelName = request.model || 'gemini-pro';
+        core_1.default.debug('Gemini streaming completion started');
+        try {
+            const model = this.genAI.getGenerativeModel({ model: modelName });
+            // Convert messages to Gemini format
+            const prompt = request.messages
+                .map((m) => {
+                const role = m.role === 'assistant' ? 'model' : m.role;
+                return `${role}: ${m.content}`;
+            })
+                .join('\n\n');
+            // Generate streaming content
+            const result = await model.generateContentStream(prompt);
+            let fullContent = '';
+            let chunkCount = 0;
+            for await (const chunk of result.stream) {
+                const text = chunk.text();
+                fullContent += text;
+                chunkCount++;
+                const isLast = chunk.candidates?.[0]?.finishReason !== undefined;
+                yield {
+                    id: `gemini-stream-${Date.now()}-${chunkCount}`,
+                    content: fullContent,
+                    delta: text,
+                    done: isLast,
+                    usage: isLast && chunk.usageMetadata
+                        ? {
+                            promptTokens: chunk.usageMetadata.promptTokenCount || 0,
+                            completionTokens: chunk.usageMetadata.candidatesTokenCount || 0,
+                            totalTokens: chunk.usageMetadata.totalTokenCount || 0,
+                        }
+                        : undefined,
+                };
+            }
+            core_1.default.debug('Gemini streaming completed');
+        }
+        catch (error) {
+            core_1.default.error('Gemini streaming error:', error);
+            throw new Error(`Gemini streaming error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Generate embeddings
+     */
+    async embed(request) {
+        const modelName = request.model || 'text-embedding-004';
+        core_1.default.debug(`Gemini embedding request for model: ${modelName}`);
+        try {
+            const model = this.genAI.getGenerativeModel({ model: modelName });
+            const inputs = Array.isArray(request.input) ? request.input : [request.input];
+            // Generate embeddings for each input
+            const embeddings = await Promise.all(inputs.map(async (text) => {
+                const result = await model.embedContent(text);
+                return result.embedding.values;
+            }));
+            // Estimate token usage (Gemini doesn't provide exact counts for embeddings)
+            const estimatedTokens = inputs.reduce((sum, text) => sum + Math.ceil(text.length / 4), 0);
+            return {
+                embeddings,
+                model: modelName,
+                usage: {
+                    promptTokens: estimatedTokens,
+                    totalTokens: estimatedTokens,
+                },
+            };
+        }
+        catch (error) {
+            core_1.default.error('Gemini embedding error:', error);
+            throw new Error(`Gemini embedding error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Check if provider is available
+     */
+    async isAvailable() {
+        if (!this.apiKey) {
+            core_1.default.warn('Gemini API key not configured');
+            return false;
+        }
+        try {
+            // Test with a minimal request
+            const model = this.genAI.getGenerativeModel({ model: 'gemini-pro' });
+            await model.generateContent('test');
+            return true;
+        }
+        catch (error) {
+            core_1.default.error('Gemini availability check failed:', error);
+            return false;
+        }
+    }
+    /**
+     * Get supported models
+     */
+    getSupportedModels() {
+        return [
+            'gemini-pro',
+            'gemini-pro-vision',
+            'gemini-1.5-pro',
+            'gemini-1.5-flash',
+            'text-embedding-004',
+        ];
+    }
+}
+exports.GeminiProvider = GeminiProvider;

package/dist/providers/gemini.provider.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gemini.provider.test.d.ts.map

package/dist/providers/gemini.provider.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemini.provider.test.d.ts","sourceRoot":"","sources":["../../src/providers/gemini.provider.test.ts"],"names":[],"mappings":""}

package/dist/providers/gemini.provider.test.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@hazeljs/core', () => ({
+    __esModule: true,
+    default: { info: jest.fn(), debug: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+const mockGenerateContent = jest.fn();
+const mockGenerateContentStream = jest.fn();
+const mockEmbedContent = jest.fn();
+const mockGetGenerativeModel = jest.fn().mockReturnValue({
+    generateContent: mockGenerateContent,
+    generateContentStream: mockGenerateContentStream,
+    embedContent: mockEmbedContent,
+});
+jest.mock('@google/generative-ai', () => ({
+    GoogleGenerativeAI: jest.fn().mockImplementation(() => ({
+        getGenerativeModel: mockGetGenerativeModel,
+    })),
+}));
+const gemini_provider_1 = require("./gemini.provider");
+const BASE_REQUEST = {
+    messages: [{ role: 'user', content: 'Hello Gemini' }],
+    model: 'gemini-pro',
+};
+const MOCK_GENERATE_RESULT = {
+    response: {
+        text: jest.fn().mockReturnValue('Gemini response'),
+        usageMetadata: {
+            promptTokenCount: 8,
+            candidatesTokenCount: 12,
+            totalTokenCount: 20,
+        },
+        candidates: [{ finishReason: 'STOP' }],
+    },
+};
+describe('GeminiProvider', () => {
+    let provider;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        MOCK_GENERATE_RESULT.response.text.mockReturnValue('Gemini response');
+        provider = new gemini_provider_1.GeminiProvider('test-api-key');
+    });
+    describe('constructor', () => {
+        it('sets name to gemini', () => {
+            expect(provider.name).toBe('gemini');
+        });
+        it('warns when no API key', () => {
+            new gemini_provider_1.GeminiProvider(); // Should not throw
+        });
+        it('uses GEMINI_API_KEY env var', () => {
+            process.env.GEMINI_API_KEY = 'env-key';
+            const p = new gemini_provider_1.GeminiProvider();
+            expect(p).toBeDefined();
+            delete process.env.GEMINI_API_KEY;
+        });
+    });
+    describe('getSupportedModels()', () => {
+        it('returns list of gemini models', () => {
+            const models = provider.getSupportedModels();
+            expect(models).toContain('gemini-pro');
+            expect(models.length).toBeGreaterThan(0);
+        });
+    });
+    describe('complete()', () => {
+        it('returns a completion response', async () => {
+            mockGenerateContent.mockResolvedValue(MOCK_GENERATE_RESULT);
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.content).toBe('Gemini response');
+            expect(result.role).toBe('assistant');
+            expect(result.usage?.promptTokens).toBe(8);
+            expect(result.usage?.completionTokens).toBe(12);
+            expect(result.usage?.totalTokens).toBe(20);
+        });
+        it('uses default model when not specified', async () => {
+            mockGenerateContent.mockResolvedValue(MOCK_GENERATE_RESULT);
+            await provider.complete({ messages: [{ role: 'user', content: 'hi' }] });
+            expect(mockGetGenerativeModel).toHaveBeenCalledWith({ model: 'gemini-pro' });
+        });
+        it('converts messages to prompt format', async () => {
+            mockGenerateContent.mockResolvedValue(MOCK_GENERATE_RESULT);
+            await provider.complete({
+                messages: [
+                    { role: 'user', content: 'User msg' },
+                    { role: 'assistant', content: 'Asst msg' },
+                    { role: 'system', content: 'Sys msg' },
+                ],
+            });
+            const callArg = mockGenerateContent.mock.calls[0][0];
+            expect(callArg).toContain('user: User msg');
+            expect(callArg).toContain('model: Asst msg');
+            expect(callArg).toContain('system: Sys msg');
+        });
+        it('handles missing usageMetadata gracefully', async () => {
+            mockGenerateContent.mockResolvedValue({
+                response: {
+                    text: jest.fn().mockReturnValue('ok'),
+                    usageMetadata: undefined,
+                    candidates: undefined,
+                },
+            });
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.usage?.totalTokens).toBe(0);
+            expect(result.finishReason).toBe('STOP');
+        });
+        it('throws wrapped error on API failure', async () => {
+            mockGenerateContent.mockRejectedValue(new Error('Quota exceeded'));
+            await expect(provider.complete(BASE_REQUEST)).rejects.toThrow('Gemini API error: Quota exceeded');
+        });
+        it('wraps non-Error thrown values', async () => {
+            mockGenerateContent.mockRejectedValue('string error');
+            await expect(provider.complete(BASE_REQUEST)).rejects.toThrow('Gemini API error: Unknown error');
+        });
+    });
+    describe('streamComplete()', () => {
+        it('yields chunks from stream', async () => {
+            async function* mockStream() {
+                yield {
+                    text: jest.fn().mockReturnValue('Hello '),
+                    candidates: undefined,
+                    usageMetadata: undefined,
+                };
+                yield {
+                    text: jest.fn().mockReturnValue('world'),
+                    candidates: [{ finishReason: 'STOP' }],
+                    usageMetadata: { promptTokenCount: 5, candidatesTokenCount: 3, totalTokenCount: 8 },
+                };
+            }
+            mockGenerateContentStream.mockResolvedValue({ stream: mockStream() });
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            expect(results.length).toBe(2);
+        });
+        it('marks last chunk as done when finishReason is set', async () => {
+            async function* mockStream() {
+                yield {
+                    text: jest.fn().mockReturnValue('end'),
+                    candidates: [{ finishReason: 'STOP' }],
+                    usageMetadata: { promptTokenCount: 3, candidatesTokenCount: 2, totalTokenCount: 5 },
+                };
+            }
+            mockGenerateContentStream.mockResolvedValue({ stream: mockStream() });
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            expect(results[0].done).toBe(true);
+            expect(results[0].usage).toBeDefined();
+        });
+        it('yields chunks without usage when not last', async () => {
+            async function* mockStream() {
+                yield {
+                    text: jest.fn().mockReturnValue('partial'),
+                    candidates: undefined,
+                    usageMetadata: undefined,
+                };
+            }
+            mockGenerateContentStream.mockResolvedValue({ stream: mockStream() });
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            expect(results[0].done).toBe(false);
+            expect(results[0].usage).toBeUndefined();
+        });
+        it('throws wrapped error on stream failure', async () => {
+            mockGenerateContentStream.mockRejectedValue(new Error('Stream failed'));
+            await expect(async () => {
+                for await (const _chunk of provider.streamComplete(BASE_REQUEST)) {
+                    // consume
+                }
+            }).rejects.toThrow('Gemini streaming error: Stream failed');
+        });
+    });
+    describe('embed()', () => {
+        it('returns embeddings for single string input', async () => {
+            mockEmbedContent.mockResolvedValue({ embedding: { values: [0.1, 0.2, 0.3] } });
+            const result = await provider.embed({ input: 'hello world', model: 'text-embedding-004' });
+            expect(result.embeddings).toHaveLength(1);
+            expect(result.embeddings[0]).toEqual([0.1, 0.2, 0.3]);
+        });
+        it('returns embeddings for array input', async () => {
+            mockEmbedContent.mockResolvedValue({ embedding: { values: [0.5, 0.6] } });
+            const result = await provider.embed({ input: ['first', 'second'] });
+            expect(result.embeddings).toHaveLength(2);
+            expect(mockEmbedContent).toHaveBeenCalledTimes(2);
+        });
+        it('uses default model text-embedding-004', async () => {
+            mockEmbedContent.mockResolvedValue({ embedding: { values: [0.1] } });
+            const result = await provider.embed({ input: 'test' });
+            expect(mockGetGenerativeModel).toHaveBeenCalledWith({ model: 'text-embedding-004' });
+            expect(result.model).toBe('text-embedding-004');
+        });
+        it('estimates token usage based on input length', async () => {
+            mockEmbedContent.mockResolvedValue({ embedding: { values: [0.1] } });
+            const result = await provider.embed({ input: 'test input' }); // 10 chars → 3 tokens
+            expect(result.usage?.promptTokens).toBeGreaterThan(0);
+        });
+        it('throws wrapped error on API failure', async () => {
+            mockEmbedContent.mockRejectedValue(new Error('Embedding failed'));
+            await expect(provider.embed({ input: 'test' })).rejects.toThrow('Gemini embedding error: Embedding failed');
+        });
+    });
+    describe('isAvailable()', () => {
+        it('returns false when no API key', async () => {
+            const p = new gemini_provider_1.GeminiProvider('');
+            expect(await p.isAvailable()).toBe(false);
+        });
+        it('returns true when API responds', async () => {
+            mockGenerateContent.mockResolvedValue(MOCK_GENERATE_RESULT);
+            expect(await provider.isAvailable()).toBe(true);
+        });
+        it('returns false on API error', async () => {
+            mockGenerateContent.mockRejectedValue(new Error('API error'));
+            expect(await provider.isAvailable()).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,45 @@
+import { IAIProvider, AIProvider, AICompletionRequest, AICompletionResponse, AIStreamChunk, AIEmbeddingRequest, AIEmbeddingResponse } from '../ai-enhanced.types';
+/**
+ * Ollama Provider
+ * Production-ready implementation for local LLM support via Ollama
+ * Supports models like Llama 2, Mistral, CodeLlama, and other open-source models
+ */
+export declare class OllamaProvider implements IAIProvider {
+    readonly name: AIProvider;
+    private baseURL;
+    private defaultModel;
+    constructor(config?: {
+        baseURL?: string;
+        defaultModel?: string;
+    });
+    /**
+     * Transform messages to Ollama prompt format
+     */
+    private transformMessages;
+    /**
+     * Generate completion
+     */
+    complete(request: AICompletionRequest): Promise<AICompletionResponse>;
+    /**
+     * Generate streaming completion
+     */
+    streamComplete(request: AICompletionRequest): AsyncGenerator<AIStreamChunk>;
+    /**
+     * Generate embeddings
+     */
+    embed(request: AIEmbeddingRequest): Promise<AIEmbeddingResponse>;
+    /**
+     * Check if provider is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Get supported models
+     * Note: This returns common models, but Ollama supports any model you pull
+     */
+    getSupportedModels(): string[];
+    /**
+     * Get supported embedding models
+     */
+    getSupportedEmbeddingModels(): string[];
+}
+//# sourceMappingURL=ollama.provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ollama.provider.d.ts","sourceRoot":"","sources":["../../src/providers/ollama.provider.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,UAAU,EACV,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EAEpB,MAAM,sBAAsB,CAAC;AAiC9B;;;;GAIG;AACH,qBAAa,cAAe,YAAW,WAAW;IAChD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAY;IACrC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAS;gBAEjB,MAAM,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE;IAMhE;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAUzB;;OAEG;IACG,QAAQ,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IA+C3E;;OAEG;IACI,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,cAAc,CAAC,aAAa,CAAC;IAqFlF;;OAEG;IACG,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAqCtE;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAWrC;;;OAGG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAkB9B;;OAEG;IACH,2BAA2B,IAAI,MAAM,EAAE;CAGxC"}

package/dist/providers/ollama.provider.js

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaProvider = void 0;
+const core_1 = __importDefault(require("@hazeljs/core"));
+/**
+ * Ollama Provider
+ * Production-ready implementation for local LLM support via Ollama
+ * Supports models like Llama 2, Mistral, CodeLlama, and other open-source models
+ */
+class OllamaProvider {
+    constructor(config) {
+        this.name = 'ollama';
+        this.baseURL = config?.baseURL || process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+        this.defaultModel = config?.defaultModel || 'llama2';
+        core_1.default.info(`Ollama provider initialized with base URL: ${this.baseURL}`);
+    }
+    /**
+     * Transform messages to Ollama prompt format
+     */
+    transformMessages(messages) {
+        return messages
+            .map((msg) => {
+            const role = msg.role === 'assistant' ? 'Assistant' : msg.role === 'system' ? 'System' : 'User';
+            return `${role}: ${msg.content}`;
+        })
+            .join('\n\n');
+    }
+    /**
+     * Generate completion
+     */
+    async complete(request) {
+        try {
+            const model = request.model || this.defaultModel;
+            core_1.default.debug(`Ollama completion request for model: ${model}`);
+            const prompt = this.transformMessages(request.messages);
+            const ollamaRequest = {
+                model,
+                prompt,
+                stream: false,
+                temperature: request.temperature ?? 0.7,
+                num_predict: request.maxTokens,
+                top_p: request.topP,
+            };
+            const response = await fetch(`${this.baseURL}/api/generate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(ollamaRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Ollama API error: ${response.status} ${errorText}`);
+            }
+            const data = (await response.json());
+            return {
+                id: `ollama-${Date.now()}`,
+                content: data.response,
+                role: 'assistant',
+                model: data.model,
+                usage: {
+                    promptTokens: data.prompt_eval_count || 0,
+                    completionTokens: data.eval_count || 0,
+                    totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+                },
+                finishReason: data.done ? 'stop' : 'length',
+            };
+        }
+        catch (error) {
+            core_1.default.error('Ollama completion error:', error);
+            throw error;
+        }
+    }
+    /**
+     * Generate streaming completion
+     */
+    async *streamComplete(request) {
+        try {
+            const model = request.model || this.defaultModel;
+            core_1.default.debug(`Ollama streaming completion request for model: ${model}`);
+            const prompt = this.transformMessages(request.messages);
+            const ollamaRequest = {
+                model,
+                prompt,
+                stream: true,
+                temperature: request.temperature ?? 0.7,
+                num_predict: request.maxTokens,
+                top_p: request.topP,
+            };
+            const response = await fetch(`${this.baseURL}/api/generate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(ollamaRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Ollama API error: ${response.status} ${errorText}`);
+            }
+            if (!response.body) {
+                throw new Error('No response body available for streaming');
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let fullContent = '';
+            let totalPromptTokens = 0;
+            let totalCompletionTokens = 0;
+            const chunkId = `ollama-${Date.now()}`;
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    const chunk = decoder.decode(value, { stream: true });
+                    const lines = chunk.split('\n').filter(Boolean);
+                    for (const line of lines) {
+                        try {
+                            const data = JSON.parse(line);
+                            if (data.response) {
+                                fullContent += data.response;
+                                totalPromptTokens = data.prompt_eval_count || totalPromptTokens;
+                                totalCompletionTokens = data.eval_count || totalCompletionTokens;
+                                yield {
+                                    id: chunkId,
+                                    content: fullContent,
+                                    delta: data.response,
+                                    done: data.done || false,
+                                    usage: {
+                                        promptTokens: totalPromptTokens,
+                                        completionTokens: totalCompletionTokens,
+                                        totalTokens: totalPromptTokens + totalCompletionTokens,
+                                    },
+                                };
+                            }
+                            if (data.done) {
+                                return;
+                            }
+                        }
+                        catch {
+                            // Skip invalid JSON lines
+                            continue;
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        }
+        catch (error) {
+            core_1.default.error('Ollama streaming error:', error);
+            throw error;
+        }
+    }
+    /**
+     * Generate embeddings
+     */
+    async embed(request) {
+        try {
+            const model = request.model || this.defaultModel;
+            core_1.default.debug(`Ollama embedding request for model: ${model}`);
+            const input = Array.isArray(request.input) ? request.input[0] : request.input;
+            const response = await fetch(`${this.baseURL}/api/embeddings`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model,
+                    prompt: input,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Ollama API error: ${response.status} ${errorText}`);
+            }
+            const data = (await response.json());
+            return {
+                embeddings: [data.embedding],
+                model,
+                usage: {
+                    promptTokens: 0, // Ollama doesn't provide token usage for embeddings
+                    totalTokens: 0,
+                },
+            };
+        }
+        catch (error) {
+            core_1.default.error('Ollama embedding error:', error);
+            throw error;
+        }
+    }
+    /**
+     * Check if provider is available
+     */
+    async isAvailable() {
+        try {
+            const response = await fetch(`${this.baseURL}/api/tags`, {
+                method: 'GET',
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get supported models
+     * Note: This returns common models, but Ollama supports any model you pull
+     */
+    getSupportedModels() {
+        return [
+            'llama2',
+            'llama2:13b',
+            'llama2:70b',
+            'mistral',
+            'mixtral',
+            'codellama',
+            'neural-chat',
+            'starling-lm',
+            'phi',
+            'orca-mini',
+            'vicuna',
+            'wizardcoder',
+            'wizard-vicuna',
+        ];
+    }
+    /**
+     * Get supported embedding models
+     */
+    getSupportedEmbeddingModels() {
+        return ['llama2', 'mistral', 'nomic-embed-text'];
+    }
+}
+exports.OllamaProvider = OllamaProvider;