@hazeljs/ai 0.2.0-beta.54 → 0.2.0-beta.56

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

@@ -0,0 +1,222 @@
+"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 mockMessagesCreate = jest.fn();
+const mockMessagesStream = jest.fn();
+jest.mock('@anthropic-ai/sdk', () => ({
+    __esModule: true,
+    default: jest.fn().mockImplementation(() => ({
+        messages: {
+            create: mockMessagesCreate,
+            stream: mockMessagesStream,
+        },
+    })),
+}));
+const anthropic_provider_1 = require("./anthropic.provider");
+const BASE_REQUEST = {
+    messages: [{ role: 'user', content: 'Hello' }],
+    model: 'claude-3-5-sonnet-20241022',
+};
+const MOCK_RESPONSE = {
+    id: 'msg_001',
+    content: [{ type: 'text', text: 'Hello there!' }],
+    model: 'claude-3-5-sonnet-20241022',
+    stop_reason: 'end_turn',
+    usage: { input_tokens: 10, output_tokens: 15 },
+};
+describe('AnthropicProvider', () => {
+    let provider;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        provider = new anthropic_provider_1.AnthropicProvider('test-api-key');
+    });
+    describe('constructor', () => {
+        it('sets name to anthropic', () => {
+            expect(provider.name).toBe('anthropic');
+        });
+        it('warns when no API key provided', () => {
+            new anthropic_provider_1.AnthropicProvider();
+            // Constructor runs without throwing
+        });
+        it('uses ANTHROPIC_API_KEY env var', () => {
+            process.env.ANTHROPIC_API_KEY = 'env-key';
+            const p = new anthropic_provider_1.AnthropicProvider();
+            expect(p).toBeDefined();
+            delete process.env.ANTHROPIC_API_KEY;
+        });
+    });
+    describe('getSupportedModels()', () => {
+        it('returns a list of claude models', () => {
+            const models = provider.getSupportedModels();
+            expect(models).toContain('claude-3-5-sonnet-20241022');
+            expect(models.length).toBeGreaterThan(0);
+        });
+    });
+    describe('complete()', () => {
+        it('returns a completion response', async () => {
+            mockMessagesCreate.mockResolvedValue(MOCK_RESPONSE);
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.content).toBe('Hello there!');
+            expect(result.role).toBe('assistant');
+            expect(result.usage?.promptTokens).toBe(10);
+            expect(result.usage?.completionTokens).toBe(15);
+            expect(result.usage?.totalTokens).toBe(25);
+            expect(result.finishReason).toBe('end_turn');
+        });
+        it('uses default model when not specified', async () => {
+            mockMessagesCreate.mockResolvedValue(MOCK_RESPONSE);
+            await provider.complete({ messages: [{ role: 'user', content: 'hi' }] });
+            expect(mockMessagesCreate).toHaveBeenCalledWith(expect.objectContaining({ model: 'claude-3-5-sonnet-20241022' }));
+        });
+        it('passes maxTokens when specified', async () => {
+            mockMessagesCreate.mockResolvedValue(MOCK_RESPONSE);
+            await provider.complete({ ...BASE_REQUEST, maxTokens: 500 });
+            expect(mockMessagesCreate).toHaveBeenCalledWith(expect.objectContaining({ max_tokens: 500 }));
+        });
+        it('separates system messages from conversation', async () => {
+            mockMessagesCreate.mockResolvedValue(MOCK_RESPONSE);
+            await provider.complete({
+                messages: [
+                    { role: 'system', content: 'You are helpful.' },
+                    { role: 'user', content: 'Hello' },
+                ],
+            });
+            expect(mockMessagesCreate).toHaveBeenCalledWith(expect.objectContaining({
+                system: 'You are helpful.',
+                messages: [{ role: 'user', content: 'Hello' }],
+            }));
+        });
+        it('handles response with no stop_reason', async () => {
+            mockMessagesCreate.mockResolvedValue({ ...MOCK_RESPONSE, stop_reason: null });
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.finishReason).toBe('end_turn');
+        });
+        it('concatenates multiple text content blocks', async () => {
+            mockMessagesCreate.mockResolvedValue({
+                ...MOCK_RESPONSE,
+                content: [
+                    { type: 'text', text: 'Part 1. ' },
+                    { type: 'text', text: 'Part 2.' },
+                ],
+            });
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.content).toBe('Part 1. Part 2.');
+        });
+        it('ignores non-text content blocks', async () => {
+            mockMessagesCreate.mockResolvedValue({
+                ...MOCK_RESPONSE,
+                content: [
+                    { type: 'tool_use', id: 'tool_1' },
+                    { type: 'text', text: 'Some text' },
+                ],
+            });
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.content).toBe('Some text');
+        });
+        it('throws wrapped error on API failure', async () => {
+            mockMessagesCreate.mockRejectedValue(new Error('Rate limit exceeded'));
+            await expect(provider.complete(BASE_REQUEST)).rejects.toThrow('Anthropic API error: Rate limit exceeded');
+        });
+        it('handles non-Error thrown objects', async () => {
+            mockMessagesCreate.mockRejectedValue('string error');
+            await expect(provider.complete(BASE_REQUEST)).rejects.toThrow('Anthropic API error: Unknown error');
+        });
+        it('sets undefined system when no system messages', async () => {
+            mockMessagesCreate.mockResolvedValue(MOCK_RESPONSE);
+            await provider.complete({ messages: [{ role: 'user', content: 'hi' }] });
+            expect(mockMessagesCreate).toHaveBeenCalledWith(expect.objectContaining({ system: undefined }));
+        });
+    });
+    describe('streamComplete()', () => {
+        function makeStreamEvents(events) {
+            return (async function* () {
+                for (const ev of events) {
+                    yield ev;
+                }
+            })();
+        }
+        it('yields chunks for message_start and content_block_delta events', async () => {
+            mockMessagesStream.mockReturnValue(makeStreamEvents([
+                { type: 'message_start', message: { id: 'msg_1', usage: { input_tokens: 5 } } },
+                { type: 'content_block_delta', delta: { type: 'text_delta', text: 'Hello' } },
+                { type: 'content_block_delta', delta: { type: 'text_delta', text: ' world' } },
+                { type: 'message_delta', usage: { output_tokens: 10 } },
+                { type: 'message_stop' },
+            ]));
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            // 2 content deltas + 1 message_stop
+            expect(results.length).toBeGreaterThan(0);
+        });
+        it('includes usage in final chunk', async () => {
+            mockMessagesStream.mockReturnValue(makeStreamEvents([
+                { type: 'message_start', message: { id: 'msg_2', usage: { input_tokens: 8 } } },
+                { type: 'message_delta', usage: { output_tokens: 12 } },
+                { type: 'message_stop' },
+            ]));
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            const finalChunk = results[results.length - 1];
+            expect(finalChunk.done).toBe(true);
+            expect(finalChunk.usage).toBeDefined();
+        });
+        it('ignores non-text_delta content blocks', async () => {
+            mockMessagesStream.mockReturnValue(makeStreamEvents([
+                { type: 'content_block_delta', delta: { type: 'input_json_delta', partial_json: '{}' } },
+                { type: 'message_stop' },
+            ]));
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            // Only message_stop chunk
+            expect(results).toHaveLength(1);
+        });
+        it('uses default model for streaming', async () => {
+            mockMessagesStream.mockReturnValue(makeStreamEvents([{ type: 'message_stop' }]));
+            for await (const _chunk of provider.streamComplete({
+                messages: [{ role: 'user', content: 'hi' }],
+            })) {
+                // consume
+            }
+            expect(mockMessagesStream).toHaveBeenCalledWith(expect.objectContaining({ model: 'claude-3-5-sonnet-20241022' }));
+        });
+        it('throws wrapped error on streaming failure', async () => {
+            mockMessagesStream.mockImplementation(async function* () {
+                throw new Error('Stream error');
+                yield { type: 'message_stop' };
+            });
+            await expect(async () => {
+                for await (const _chunk of provider.streamComplete(BASE_REQUEST)) {
+                    // consume
+                }
+            }).rejects.toThrow('Anthropic streaming error: Stream error');
+        });
+    });
+    describe('embed()', () => {
+        it('throws not supported error', async () => {
+            await expect(provider.embed({ input: 'test' })).rejects.toThrow('Anthropic does not support embeddings');
+        });
+    });
+    describe('isAvailable()', () => {
+        it('returns false when no API key', async () => {
+            const p = new anthropic_provider_1.AnthropicProvider('');
+            expect(await p.isAvailable()).toBe(false);
+        });
+        it('returns true when API responds successfully', async () => {
+            mockMessagesCreate.mockResolvedValue(MOCK_RESPONSE);
+            expect(await provider.isAvailable()).toBe(true);
+        });
+        it('returns false on API error', async () => {
+            mockMessagesCreate.mockRejectedValue(new Error('Unauthorized'));
+            expect(await provider.isAvailable()).toBe(false);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,267 @@
+"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 mockGenerate = jest.fn();
+const mockGenerateStream = jest.fn();
+const mockEmbed = jest.fn();
+const mockRerank = jest.fn();
+jest.mock('cohere-ai', () => ({
+    CohereClient: jest.fn().mockImplementation(() => ({
+        generate: mockGenerate,
+        generateStream: mockGenerateStream,
+        embed: mockEmbed,
+        rerank: mockRerank,
+    })),
+}));
+const cohere_provider_1 = require("./cohere.provider");
+const BASE_REQUEST = {
+    messages: [{ role: 'user', content: 'Hello Cohere' }],
+    model: 'command',
+};
+const MOCK_GENERATE_RESPONSE = {
+    id: 'cohere-123',
+    generations: [{ text: 'Cohere response' }],
+    meta: { billedUnits: { inputTokens: 10, outputTokens: 20 } },
+};
+describe('CohereProvider', () => {
+    let provider;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        provider = new cohere_provider_1.CohereProvider('test-api-key');
+    });
+    describe('constructor', () => {
+        it('sets name to cohere', () => {
+            expect(provider.name).toBe('cohere');
+        });
+        it('warns when no API key', () => {
+            new cohere_provider_1.CohereProvider(); // Should not throw
+        });
+        it('uses COHERE_API_KEY env var', () => {
+            process.env.COHERE_API_KEY = 'env-key';
+            const p = new cohere_provider_1.CohereProvider();
+            expect(p).toBeDefined();
+            delete process.env.COHERE_API_KEY;
+        });
+    });
+    describe('getSupportedModels()', () => {
+        it('returns list of cohere models', () => {
+            const models = provider.getSupportedModels();
+            expect(models).toContain('command');
+            expect(models.length).toBeGreaterThan(0);
+        });
+    });
+    describe('complete()', () => {
+        it('returns a completion response', async () => {
+            mockGenerate.mockResolvedValue(MOCK_GENERATE_RESPONSE);
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.content).toBe('Cohere response');
+            expect(result.role).toBe('assistant');
+            expect(result.usage?.promptTokens).toBe(10);
+            expect(result.usage?.completionTokens).toBe(20);
+            expect(result.usage?.totalTokens).toBe(30);
+            expect(result.finishReason).toBe('COMPLETE');
+        });
+        it('uses default model when not specified', async () => {
+            mockGenerate.mockResolvedValue(MOCK_GENERATE_RESPONSE);
+            await provider.complete({ messages: [{ role: 'user', content: 'hi' }] });
+            expect(mockGenerate).toHaveBeenCalledWith(expect.objectContaining({ model: 'command' }));
+        });
+        it('passes temperature and maxTokens to API', async () => {
+            mockGenerate.mockResolvedValue(MOCK_GENERATE_RESPONSE);
+            await provider.complete({ ...BASE_REQUEST, temperature: 0.5, maxTokens: 200, topP: 0.9 });
+            expect(mockGenerate).toHaveBeenCalledWith(expect.objectContaining({ temperature: 0.5, maxTokens: 200, p: 0.9 }));
+        });
+        it('handles missing meta/billedUnits gracefully', async () => {
+            mockGenerate.mockResolvedValue({
+                generations: [{ text: 'ok' }],
+                meta: undefined,
+            });
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.usage?.totalTokens).toBe(0);
+        });
+        it('uses generated id when response has one', async () => {
+            mockGenerate.mockResolvedValue(MOCK_GENERATE_RESPONSE);
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.id).toBe('cohere-123');
+        });
+        it('generates a fallback id when response has no id', async () => {
+            mockGenerate.mockResolvedValue({ ...MOCK_GENERATE_RESPONSE, id: undefined });
+            const result = await provider.complete(BASE_REQUEST);
+            expect(result.id).toMatch(/^cohere-\d+$/);
+        });
+        it('converts messages to prompt format', async () => {
+            mockGenerate.mockResolvedValue(MOCK_GENERATE_RESPONSE);
+            await provider.complete({
+                messages: [
+                    { role: 'user', content: 'User msg' },
+                    { role: 'assistant', content: 'Asst msg' },
+                ],
+            });
+            const callArg = mockGenerate.mock.calls[0][0];
+            expect(callArg.prompt).toContain('user: User msg');
+            expect(callArg.prompt).toContain('assistant: Asst msg');
+        });
+        it('throws wrapped error on API failure', async () => {
+            mockGenerate.mockRejectedValue(new Error('Quota exceeded'));
+            await expect(provider.complete(BASE_REQUEST)).rejects.toThrow('Cohere API error: Quota exceeded');
+        });
+        it('wraps non-Error thrown values', async () => {
+            mockGenerate.mockRejectedValue('string error');
+            await expect(provider.complete(BASE_REQUEST)).rejects.toThrow('Cohere API error: Unknown error');
+        });
+    });
+    describe('streamComplete()', () => {
+        it('yields text-generation chunks', async () => {
+            async function* mockStream() {
+                yield { eventType: 'text-generation', text: 'Hello ' };
+                yield { eventType: 'text-generation', text: 'world' };
+                yield {
+                    eventType: 'stream-end',
+                    response: {
+                        meta: { billedUnits: { inputTokens: 5, outputTokens: 10 } },
+                    },
+                };
+            }
+            mockGenerateStream.mockReturnValue(mockStream());
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            // 2 text chunks + 1 stream-end
+            expect(results.length).toBe(3);
+        });
+        it('yields done=true chunk on stream-end with usage', async () => {
+            async function* mockStream() {
+                yield {
+                    eventType: 'stream-end',
+                    response: { meta: { billedUnits: { inputTokens: 5, outputTokens: 3 } } },
+                };
+            }
+            mockGenerateStream.mockReturnValue(mockStream());
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            const last = results[results.length - 1];
+            expect(last.done).toBe(true);
+            expect(last.usage).toBeDefined();
+        });
+        it('yields stream-end with undefined usage when no billedUnits', async () => {
+            async function* mockStream() {
+                yield { eventType: 'stream-end', response: { meta: {} } };
+            }
+            mockGenerateStream.mockReturnValue(mockStream());
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            expect(results[0].usage).toBeUndefined();
+        });
+        it('ignores unknown event types', async () => {
+            async function* mockStream() {
+                yield { eventType: 'unknown-event' };
+                yield { eventType: 'stream-end', response: {} };
+            }
+            mockGenerateStream.mockReturnValue(mockStream());
+            const results = [];
+            for await (const chunk of provider.streamComplete(BASE_REQUEST)) {
+                results.push(chunk);
+            }
+            expect(results.length).toBe(1); // only stream-end
+        });
+        it('throws wrapped error on streaming failure', async () => {
+            mockGenerateStream.mockImplementation(async function* () {
+                throw new Error('Stream crashed');
+                yield { eventType: 'stream-end' };
+            });
+            await expect(async () => {
+                for await (const _chunk of provider.streamComplete(BASE_REQUEST)) {
+                    // consume
+                }
+            }).rejects.toThrow('Cohere streaming error: Stream crashed');
+        });
+    });
+    describe('embed()', () => {
+        it('returns embeddings for string array', async () => {
+            mockEmbed.mockResolvedValue({
+                embeddings: [
+                    [0.1, 0.2],
+                    [0.3, 0.4],
+                ],
+            });
+            const result = await provider.embed({ input: ['first', 'second'] });
+            expect(result.embeddings).toHaveLength(2);
+            expect(result.model).toBe('embed-english-v3.0');
+        });
+        it('handles single string input', async () => {
+            mockEmbed.mockResolvedValue({ embeddings: [[0.5, 0.6]] });
+            const result = await provider.embed({ input: 'single' });
+            expect(result.embeddings).toHaveLength(1);
+        });
+        it('handles { float: number[][] } response format', async () => {
+            mockEmbed.mockResolvedValue({ embeddings: { float: [[0.7, 0.8]] } });
+            const result = await provider.embed({ input: 'test' });
+            expect(result.embeddings).toEqual([[0.7, 0.8]]);
+        });
+        it('uses custom model when specified', async () => {
+            mockEmbed.mockResolvedValue({ embeddings: [[0.1]] });
+            const result = await provider.embed({ input: 'test', model: 'embed-multilingual-v3.0' });
+            expect(result.model).toBe('embed-multilingual-v3.0');
+        });
+        it('estimates token usage from input length', async () => {
+            mockEmbed.mockResolvedValue({ embeddings: [[0.1]] });
+            const result = await provider.embed({ input: 'hello world' }); // 11 chars → ~3 tokens
+            expect(result.usage?.promptTokens).toBeGreaterThan(0);
+        });
+        it('throws wrapped error on failure', async () => {
+            mockEmbed.mockRejectedValue(new Error('Embedding failed'));
+            await expect(provider.embed({ input: 'test' })).rejects.toThrow('Cohere embedding error: Embedding failed');
+        });
+    });
+    describe('isAvailable()', () => {
+        it('returns false when no API key', async () => {
+            const p = new cohere_provider_1.CohereProvider('');
+            expect(await p.isAvailable()).toBe(false);
+        });
+        it('returns true when API responds', async () => {
+            mockGenerate.mockResolvedValue(MOCK_GENERATE_RESPONSE);
+            expect(await provider.isAvailable()).toBe(true);
+        });
+        it('returns false on API error', async () => {
+            mockGenerate.mockRejectedValue(new Error('Unauthorized'));
+            expect(await provider.isAvailable()).toBe(false);
+        });
+    });
+    describe('rerank()', () => {
+        it('returns ranked documents', async () => {
+            mockRerank.mockResolvedValue({
+                results: [
+                    { index: 1, relevanceScore: 0.9 },
+                    { index: 0, relevanceScore: 0.7 },
+                ],
+            });
+            const result = await provider.rerank('query', ['doc0', 'doc1'], 2);
+            expect(result).toHaveLength(2);
+            expect(result[0].score).toBe(0.9);
+            expect(result[0].index).toBe(1);
+            expect(result[0].document).toBe('doc1');
+        });
+        it('uses default rerank model', async () => {
+            mockRerank.mockResolvedValue({ results: [] });
+            await provider.rerank('query', ['doc1']);
+            expect(mockRerank).toHaveBeenCalledWith(expect.objectContaining({ model: 'rerank-english-v3.0' }));
+        });
+        it('uses custom model when specified', async () => {
+            mockRerank.mockResolvedValue({ results: [] });
+            await provider.rerank('query', ['doc'], undefined, 'rerank-multilingual-v3.0');
+            expect(mockRerank).toHaveBeenCalledWith(expect.objectContaining({ model: 'rerank-multilingual-v3.0' }));
+        });
+        it('throws wrapped error on rerank failure', async () => {
+            mockRerank.mockRejectedValue(new Error('Rerank failed'));
+            await expect(provider.rerank('q', ['d'])).rejects.toThrow('Cohere rerank error: Rerank failed');
+        });
+    });
+});

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