@hazeljs/ai 0.2.0-alpha.1

package/dist/index.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * @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.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
+var openai_provider_1 = require("./providers/openai.provider");
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return openai_provider_1.OpenAIProvider; } });
+var anthropic_provider_1 = require("./providers/anthropic.provider");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return anthropic_provider_1.AnthropicProvider; } });
+var gemini_provider_1 = require("./providers/gemini.provider");
+Object.defineProperty(exports, "GeminiProvider", { enumerable: true, get: function () { return gemini_provider_1.GeminiProvider; } });
+var cohere_provider_1 = require("./providers/cohere.provider");
+Object.defineProperty(exports, "CohereProvider", { enumerable: true, get: function () { return cohere_provider_1.CohereProvider; } });
+var ollama_provider_1 = require("./providers/ollama.provider");
+Object.defineProperty(exports, "OllamaProvider", { enumerable: true, get: function () { return ollama_provider_1.OllamaProvider; } });
+var ai_function_decorator_1 = require("./decorators/ai-function.decorator");
+Object.defineProperty(exports, "AIFunction", { enumerable: true, get: function () { return ai_function_decorator_1.AIFunction; } });
+Object.defineProperty(exports, "AIPrompt", { enumerable: true, get: function () { return ai_function_decorator_1.AIPrompt; } });
+Object.defineProperty(exports, "getAIFunctionMetadata", { enumerable: true, get: function () { return ai_function_decorator_1.getAIFunctionMetadata; } });
+Object.defineProperty(exports, "hasAIFunctionMetadata", { enumerable: true, get: function () { return ai_function_decorator_1.hasAIFunctionMetadata; } });
+Object.defineProperty(exports, "getAIPromptMetadata", { enumerable: true, get: function () { return ai_function_decorator_1.getAIPromptMetadata; } });
+var ai_validate_decorator_1 = require("./decorators/ai-validate.decorator");
+Object.defineProperty(exports, "AIValidate", { enumerable: true, get: function () { return ai_validate_decorator_1.AIValidate; } });
+Object.defineProperty(exports, "AIValidateProperty", { enumerable: true, get: function () { return ai_validate_decorator_1.AIValidateProperty; } });
+Object.defineProperty(exports, "getAIValidationMetadata", { enumerable: true, get: function () { return ai_validate_decorator_1.getAIValidationMetadata; } });
+Object.defineProperty(exports, "hasAIValidationMetadata", { enumerable: true, get: function () { return ai_validate_decorator_1.hasAIValidationMetadata; } });
+Object.defineProperty(exports, "getAIPropertyValidationMetadata", { enumerable: true, get: function () { return ai_validate_decorator_1.getAIPropertyValidationMetadata; } });
+var vector_service_1 = require("./vector/vector.service");
+Object.defineProperty(exports, "VectorService", { enumerable: true, get: function () { return vector_service_1.VectorService; } });

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.d.ts

@@ -0,0 +1,48 @@
+import { IAIProvider, AIProvider, AICompletionRequest, AICompletionResponse, AIStreamChunk, AIEmbeddingRequest, AIEmbeddingResponse } from '../ai-enhanced.types';
+/**
+ * Anthropic Claude AI Provider
+ *
+ * Production-ready implementation using Anthropic SDK.
+ *
+ * Setup:
+ * 1. Install the SDK: `npm install @anthropic-ai/sdk`
+ * 2. Set ANTHROPIC_API_KEY environment variable
+ * 3. Use the provider in your application
+ *
+ * Supported models:
+ * - claude-3-5-sonnet-20241022: Latest and most intelligent model
+ * - claude-3-opus-20240229: Most powerful for complex tasks
+ * - claude-3-sonnet-20240229: Balanced performance
+ * - claude-3-haiku-20240307: Fast and cost-effective
+ *
+ * Note: Anthropic does not provide embeddings API. Use OpenAI or Cohere for embeddings.
+ */
+export declare class AnthropicProvider implements IAIProvider {
+    readonly name: AIProvider;
+    private apiKey;
+    private anthropic;
+    private endpoint;
+    constructor(apiKey?: string, endpoint?: string);
+    /**
+     * Generate completion
+     */
+    complete(request: AICompletionRequest): Promise<AICompletionResponse>;
+    /**
+     * Generate streaming completion
+     */
+    streamComplete(request: AICompletionRequest): AsyncGenerator<AIStreamChunk>;
+    /**
+     * Generate embeddings
+     * Note: Anthropic doesn't provide embeddings API
+     */
+    embed(_request: AIEmbeddingRequest): Promise<AIEmbeddingResponse>;
+    /**
+     * Check if provider is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Get supported models
+     */
+    getSupportedModels(): string[];
+}
+//# sourceMappingURL=anthropic.provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.provider.d.ts","sourceRoot":"","sources":["../../src/providers/anthropic.provider.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,UAAU,EACV,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAI9B;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,iBAAkB,YAAW,WAAW;IACnD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAe;IACxC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,QAAQ,CAAS;gBAEb,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAY9C;;OAEG;IACG,QAAQ,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAiD3E;;OAEG;IACI,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,cAAc,CAAC,aAAa,CAAC;IAsElF;;;OAGG;IACG,KAAK,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAIvE;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAoBrC;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;CAW/B"}

package/dist/providers/anthropic.provider.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+const core_1 = __importDefault(require("@hazeljs/core"));
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+/**
+ * Anthropic Claude AI Provider
+ *
+ * Production-ready implementation using Anthropic SDK.
+ *
+ * Setup:
+ * 1. Install the SDK: `npm install @anthropic-ai/sdk`
+ * 2. Set ANTHROPIC_API_KEY environment variable
+ * 3. Use the provider in your application
+ *
+ * Supported models:
+ * - claude-3-5-sonnet-20241022: Latest and most intelligent model
+ * - claude-3-opus-20240229: Most powerful for complex tasks
+ * - claude-3-sonnet-20240229: Balanced performance
+ * - claude-3-haiku-20240307: Fast and cost-effective
+ *
+ * Note: Anthropic does not provide embeddings API. Use OpenAI or Cohere for embeddings.
+ */
+class AnthropicProvider {
+    constructor(apiKey, endpoint) {
+        this.name = 'anthropic';
+        this.apiKey = apiKey || process.env.ANTHROPIC_API_KEY || '';
+        this.endpoint = endpoint || 'https://api.anthropic.com/v1';
+        if (!this.apiKey) {
+            core_1.default.warn('Anthropic API key not provided. Set ANTHROPIC_API_KEY environment variable.');
+        }
+        this.anthropic = new sdk_1.default({ apiKey: this.apiKey });
+        core_1.default.info('Anthropic provider initialized');
+    }
+    /**
+     * Generate completion
+     */
+    async complete(request) {
+        const modelName = request.model || 'claude-3-5-sonnet-20241022';
+        core_1.default.debug(`Anthropic completion request for model: ${modelName}`);
+        try {
+            // Separate system messages from conversation messages
+            const systemMessages = request.messages.filter((m) => m.role === 'system');
+            const conversationMessages = request.messages.filter((m) => m.role !== 'system');
+            const systemPrompt = systemMessages.map((m) => m.content).join('\n\n');
+            // Create message request
+            const response = await this.anthropic.messages.create({
+                model: modelName,
+                max_tokens: request.maxTokens || 4096,
+                temperature: request.temperature,
+                system: systemPrompt || undefined,
+                messages: conversationMessages.map((m) => ({
+                    role: m.role,
+                    content: m.content,
+                })),
+            });
+            // Extract text content
+            const textContent = response.content
+                .filter((block) => block.type === 'text')
+                .map((block) => block.text || '')
+                .join('');
+            return {
+                id: response.id,
+                content: textContent,
+                role: 'assistant',
+                model: response.model,
+                usage: {
+                    promptTokens: response.usage.input_tokens,
+                    completionTokens: response.usage.output_tokens,
+                    totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+                },
+                finishReason: response.stop_reason || 'end_turn',
+            };
+        }
+        catch (error) {
+            core_1.default.error('Anthropic completion error:', error);
+            throw new Error(`Anthropic API error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Generate streaming completion
+     */
+    async *streamComplete(request) {
+        const modelName = request.model || 'claude-3-5-sonnet-20241022';
+        core_1.default.debug('Anthropic streaming completion started');
+        try {
+            // Separate system messages from conversation messages
+            const systemMessages = request.messages.filter((m) => m.role === 'system');
+            const conversationMessages = request.messages.filter((m) => m.role !== 'system');
+            const systemPrompt = systemMessages.map((m) => m.content).join('\n\n');
+            // Create streaming request
+            const stream = await this.anthropic.messages.stream({
+                model: modelName,
+                max_tokens: request.maxTokens || 4096,
+                temperature: request.temperature,
+                system: systemPrompt || undefined,
+                messages: conversationMessages.map((m) => ({
+                    role: m.role,
+                    content: m.content,
+                })),
+            });
+            let fullContent = '';
+            let messageId = '';
+            let inputTokens = 0;
+            let outputTokens = 0;
+            for await (const event of stream) {
+                if (event.type === 'message_start') {
+                    messageId = event.message.id;
+                    inputTokens = event.message.usage.input_tokens;
+                }
+                else if (event.type === 'content_block_delta') {
+                    if (event.delta.type === 'text_delta') {
+                        const text = event.delta.text;
+                        fullContent += text;
+                        yield {
+                            id: messageId || `claude-stream-${Date.now()}`,
+                            content: fullContent,
+                            delta: text,
+                            done: false,
+                        };
+                    }
+                }
+                else if (event.type === 'message_delta') {
+                    outputTokens = event.usage.output_tokens;
+                }
+                else if (event.type === 'message_stop') {
+                    yield {
+                        id: messageId || `claude-stream-${Date.now()}`,
+                        content: fullContent,
+                        delta: '',
+                        done: true,
+                        usage: {
+                            promptTokens: inputTokens,
+                            completionTokens: outputTokens,
+                            totalTokens: inputTokens + outputTokens,
+                        },
+                    };
+                }
+            }
+            core_1.default.debug('Anthropic streaming completed');
+        }
+        catch (error) {
+            core_1.default.error('Anthropic streaming error:', error);
+            throw new Error(`Anthropic streaming error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Generate embeddings
+     * Note: Anthropic doesn't provide embeddings API
+     */
+    async embed(_request) {
+        throw new Error('Anthropic does not support embeddings. Use OpenAI or Cohere instead.');
+    }
+    /**
+     * Check if provider is available
+     */
+    async isAvailable() {
+        if (!this.apiKey) {
+            core_1.default.warn('Anthropic API key not configured');
+            return false;
+        }
+        try {
+            // Test with a minimal request using fastest model
+            await this.anthropic.messages.create({
+                model: 'claude-3-haiku-20240307',
+                max_tokens: 10,
+                messages: [{ role: 'user', content: 'test' }],
+            });
+            return true;
+        }
+        catch (error) {
+            core_1.default.error('Anthropic availability check failed:', error);
+            return false;
+        }
+    }
+    /**
+     * Get supported models
+     */
+    getSupportedModels() {
+        return [
+            'claude-3-5-sonnet-20241022',
+            'claude-3-5-sonnet-20240620',
+            'claude-3-opus-20240229',
+            'claude-3-sonnet-20240229',
+            'claude-3-haiku-20240307',
+            'claude-2.1',
+            'claude-2.0',
+        ];
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;

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.d.ts

@@ -0,0 +1,57 @@
+import { IAIProvider, AIProvider, AICompletionRequest, AICompletionResponse, AIStreamChunk, AIEmbeddingRequest, AIEmbeddingResponse } from '../ai-enhanced.types';
+/**
+ * Cohere AI Provider
+ *
+ * Production-ready implementation using Cohere AI SDK.
+ *
+ * Setup:
+ * 1. Install the SDK: `npm install cohere-ai`
+ * 2. Set COHERE_API_KEY environment variable
+ * 3. Use the provider in your application
+ *
+ * Supported models:
+ * - command-r-plus: Most powerful model for complex tasks
+ * - command-r: Balanced performance and cost
+ * - command: Standard text generation
+ * - command-light: Fast, cost-effective model
+ * - embed-english-v3.0: English text embeddings
+ * - embed-multilingual-v3.0: Multilingual embeddings
+ * - rerank-english-v3.0: Document reranking
+ */
+export declare class CohereProvider implements IAIProvider {
+    readonly name: AIProvider;
+    private apiKey;
+    private cohere;
+    private endpoint;
+    constructor(apiKey?: string, endpoint?: string);
+    /**
+     * 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
+     */
+    getSupportedModels(): string[];
+    /**
+     * Rerank documents (Cohere-specific feature)
+     * Useful for RAG applications to improve retrieval quality
+     */
+    rerank(query: string, documents: string[], topN?: number, model?: string): Promise<Array<{
+        index: number;
+        score: number;
+        document: string;
+    }>>;
+}
+//# sourceMappingURL=cohere.provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cohere.provider.d.ts","sourceRoot":"","sources":["../../src/providers/cohere.provider.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,UAAU,EACV,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAI9B;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,cAAe,YAAW,WAAW;IAChD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAY;IACrC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,QAAQ,CAAS;gBAEb,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAY9C;;OAEG;IACG,QAAQ,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAuC3E;;OAEG;IACI,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,cAAc,CAAC,aAAa,CAAC;IAgElF;;OAEG;IACG,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAsCtE;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAoBrC;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAgB9B;;;OAGG;IACG,MAAM,CACV,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EAAE,EACnB,IAAI,CAAC,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAwBtE"}