@hazeljs/ai 0.2.0-beta.1

package/dist/ai-enhanced.service.js

@@ -0,0 +1,345 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIEnhancedService = void 0;
+const core_1 = require("@hazeljs/core");
+const openai_provider_1 = require("./providers/openai.provider");
+const anthropic_provider_1 = require("./providers/anthropic.provider");
+const gemini_provider_1 = require("./providers/gemini.provider");
+const cohere_provider_1 = require("./providers/cohere.provider");
+const ollama_provider_1 = require("./providers/ollama.provider");
+const context_manager_1 = require("./context/context.manager");
+const token_tracker_1 = require("./tracking/token.tracker");
+const cache_1 = require("@hazeljs/cache");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Enhanced AI Service
+ * Production-ready AI service with provider management, caching, and rate limiting
+ */
+let AIEnhancedService = class AIEnhancedService {
+    constructor(tokenTracker, cacheService) {
+        this.providers = new Map();
+        this.defaultProvider = 'openai';
+        this.retryAttempts = 3;
+        this.retryDelay = 1000;
+        this.tokenTracker = tokenTracker || new token_tracker_1.TokenTracker();
+        this.cacheService = cacheService;
+        this.initializeProviders();
+        core_2.default.info('AI Enhanced Service initialized');
+    }
+    /**
+     * Initialize AI providers
+     */
+    initializeProviders() {
+        try {
+            // Initialize OpenAI
+            if (process.env.OPENAI_API_KEY) {
+                this.providers.set('openai', new openai_provider_1.OpenAIProvider());
+                core_2.default.info('OpenAI provider registered');
+            }
+            // Initialize Anthropic
+            if (process.env.ANTHROPIC_API_KEY) {
+                this.providers.set('anthropic', new anthropic_provider_1.AnthropicProvider());
+                core_2.default.info('Anthropic provider registered');
+            }
+            // Initialize Gemini
+            if (process.env.GEMINI_API_KEY) {
+                this.providers.set('gemini', new gemini_provider_1.GeminiProvider());
+                core_2.default.info('Gemini provider registered');
+            }
+            // Initialize Cohere
+            if (process.env.COHERE_API_KEY) {
+                this.providers.set('cohere', new cohere_provider_1.CohereProvider());
+                core_2.default.info('Cohere provider registered');
+            }
+            // Initialize Ollama (always available if Ollama server is running)
+            // Ollama doesn't require an API key, just a running server
+            const ollamaProvider = new ollama_provider_1.OllamaProvider({
+                baseURL: process.env.OLLAMA_BASE_URL,
+                defaultModel: process.env.OLLAMA_DEFAULT_MODEL,
+            });
+            this.providers.set('ollama', ollamaProvider);
+            core_2.default.info('Ollama provider registered (will check availability on first use)');
+            if (this.providers.size === 0) {
+                core_2.default.warn('No AI providers configured. Set API keys in environment variables or start Ollama server.');
+            }
+        }
+        catch (error) {
+            core_2.default.error('Error initializing AI providers:', error);
+        }
+    }
+    /**
+     * Register a custom provider
+     */
+    registerProvider(provider) {
+        this.providers.set(provider.name, provider);
+        core_2.default.info(`Custom provider registered: ${provider.name}`);
+    }
+    /**
+     * Set default provider
+     */
+    setDefaultProvider(provider) {
+        if (!this.providers.has(provider)) {
+            throw new Error(`Provider ${provider} is not registered`);
+        }
+        this.defaultProvider = provider;
+        core_2.default.info(`Default provider set to: ${provider}`);
+    }
+    /**
+     * Create a context manager for conversation
+     */
+    createContext(maxTokens) {
+        this.contextManager = new context_manager_1.AIContextManager(maxTokens);
+        return this.contextManager;
+    }
+    /**
+     * Get current context manager
+     */
+    getContext() {
+        return this.contextManager;
+    }
+    /**
+     * Generate completion with retry logic and caching
+     */
+    async complete(request, config) {
+        const provider = this.getProvider(config?.provider);
+        const cacheKey = config?.cacheKey || this.generateCacheKey(request);
+        // Check cache first
+        if (this.cacheService && config?.cacheKey) {
+            const cached = await this.cacheService.get(cacheKey);
+            if (cached) {
+                core_2.default.debug('Returning cached AI response');
+                return cached;
+            }
+        }
+        // Check rate limits
+        const estimatedTokens = this.estimateRequestTokens(request);
+        const limitCheck = await this.tokenTracker.checkLimits(config?.userId, estimatedTokens);
+        if (!limitCheck.allowed) {
+            throw new Error(`Rate limit exceeded: ${limitCheck.reason}`);
+        }
+        // Execute with retry logic
+        const response = await this.executeWithRetry(async () => {
+            return await provider.complete(request);
+        });
+        // Track token usage
+        if (response.usage) {
+            this.tokenTracker.track({
+                userId: config?.userId,
+                promptTokens: response.usage.promptTokens,
+                completionTokens: response.usage.completionTokens,
+                totalTokens: response.usage.totalTokens,
+                timestamp: Date.now(),
+            }, request.model);
+        }
+        // Cache response
+        if (this.cacheService && config?.cacheKey) {
+            await this.cacheService.set(cacheKey, response, config.cacheTTL || 3600);
+        }
+        return response;
+    }
+    /**
+     * Generate streaming completion
+     */
+    async *streamComplete(request, config) {
+        const provider = this.getProvider(config?.provider);
+        // Check rate limits
+        const estimatedTokens = this.estimateRequestTokens(request);
+        const limitCheck = await this.tokenTracker.checkLimits(config?.userId, estimatedTokens);
+        if (!limitCheck.allowed) {
+            throw new Error(`Rate limit exceeded: ${limitCheck.reason}`);
+        }
+        try {
+            for await (const chunk of provider.streamComplete(request)) {
+                yield chunk;
+                // Track final usage
+                if (chunk.done && chunk.usage) {
+                    this.tokenTracker.track({
+                        userId: config?.userId,
+                        promptTokens: chunk.usage.promptTokens,
+                        completionTokens: chunk.usage.completionTokens,
+                        totalTokens: chunk.usage.totalTokens,
+                        timestamp: Date.now(),
+                    }, request.model);
+                }
+            }
+        }
+        catch (error) {
+            core_2.default.error('Streaming completion failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Generate embeddings
+     */
+    async embed(request, config) {
+        const provider = this.getProvider(config?.provider);
+        const cacheKey = config?.cacheKey || this.generateEmbeddingCacheKey(request);
+        // Check cache first
+        if (this.cacheService && config?.cacheKey) {
+            const cached = await this.cacheService.get(cacheKey);
+            if (cached) {
+                core_2.default.debug('Returning cached embeddings');
+                return cached;
+            }
+        }
+        // Execute with retry logic
+        const response = await this.executeWithRetry(async () => {
+            return await provider.embed(request);
+        });
+        // Track token usage
+        if (response.usage) {
+            this.tokenTracker.track({
+                userId: config?.userId,
+                promptTokens: response.usage.promptTokens,
+                completionTokens: 0,
+                totalTokens: response.usage.totalTokens,
+                timestamp: Date.now(),
+            }, request.model);
+        }
+        // Cache response
+        if (this.cacheService && config?.cacheKey) {
+            await this.cacheService.set(cacheKey, response, config.cacheTTL || 86400); // 24 hours
+        }
+        return response;
+    }
+    /**
+     * Check if a provider is available
+     */
+    async isProviderAvailable(provider) {
+        const providerInstance = this.providers.get(provider);
+        if (!providerInstance) {
+            return false;
+        }
+        return await providerInstance.isAvailable();
+    }
+    /**
+     * Get list of available providers
+     */
+    getAvailableProviders() {
+        return Array.from(this.providers.keys());
+    }
+    /**
+     * Get token usage statistics
+     */
+    getTokenStats(userId, days) {
+        if (userId) {
+            return this.tokenTracker.getUserStats(userId, days);
+        }
+        return this.tokenTracker.getGlobalStats(days);
+    }
+    /**
+     * Configure model settings
+     */
+    configureModel(config) {
+        const provider = this.providers.get(config.provider);
+        if (!provider) {
+            throw new Error(`Provider ${config.provider} not found`);
+        }
+        // Provider-specific configuration would go here
+        core_2.default.info(`Model configured for provider: ${config.provider}`);
+    }
+    /**
+     * Get provider instance
+     */
+    getProvider(providerName) {
+        const name = providerName || this.defaultProvider;
+        const provider = this.providers.get(name);
+        if (!provider) {
+            throw new Error(`Provider ${name} is not registered or available`);
+        }
+        return provider;
+    }
+    /**
+     * Execute function with retry logic
+     */
+    async executeWithRetry(fn) {
+        let lastError;
+        for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error('Unknown error');
+                core_2.default.warn(`Attempt ${attempt} failed:`, lastError.message);
+                if (attempt < this.retryAttempts) {
+                    const delay = this.retryDelay * Math.pow(2, attempt - 1); // Exponential backoff
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            }
+        }
+        throw lastError || new Error('All retry attempts failed');
+    }
+    /**
+     * Generate cache key for completion request
+     */
+    generateCacheKey(request) {
+        const key = JSON.stringify({
+            messages: request.messages,
+            model: request.model,
+            temperature: request.temperature,
+            maxTokens: request.maxTokens,
+        });
+        return `ai:completion:${this.hashString(key)}`;
+    }
+    /**
+     * Generate cache key for embedding request
+     */
+    generateEmbeddingCacheKey(request) {
+        const key = JSON.stringify({
+            input: request.input,
+            model: request.model,
+        });
+        return `ai:embedding:${this.hashString(key)}`;
+    }
+    /**
+     * Simple string hash function
+     */
+    hashString(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return Math.abs(hash).toString(36);
+    }
+    /**
+     * Estimate tokens for a request (rough estimation)
+     */
+    estimateRequestTokens(request) {
+        let tokens = 0;
+        for (const message of request.messages) {
+            // Rough estimate: 1 token ≈ 4 characters
+            tokens += Math.ceil(message.content.length / 4);
+            tokens += 4; // Message overhead
+        }
+        // Add estimated completion tokens
+        tokens += request.maxTokens || 1000;
+        return tokens;
+    }
+    /**
+     * Set retry configuration
+     */
+    setRetryConfig(attempts, delay) {
+        this.retryAttempts = attempts;
+        this.retryDelay = delay;
+        core_2.default.info(`Retry config updated: ${attempts} attempts, ${delay}ms delay`);
+    }
+};
+exports.AIEnhancedService = AIEnhancedService;
+exports.AIEnhancedService = AIEnhancedService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [token_tracker_1.TokenTracker, cache_1.CacheService])
+], AIEnhancedService);

package/dist/ai-enhanced.types.d.ts

@@ -0,0 +1,269 @@
+/**
+ * AI Provider types
+ */
+export type AIProvider = 'openai' | 'anthropic' | 'gemini' | 'cohere' | 'ollama' | 'huggingface';
+/**
+ * AI model configuration
+ */
+export interface AIModelConfig {
+    /**
+     * Provider name
+     */
+    provider: AIProvider;
+    /**
+     * Model name
+     */
+    model: string;
+    /**
+     * API key
+     */
+    apiKey?: string;
+    /**
+     * Temperature (0-1)
+     */
+    temperature?: number;
+    /**
+     * Max tokens
+     */
+    maxTokens?: number;
+    /**
+     * Top P
+     */
+    topP?: number;
+    /**
+     * Enable streaming
+     */
+    streaming?: boolean;
+    /**
+     * Custom endpoint
+     */
+    endpoint?: string;
+}
+/**
+ * AI message role
+ */
+export type AIMessageRole = 'system' | 'user' | 'assistant' | 'function' | 'tool';
+/**
+ * AI message
+ */
+export interface AIToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface AIMessage {
+    role: AIMessageRole;
+    content: string;
+    name?: string;
+    toolCallId?: string;
+    functionCall?: {
+        name: string;
+        arguments: string;
+    };
+    toolCalls?: AIToolCall[];
+}
+/**
+ * AI completion request
+ */
+export interface AICompletionRequest {
+    messages: AIMessage[];
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    stream?: boolean;
+    functions?: AIFunction[];
+    functionCall?: 'auto' | 'none' | {
+        name: string;
+    };
+}
+/**
+ * AI completion response
+ */
+export interface AICompletionResponse {
+    id: string;
+    content: string;
+    role: AIMessageRole;
+    model: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    functionCall?: {
+        name: string;
+        arguments: string;
+    };
+    toolCalls?: AIToolCall[];
+    finishReason?: string;
+}
+/**
+ * AI streaming chunk
+ */
+export interface AIStreamChunk {
+    id: string;
+    content: string;
+    delta: string;
+    done: boolean;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+/**
+ * AI function definition
+ */
+export interface AIFunction {
+    name: string;
+    description: string;
+    parameters: {
+        type: 'object';
+        properties: Record<string, {
+            type: string;
+            description?: string;
+            enum?: string[];
+        }>;
+        required?: string[];
+    };
+}
+/**
+ * AI embedding request
+ */
+export interface AIEmbeddingRequest {
+    input: string | string[];
+    model?: string;
+}
+/**
+ * AI embedding response
+ */
+export interface AIEmbeddingResponse {
+    embeddings: number[][];
+    model: string;
+    usage?: {
+        promptTokens: number;
+        totalTokens: number;
+    };
+}
+/**
+ * AI provider interface
+ */
+export interface IAIProvider {
+    /**
+     * Provider name
+     */
+    readonly name: AIProvider;
+    /**
+     * 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>;
+}
+/**
+ * Vector database types
+ */
+export type VectorDatabase = 'pinecone' | 'weaviate' | 'qdrant' | 'chroma';
+/**
+ * Vector store configuration
+ */
+export interface VectorStoreConfig {
+    database: VectorDatabase;
+    apiKey?: string;
+    endpoint?: string;
+    index?: string;
+    namespace?: string;
+}
+/**
+ * Vector document
+ */
+export interface VectorDocument {
+    id: string;
+    content: string;
+    embedding?: number[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Vector search request
+ */
+export interface VectorSearchRequest {
+    query: string;
+    topK?: number;
+    filter?: Record<string, unknown>;
+    namespace?: string;
+}
+/**
+ * Vector search result
+ */
+export interface VectorSearchResult {
+    id: string;
+    content: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * AI context manager
+ */
+export interface AIContext {
+    messages: AIMessage[];
+    maxTokens: number;
+    currentTokens: number;
+    addMessage(message: AIMessage): void;
+    getMessages(): AIMessage[];
+    clear(): void;
+    trimToLimit(): void;
+}
+/**
+ * Token usage tracker
+ */
+export interface TokenUsage {
+    userId?: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cost?: number;
+    timestamp: number;
+}
+/**
+ * Token limit configuration
+ */
+export interface TokenLimitConfig {
+    maxTokensPerRequest?: number;
+    maxTokensPerDay?: number;
+    maxTokensPerMonth?: number;
+    costPerToken?: number;
+}
+/**
+ * AI function decorator options
+ */
+export interface AIFunctionOptions {
+    provider: AIProvider;
+    model: string;
+    streaming?: boolean;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+}
+/**
+ * AI validation options
+ */
+export interface AIValidationOptions {
+    provider: AIProvider;
+    model?: string;
+    instruction: string;
+    failOnInvalid?: boolean;
+}
+//# sourceMappingURL=ai-enhanced.types.d.ts.map

package/dist/ai-enhanced.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-enhanced.types.d.ts","sourceRoot":"","sources":["../src/ai-enhanced.types.ts"],"names":[],"mappings":"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"}

package/dist/ai-enhanced.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ai.decorator.d.ts

@@ -0,0 +1,4 @@
+import { AITaskConfig } from './ai.types';
+import 'reflect-metadata';
+export declare function AITask(config: AITaskConfig): MethodDecorator;
+//# sourceMappingURL=ai.decorator.d.ts.map

package/dist/ai.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.decorator.d.ts","sourceRoot":"","sources":["../src/ai.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,kBAAkB,CAAC;AAM1B,wBAAgB,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,eAAe,CA2D5D"}

package/dist/ai.decorator.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AITask = AITask;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+const AI_TASK_METADATA_KEY = 'hazel:ai-task';
+function AITask(config) {
+    return (target, propertyKey, descriptor) => {
+        // Store the AI task configuration in metadata
+        Reflect.defineMetadata(AI_TASK_METADATA_KEY, config, target, propertyKey);
+        // Replace the method with our AI-powered version
+        descriptor.value = async function (...args) {
+            try {
+                // Get the AI task configuration from metadata
+                const taskConfig = Reflect.getMetadata(AI_TASK_METADATA_KEY, target, propertyKey);
+                if (!taskConfig) {
+                    throw new Error('AI task configuration not found');
+                }
+                // Get the AI service from the container
+                const aiService = this.aiService;
+                if (!aiService) {
+                    throw new Error('AI service not found. Make sure to inject AIService in the constructor.');
+                }
+                core_1.default.debug('Executing AI task with config:', {
+                    name: taskConfig.name,
+                    stream: taskConfig.stream,
+                });
+                // Execute the AI task
+                const result = await aiService.executeTask(taskConfig, args[0]);
+                // If streaming is enabled and a stream is returned, return the stream directly
+                if (taskConfig.stream && result.stream) {
+                    core_1.default.debug('Returning stream from AI task');
+                    return result.stream;
+                }
+                // If there's an error, throw it
+                if (result.error) {
+                    core_1.default.error('AI task error:', result.error);
+                    throw new Error(result.error);
+                }
+                // For non-streaming responses, return the data
+                core_1.default.debug('Returning data from AI task:', result.data);
+                return result.data;
+            }
+            catch (error) {
+                core_1.default.error('AI task execution failed:', error);
+                if (error instanceof Error) {
+                    throw new Error(`AI task execution failed: ${error.message}`);
+                }
+                throw new Error('AI task execution failed: Unknown error');
+            }
+        };
+        return descriptor;
+    };
+}