@hazeljs/ai 0.2.0-beta.1

package/dist/decorators/ai-function.decorator.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIFunction = AIFunction;
+exports.getAIFunctionMetadata = getAIFunctionMetadata;
+exports.hasAIFunctionMetadata = hasAIFunctionMetadata;
+exports.AIPrompt = AIPrompt;
+exports.getAIPromptMetadata = getAIPromptMetadata;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+const AI_FUNCTION_METADATA_KEY = 'hazel:ai:function';
+const AI_PROMPT_METADATA_KEY = 'hazel:ai:prompt';
+/**
+ * AIFunction decorator for AI-powered methods
+ *
+ * @example
+ * ```typescript
+ * @AIFunction({
+ *   provider: 'openai',
+ *   model: 'gpt-4',
+ *   streaming: true
+ * })
+ * async generateContent(@AIPrompt() prompt: string) {
+ *   // Auto-handled by framework
+ * }
+ * ```
+ */
+function AIFunction(options) {
+    return (target, propertyKey, descriptor) => {
+        const defaults = {
+            streaming: false,
+            temperature: 0.7,
+            maxTokens: 1000,
+            ...options,
+        };
+        Reflect.defineMetadata(AI_FUNCTION_METADATA_KEY, defaults, target, propertyKey);
+        core_1.default.debug(`AIFunction decorator applied to ${target.constructor.name}.${String(propertyKey)}`);
+        return descriptor;
+    };
+}
+/**
+ * Get AI function metadata
+ */
+function getAIFunctionMetadata(target, propertyKey) {
+    return Reflect.getMetadata(AI_FUNCTION_METADATA_KEY, target, propertyKey);
+}
+/**
+ * Check if method has AI function metadata
+ */
+function hasAIFunctionMetadata(target, propertyKey) {
+    return Reflect.hasMetadata(AI_FUNCTION_METADATA_KEY, target, propertyKey);
+}
+/**
+ * AIPrompt parameter decorator
+ *
+ * @example
+ * ```typescript
+ * async generateContent(@AIPrompt() prompt: string) {
+ *   // prompt parameter is marked for AI processing
+ * }
+ * ```
+ */
+function AIPrompt() {
+    return (target, propertyKey, parameterIndex) => {
+        const existingParams = Reflect.getMetadata(AI_PROMPT_METADATA_KEY, target, propertyKey) || [];
+        existingParams[parameterIndex] = 'prompt';
+        Reflect.defineMetadata(AI_PROMPT_METADATA_KEY, existingParams, target, propertyKey);
+    };
+}
+/**
+ * Get AI prompt parameter metadata
+ */
+function getAIPromptMetadata(target, propertyKey) {
+    const params = Reflect.getMetadata(AI_PROMPT_METADATA_KEY, target, propertyKey) || [];
+    return params
+        .map((p, index) => (p === 'prompt' ? index : -1))
+        .filter((i) => i !== -1);
+}

package/dist/decorators/ai-validate.decorator.d.ts

@@ -0,0 +1,46 @@
+import 'reflect-metadata';
+import { AIValidationOptions } from '../ai-enhanced.types';
+/**
+ * AIValidate decorator for AI-powered validation
+ *
+ * @example
+ * ```typescript
+ * @AIValidate({
+ *   provider: 'openai',
+ *   instruction: 'Validate if this is a professional email'
+ * })
+ * export class ContactDto {
+ *   @IsEmail()
+ *   email: string;
+ * }
+ * ```
+ */
+export declare function AIValidate(options: AIValidationOptions): ClassDecorator;
+/**
+ * Get AI validation metadata
+ */
+export declare function getAIValidationMetadata(target: object): AIValidationOptions | undefined;
+/**
+ * Check if class has AI validation metadata
+ */
+export declare function hasAIValidationMetadata(target: object): boolean;
+/**
+ * AIValidateProperty decorator for property-level validation
+ *
+ * @example
+ * ```typescript
+ * export class UserDto {
+ *   @AIValidateProperty({
+ *     provider: 'openai',
+ *     instruction: 'Check if this username is appropriate'
+ *   })
+ *   username: string;
+ * }
+ * ```
+ */
+export declare function AIValidateProperty(options: AIValidationOptions): PropertyDecorator;
+/**
+ * Get AI property validation metadata
+ */
+export declare function getAIPropertyValidationMetadata(target: object, propertyKey: string | symbol): AIValidationOptions | undefined;
+//# sourceMappingURL=ai-validate.decorator.d.ts.map

package/dist/decorators/ai-validate.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-validate.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/ai-validate.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAK3D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,mBAAmB,GAAG,cAAc,CAYvE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAEvF;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,mBAAmB,GAAG,iBAAiB,CAalF;AAED;;GAEG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,GAC3B,mBAAmB,GAAG,SAAS,CAEjC"}

package/dist/decorators/ai-validate.decorator.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIValidate = AIValidate;
+exports.getAIValidationMetadata = getAIValidationMetadata;
+exports.hasAIValidationMetadata = hasAIValidationMetadata;
+exports.AIValidateProperty = AIValidateProperty;
+exports.getAIPropertyValidationMetadata = getAIPropertyValidationMetadata;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+const AI_VALIDATE_METADATA_KEY = 'hazel:ai:validate';
+/**
+ * AIValidate decorator for AI-powered validation
+ *
+ * @example
+ * ```typescript
+ * @AIValidate({
+ *   provider: 'openai',
+ *   instruction: 'Validate if this is a professional email'
+ * })
+ * export class ContactDto {
+ *   @IsEmail()
+ *   email: string;
+ * }
+ * ```
+ */
+function AIValidate(options) {
+    return (target) => {
+        const defaults = {
+            model: 'gpt-3.5-turbo',
+            failOnInvalid: true,
+            ...options,
+        };
+        Reflect.defineMetadata(AI_VALIDATE_METADATA_KEY, defaults, target);
+        const className = target.name || 'Unknown';
+        core_1.default.debug(`AIValidate decorator applied to ${className}`);
+    };
+}
+/**
+ * Get AI validation metadata
+ */
+function getAIValidationMetadata(target) {
+    return Reflect.getMetadata(AI_VALIDATE_METADATA_KEY, target);
+}
+/**
+ * Check if class has AI validation metadata
+ */
+function hasAIValidationMetadata(target) {
+    return Reflect.hasMetadata(AI_VALIDATE_METADATA_KEY, target);
+}
+/**
+ * AIValidateProperty decorator for property-level validation
+ *
+ * @example
+ * ```typescript
+ * export class UserDto {
+ *   @AIValidateProperty({
+ *     provider: 'openai',
+ *     instruction: 'Check if this username is appropriate'
+ *   })
+ *   username: string;
+ * }
+ * ```
+ */
+function AIValidateProperty(options) {
+    return (target, propertyKey) => {
+        const defaults = {
+            model: 'gpt-3.5-turbo',
+            failOnInvalid: true,
+            ...options,
+        };
+        Reflect.defineMetadata(`${AI_VALIDATE_METADATA_KEY}:${String(propertyKey)}`, defaults, target);
+        core_1.default.debug(`AIValidateProperty decorator applied to ${target.constructor.name}.${String(propertyKey)}`);
+    };
+}
+/**
+ * Get AI property validation metadata
+ */
+function getAIPropertyValidationMetadata(target, propertyKey) {
+    return Reflect.getMetadata(`${AI_VALIDATE_METADATA_KEY}:${String(propertyKey)}`, target);
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @hazeljs/ai - AI integration module for HazelJS
+ */
+export { AIModule } from './ai.module';
+export { AIService } from './ai.service';
+export type { AITaskConfig, AITaskContext, AITaskResult } from './ai.types';
+export { AITask } from './ai.decorator';
+export { OpenAIProvider } from './providers/openai.provider';
+export { AnthropicProvider } from './providers/anthropic.provider';
+export { GeminiProvider } from './providers/gemini.provider';
+export { CohereProvider } from './providers/cohere.provider';
+export { OllamaProvider } from './providers/ollama.provider';
+export { AIFunction, AIPrompt, getAIFunctionMetadata, hasAIFunctionMetadata, getAIPromptMetadata, } from './decorators/ai-function.decorator';
+export { AIValidate, AIValidateProperty, getAIValidationMetadata, hasAIValidationMetadata, getAIPropertyValidationMetadata, } from './decorators/ai-validate.decorator';
+export { VectorService } from './vector/vector.service';
+export { type AIProvider, type AIModelConfig, type AIMessageRole, type AIMessage, type AICompletionRequest, type AICompletionResponse, type AIStreamChunk, type AIFunction as AIFunctionType, type AIEmbeddingRequest, type AIEmbeddingResponse, type IAIProvider, type VectorDatabase, type VectorStoreConfig, type VectorDocument, type VectorSearchRequest, type VectorSearchResult, type AIContext, type TokenUsage, type TokenLimitConfig, type AIFunctionOptions, type AIValidationOptions, } from './ai-enhanced.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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"}

package/dist/index.js

@@ -0,0 +1,38 @@
+"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.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_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/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/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;IA4DlF;;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"}