@hazeljs/ai 0.2.0-alpha.1

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

@@ -0,0 +1,108 @@
+import { IAIProvider, AIProvider, AICompletionRequest, AICompletionResponse, AIStreamChunk, AIEmbeddingRequest, AIEmbeddingResponse, AIModelConfig } from './ai-enhanced.types';
+import { AIContextManager } from './context/context.manager';
+import { TokenTracker } from './tracking/token.tracker';
+import { CacheService } from '@hazeljs/cache';
+/**
+ * Enhanced AI Service
+ * Production-ready AI service with provider management, caching, and rate limiting
+ */
+export declare class AIEnhancedService {
+    private providers;
+    private defaultProvider;
+    private contextManager?;
+    private tokenTracker;
+    private cacheService?;
+    private retryAttempts;
+    private retryDelay;
+    constructor(tokenTracker?: TokenTracker, cacheService?: CacheService);
+    /**
+     * Initialize AI providers
+     */
+    private initializeProviders;
+    /**
+     * Register a custom provider
+     */
+    registerProvider(provider: IAIProvider): void;
+    /**
+     * Set default provider
+     */
+    setDefaultProvider(provider: AIProvider): void;
+    /**
+     * Create a context manager for conversation
+     */
+    createContext(maxTokens?: number): AIContextManager;
+    /**
+     * Get current context manager
+     */
+    getContext(): AIContextManager | undefined;
+    /**
+     * Generate completion with retry logic and caching
+     */
+    complete(request: AICompletionRequest, config?: {
+        provider?: AIProvider;
+        userId?: string;
+        cacheKey?: string;
+        cacheTTL?: number;
+    }): Promise<AICompletionResponse>;
+    /**
+     * Generate streaming completion
+     */
+    streamComplete(request: AICompletionRequest, config?: {
+        provider?: AIProvider;
+        userId?: string;
+    }): AsyncGenerator<AIStreamChunk>;
+    /**
+     * Generate embeddings
+     */
+    embed(request: AIEmbeddingRequest, config?: {
+        provider?: AIProvider;
+        userId?: string;
+        cacheKey?: string;
+        cacheTTL?: number;
+    }): Promise<AIEmbeddingResponse>;
+    /**
+     * Check if a provider is available
+     */
+    isProviderAvailable(provider: AIProvider): Promise<boolean>;
+    /**
+     * Get list of available providers
+     */
+    getAvailableProviders(): AIProvider[];
+    /**
+     * Get token usage statistics
+     */
+    getTokenStats(userId?: string, days?: number): unknown;
+    /**
+     * Configure model settings
+     */
+    configureModel(config: AIModelConfig): void;
+    /**
+     * Get provider instance
+     */
+    private getProvider;
+    /**
+     * Execute function with retry logic
+     */
+    private executeWithRetry;
+    /**
+     * Generate cache key for completion request
+     */
+    private generateCacheKey;
+    /**
+     * Generate cache key for embedding request
+     */
+    private generateEmbeddingCacheKey;
+    /**
+     * Simple string hash function
+     */
+    private hashString;
+    /**
+     * Estimate tokens for a request (rough estimation)
+     */
+    private estimateRequestTokens;
+    /**
+     * Set retry configuration
+     */
+    setRetryConfig(attempts: number, delay: number): void;
+}
+//# sourceMappingURL=ai-enhanced.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai-enhanced.service.d.ts","sourceRoot":"","sources":["../src/ai-enhanced.service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,UAAU,EACV,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACd,MAAM,qBAAqB,CAAC;AAO7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG9C;;;GAGG;AACH,qBACa,iBAAiB;IAC5B,OAAO,CAAC,SAAS,CAA2C;IAC5D,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,cAAc,CAAC,CAAmB;IAC1C,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,YAAY,CAAC,CAAe;IACpC,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,UAAU,CAAgB;gBAEtB,YAAY,CAAC,EAAE,YAAY,EAAE,YAAY,CAAC,EAAE,YAAY;IAOpE;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA6C3B;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI;IAK7C;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,IAAI;IAQ9C;;OAEG;IACH,aAAa,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,gBAAgB;IAKnD;;OAEG;IACH,UAAU,IAAI,gBAAgB,GAAG,SAAS;IAI1C;;OAEG;IACG,QAAQ,CACZ,OAAO,EAAE,mBAAmB,EAC5B,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,UAAU,CAAC;QACtB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GACA,OAAO,CAAC,oBAAoB,CAAC;IAgDhC;;OAEG;IACI,cAAc,CACnB,OAAO,EAAE,mBAAmB,EAC5B,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,UAAU,CAAC;QACtB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,GACA,cAAc,CAAC,aAAa,CAAC;IAmChC;;OAEG;IACG,KAAK,CACT,OAAO,EAAE,kBAAkB,EAC3B,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,UAAU,CAAC;QACtB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GACA,OAAO,CAAC,mBAAmB,CAAC;IAwC/B;;OAEG;IACG,mBAAmB,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC;IAQjE;;OAEG;IACH,qBAAqB,IAAI,UAAU,EAAE;IAIrC;;OAEG;IACH,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAOtD;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAU3C;;OAEG;IACH,OAAO,CAAC,WAAW;IAWnB;;OAEG;YACW,gBAAgB;IAoB9B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAQjC;;OAEG;IACH,OAAO,CAAC,UAAU;IAUlB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAe7B;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAKtD"}

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.Service)(),
+    __metadata("design:paramtypes", [token_tracker_1.TokenTracker, cache_1.CacheService])
+], AIEnhancedService);

package/dist/ai-enhanced.service.test.d.ts

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

package/dist/ai-enhanced.service.test.d.ts.map

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