@hazeljs/ai 0.2.0-beta.8 → 0.2.0-beta.80

package/dist/context/context.manager.test.js

@@ -0,0 +1,180 @@
+"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 context_manager_1 = require("./context.manager");
+describe('AIContextManager', () => {
+    let manager;
+    beforeEach(() => {
+        manager = new context_manager_1.AIContextManager(200);
+    });
+    describe('constructor', () => {
+        it('initializes with default maxTokens', () => {
+            const m = new context_manager_1.AIContextManager();
+            expect(m.maxTokens).toBe(4096);
+            expect(m.messages).toEqual([]);
+            expect(m.currentTokens).toBe(0);
+        });
+        it('initializes with custom maxTokens', () => {
+            const m = new context_manager_1.AIContextManager(1000);
+            expect(m.maxTokens).toBe(1000);
+        });
+    });
+    describe('addMessage()', () => {
+        it('adds a user message', () => {
+            manager.addMessage({ role: 'user', content: 'hello' });
+            expect(manager.messages).toHaveLength(1);
+            expect(manager.messages[0].content).toBe('hello');
+        });
+        it('increments currentTokens', () => {
+            manager.addMessage({ role: 'user', content: 'hello' });
+            expect(manager.currentTokens).toBeGreaterThan(0);
+        });
+        it('adds message with name field', () => {
+            manager.addMessage({ role: 'user', content: 'hi', name: 'Alice' });
+            expect(manager.messages[0].name).toBe('Alice');
+        });
+        it('adds message with functionCall field', () => {
+            manager.addMessage({
+                role: 'assistant',
+                content: '',
+                functionCall: { name: 'getWeather', arguments: '{"city":"NYC"}' },
+            });
+            expect(manager.messages).toHaveLength(1);
+        });
+        it('auto-trims when content exceeds token limit', () => {
+            const tightManager = new context_manager_1.AIContextManager(10);
+            tightManager.addMessage({ role: 'user', content: 'a'.repeat(200) });
+            expect(tightManager.currentTokens).toBeLessThanOrEqual(10);
+        });
+        it('adds multiple messages', () => {
+            manager.addMessage({ role: 'user', content: 'first' });
+            manager.addMessage({ role: 'assistant', content: 'second' });
+            expect(manager.messages).toHaveLength(2);
+        });
+    });
+    describe('getMessages()', () => {
+        it('returns a shallow copy of messages', () => {
+            manager.addMessage({ role: 'user', content: 'test' });
+            const msgs = manager.getMessages();
+            msgs.push({ role: 'assistant', content: 'extra' });
+            expect(manager.messages).toHaveLength(1);
+        });
+        it('returns empty array when no messages', () => {
+            expect(manager.getMessages()).toEqual([]);
+        });
+    });
+    describe('clear()', () => {
+        it('clears all messages and resets token count', () => {
+            manager.addMessage({ role: 'user', content: 'test' });
+            manager.clear();
+            expect(manager.messages).toHaveLength(0);
+            expect(manager.currentTokens).toBe(0);
+        });
+    });
+    describe('trimToLimit()', () => {
+        it('preserves system messages', () => {
+            const tightManager = new context_manager_1.AIContextManager(50);
+            tightManager.addMessage({ role: 'system', content: 'You are a helpful assistant' });
+            tightManager.addMessage({ role: 'user', content: 'message 1 to be trimmed maybe' });
+            tightManager.addMessage({ role: 'user', content: 'message 2 to be trimmed maybe' });
+            tightManager.trimToLimit();
+            const systemMsgs = tightManager.getSystemMessages();
+            expect(systemMsgs).toHaveLength(1);
+        });
+        it('keeps most recent conversation messages', () => {
+            const tightManager = new context_manager_1.AIContextManager(30);
+            tightManager.addMessage({ role: 'user', content: 'old' });
+            tightManager.addMessage({ role: 'user', content: 'new' });
+            tightManager.trimToLimit();
+            const msgs = tightManager.getConversationMessages();
+            if (msgs.length > 0) {
+                expect(msgs[msgs.length - 1].content).toBe('new');
+            }
+        });
+        it('trims all conversation messages when system tokens fill the limit', () => {
+            const tightManager = new context_manager_1.AIContextManager(5);
+            tightManager.addMessage({ role: 'system', content: 'sys' });
+            tightManager.addMessage({ role: 'user', content: 'user msg' });
+            tightManager.trimToLimit();
+            expect(tightManager.getSystemMessages()).toHaveLength(1);
+        });
+    });
+    describe('getStats()', () => {
+        it('returns zero stats when empty', () => {
+            const stats = manager.getStats();
+            expect(stats.messageCount).toBe(0);
+            expect(stats.currentTokens).toBe(0);
+            expect(stats.maxTokens).toBe(200);
+            expect(stats.utilizationPercent).toBe(0);
+        });
+        it('returns correct utilization after adding messages', () => {
+            manager.addMessage({ role: 'user', content: 'hello world' });
+            const stats = manager.getStats();
+            expect(stats.messageCount).toBe(1);
+            expect(stats.utilizationPercent).toBeGreaterThan(0);
+        });
+    });
+    describe('setMaxTokens()', () => {
+        it('updates maxTokens', () => {
+            manager.setMaxTokens(500);
+            expect(manager.maxTokens).toBe(500);
+        });
+        it('trims when new limit is lower than current usage', () => {
+            manager.addMessage({ role: 'user', content: 'a'.repeat(200) });
+            manager.setMaxTokens(10);
+            expect(manager.currentTokens).toBeLessThanOrEqual(10);
+        });
+        it('does not trim when new limit is higher', () => {
+            manager.addMessage({ role: 'user', content: 'hello' });
+            const tokensBefore = manager.currentTokens;
+            manager.setMaxTokens(1000);
+            expect(manager.currentTokens).toBe(tokensBefore);
+        });
+    });
+    describe('getSystemMessages()', () => {
+        it('returns only system messages', () => {
+            manager.addMessage({ role: 'system', content: 'system prompt' });
+            manager.addMessage({ role: 'user', content: 'user msg' });
+            expect(manager.getSystemMessages()).toHaveLength(1);
+            expect(manager.getSystemMessages()[0].role).toBe('system');
+        });
+        it('returns empty array when no system messages', () => {
+            manager.addMessage({ role: 'user', content: 'user' });
+            expect(manager.getSystemMessages()).toHaveLength(0);
+        });
+    });
+    describe('getConversationMessages()', () => {
+        it('returns user and assistant messages only', () => {
+            manager.addMessage({ role: 'system', content: 'system' });
+            manager.addMessage({ role: 'user', content: 'user' });
+            manager.addMessage({ role: 'assistant', content: 'assistant' });
+            const conv = manager.getConversationMessages();
+            expect(conv).toHaveLength(2);
+            expect(conv.every((m) => m.role === 'user' || m.role === 'assistant')).toBe(true);
+        });
+    });
+    describe('addSystemMessage()', () => {
+        it('adds a system message', () => {
+            manager.addSystemMessage('You are helpful');
+            expect(manager.messages[0].role).toBe('system');
+            expect(manager.messages[0].content).toBe('You are helpful');
+        });
+    });
+    describe('addUserMessage()', () => {
+        it('adds a user message', () => {
+            manager.addUserMessage('What is the weather?');
+            expect(manager.messages[0].role).toBe('user');
+            expect(manager.messages[0].content).toBe('What is the weather?');
+        });
+    });
+    describe('addAssistantMessage()', () => {
+        it('adds an assistant message', () => {
+            manager.addAssistantMessage('It is sunny');
+            expect(manager.messages[0].role).toBe('assistant');
+            expect(manager.messages[0].content).toBe('It is sunny');
+        });
+    });
+});

package/dist/index.d.ts

@@ -3,6 +3,7 @@
  */
 export { AIModule } from './ai.module';
 export { AIService } from './ai.service';
+export { AIEnhancedService } from './ai-enhanced.service';
 export type { AITaskConfig, AITaskContext, AITaskResult } from './ai.types';
 export { AITask } from './ai.decorator';
 export { OpenAIProvider } from './providers/openai.provider';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAGxC,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EACL,UAAU,EACV,QAAQ,EACR,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,uBAAuB,EACvB,uBAAuB,EACvB,+BAA+B,GAChC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EACL,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,UAAU,IAAI,cAAc,EACjC,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,GACzB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAGxC,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EACL,UAAU,EACV,QAAQ,EACR,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,uBAAuB,EACvB,uBAAuB,EACvB,+BAA+B,GAChC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EACL,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,UAAU,IAAI,cAAc,EACjC,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,GACzB,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -3,12 +3,14 @@
  * @hazeljs/ai - AI integration module for HazelJS
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VectorService = exports.getAIPropertyValidationMetadata = exports.hasAIValidationMetadata = exports.getAIValidationMetadata = exports.AIValidateProperty = exports.AIValidate = exports.getAIPromptMetadata = exports.hasAIFunctionMetadata = exports.getAIFunctionMetadata = exports.AIPrompt = exports.AIFunction = exports.OllamaProvider = exports.CohereProvider = exports.GeminiProvider = exports.AnthropicProvider = exports.OpenAIProvider = exports.AITask = exports.AIService = exports.AIModule = void 0;
+exports.VectorService = exports.getAIPropertyValidationMetadata = exports.hasAIValidationMetadata = exports.getAIValidationMetadata = exports.AIValidateProperty = exports.AIValidate = exports.getAIPromptMetadata = exports.hasAIFunctionMetadata = exports.getAIFunctionMetadata = exports.AIPrompt = exports.AIFunction = exports.OllamaProvider = exports.CohereProvider = exports.GeminiProvider = exports.AnthropicProvider = exports.OpenAIProvider = exports.AITask = exports.AIEnhancedService = exports.AIService = exports.AIModule = void 0;
 // AI Module
 var ai_module_1 = require("./ai.module");
 Object.defineProperty(exports, "AIModule", { enumerable: true, get: function () { return ai_module_1.AIModule; } });
 var ai_service_1 = require("./ai.service");
 Object.defineProperty(exports, "AIService", { enumerable: true, get: function () { return ai_service_1.AIService; } });
+var ai_enhanced_service_1 = require("./ai-enhanced.service");
+Object.defineProperty(exports, "AIEnhancedService", { enumerable: true, get: function () { return ai_enhanced_service_1.AIEnhancedService; } });
 var ai_decorator_1 = require("./ai.decorator");
 Object.defineProperty(exports, "AITask", { enumerable: true, get: function () { return ai_decorator_1.AITask; } });
 // Enhanced AI

package/dist/prompts/task.prompt.d.ts

@@ -0,0 +1,12 @@
+import { PromptTemplate } from '@hazeljs/prompts';
+export declare const AI_TASK_FORMAT_KEY = "ai:task:format";
+export interface AITaskFormatVariables {
+    taskName: string;
+    description: string;
+    input: string;
+    inputExample: string;
+    outputExample: string;
+}
+declare const template: PromptTemplate<AITaskFormatVariables>;
+export { template as aiTaskFormatPrompt };
+//# sourceMappingURL=task.prompt.d.ts.map

package/dist/prompts/task.prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.prompt.d.ts","sourceRoot":"","sources":["../../src/prompts/task.prompt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAkB,MAAM,kBAAkB,CAAC;AAElE,eAAO,MAAM,kBAAkB,mBAAmB,CAAC;AAEnD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,QAAA,MAAM,QAAQ,uCAKZ,CAAC;AAIH,OAAO,EAAE,QAAQ,IAAI,kBAAkB,EAAE,CAAC"}

package/dist/prompts/task.prompt.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiTaskFormatPrompt = exports.AI_TASK_FORMAT_KEY = void 0;
+const prompts_1 = require("@hazeljs/prompts");
+exports.AI_TASK_FORMAT_KEY = 'ai:task:format';
+const template = new prompts_1.PromptTemplate(`{description}`, {
+    name: 'AI Task Format',
+    description: 'Formats an AI task prompt by substituting context variables into the template string',
+    version: '1.0.0',
+});
+exports.aiTaskFormatPrompt = template;
+prompts_1.PromptRegistry.register(exports.AI_TASK_FORMAT_KEY, template);

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

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

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

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

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