@hazeljs/ai 0.2.0-beta.1

package/dist/providers/ollama.provider.js

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaProvider = void 0;
+const core_1 = __importDefault(require("@hazeljs/core"));
+/**
+ * Ollama Provider
+ * Production-ready implementation for local LLM support via Ollama
+ * Supports models like Llama 2, Mistral, CodeLlama, and other open-source models
+ */
+class OllamaProvider {
+    constructor(config) {
+        this.name = 'ollama';
+        this.baseURL = config?.baseURL || process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+        this.defaultModel = config?.defaultModel || 'llama2';
+        core_1.default.info(`Ollama provider initialized with base URL: ${this.baseURL}`);
+    }
+    /**
+     * Transform messages to Ollama prompt format
+     */
+    transformMessages(messages) {
+        return messages
+            .map((msg) => {
+            const role = msg.role === 'assistant' ? 'Assistant' : msg.role === 'system' ? 'System' : 'User';
+            return `${role}: ${msg.content}`;
+        })
+            .join('\n\n');
+    }
+    /**
+     * Generate completion
+     */
+    async complete(request) {
+        try {
+            const model = request.model || this.defaultModel;
+            core_1.default.debug(`Ollama completion request for model: ${model}`);
+            const prompt = this.transformMessages(request.messages);
+            const ollamaRequest = {
+                model,
+                prompt,
+                stream: false,
+                temperature: request.temperature ?? 0.7,
+                num_predict: request.maxTokens,
+                top_p: request.topP,
+            };
+            const response = await fetch(`${this.baseURL}/api/generate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(ollamaRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Ollama API error: ${response.status} ${errorText}`);
+            }
+            const data = (await response.json());
+            return {
+                id: `ollama-${Date.now()}`,
+                content: data.response,
+                role: 'assistant',
+                model: data.model,
+                usage: {
+                    promptTokens: data.prompt_eval_count || 0,
+                    completionTokens: data.eval_count || 0,
+                    totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+                },
+                finishReason: data.done ? 'stop' : 'length',
+            };
+        }
+        catch (error) {
+            core_1.default.error('Ollama completion error:', error);
+            throw error;
+        }
+    }
+    /**
+     * Generate streaming completion
+     */
+    async *streamComplete(request) {
+        try {
+            const model = request.model || this.defaultModel;
+            core_1.default.debug(`Ollama streaming completion request for model: ${model}`);
+            const prompt = this.transformMessages(request.messages);
+            const ollamaRequest = {
+                model,
+                prompt,
+                stream: true,
+                temperature: request.temperature ?? 0.7,
+                num_predict: request.maxTokens,
+                top_p: request.topP,
+            };
+            const response = await fetch(`${this.baseURL}/api/generate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(ollamaRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Ollama API error: ${response.status} ${errorText}`);
+            }
+            if (!response.body) {
+                throw new Error('No response body available for streaming');
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let fullContent = '';
+            let totalPromptTokens = 0;
+            let totalCompletionTokens = 0;
+            const chunkId = `ollama-${Date.now()}`;
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    const chunk = decoder.decode(value, { stream: true });
+                    const lines = chunk.split('\n').filter(Boolean);
+                    for (const line of lines) {
+                        try {
+                            const data = JSON.parse(line);
+                            if (data.response) {
+                                fullContent += data.response;
+                                totalPromptTokens = data.prompt_eval_count || totalPromptTokens;
+                                totalCompletionTokens = data.eval_count || totalCompletionTokens;
+                                yield {
+                                    id: chunkId,
+                                    content: fullContent,
+                                    delta: data.response,
+                                    done: data.done || false,
+                                    usage: {
+                                        promptTokens: totalPromptTokens,
+                                        completionTokens: totalCompletionTokens,
+                                        totalTokens: totalPromptTokens + totalCompletionTokens,
+                                    },
+                                };
+                            }
+                            if (data.done) {
+                                return;
+                            }
+                        }
+                        catch {
+                            // Skip invalid JSON lines
+                            continue;
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        }
+        catch (error) {
+            core_1.default.error('Ollama streaming error:', error);
+            throw error;
+        }
+    }
+    /**
+     * Generate embeddings
+     */
+    async embed(request) {
+        try {
+            const model = request.model || this.defaultModel;
+            core_1.default.debug(`Ollama embedding request for model: ${model}`);
+            const input = Array.isArray(request.input) ? request.input[0] : request.input;
+            const response = await fetch(`${this.baseURL}/api/embeddings`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model,
+                    prompt: input,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Ollama API error: ${response.status} ${errorText}`);
+            }
+            const data = (await response.json());
+            return {
+                embeddings: [data.embedding],
+                model,
+                usage: {
+                    promptTokens: 0, // Ollama doesn't provide token usage for embeddings
+                    totalTokens: 0,
+                },
+            };
+        }
+        catch (error) {
+            core_1.default.error('Ollama embedding error:', error);
+            throw error;
+        }
+    }
+    /**
+     * Check if provider is available
+     */
+    async isAvailable() {
+        try {
+            const response = await fetch(`${this.baseURL}/api/tags`, {
+                method: 'GET',
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get supported models
+     * Note: This returns common models, but Ollama supports any model you pull
+     */
+    getSupportedModels() {
+        return [
+            'llama2',
+            'llama2:13b',
+            'llama2:70b',
+            'mistral',
+            'mixtral',
+            'codellama',
+            'neural-chat',
+            'starling-lm',
+            'phi',
+            'orca-mini',
+            'vicuna',
+            'wizardcoder',
+            'wizard-vicuna',
+        ];
+    }
+    /**
+     * Get supported embedding models
+     */
+    getSupportedEmbeddingModels() {
+        return ['llama2', 'mistral', 'nomic-embed-text'];
+    }
+}
+exports.OllamaProvider = OllamaProvider;

package/dist/providers/openai.provider.d.ts

@@ -0,0 +1,47 @@
+import { IAIProvider, AIProvider, AICompletionRequest, AICompletionResponse, AIStreamChunk, AIEmbeddingRequest, AIEmbeddingResponse } from '../ai-enhanced.types';
+/**
+ * OpenAI Provider
+ * Production-ready implementation with full OpenAI API support
+ */
+export declare class OpenAIProvider implements IAIProvider {
+    readonly name: AIProvider;
+    private client;
+    private defaultModel;
+    constructor(apiKey?: string, config?: {
+        baseURL?: string;
+        defaultModel?: 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[];
+    /**
+     * Get supported embedding models
+     */
+    getSupportedEmbeddingModels(): string[];
+    /**
+     * Transform messages to OpenAI format
+     */
+    private transformMessages;
+    /**
+     * Handle OpenAI errors
+     */
+    private handleError;
+}
+//# sourceMappingURL=openai.provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"openai.provider.d.ts","sourceRoot":"","sources":["../../src/providers/openai.provider.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,UAAU,EACV,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EAEpB,MAAM,sBAAsB,CAAC;AAK9B;;;GAGG;AACH,qBAAa,cAAe,YAAW,WAAW;IAChD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAY;IACrC,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,YAAY,CAAS;gBAEjB,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE;IASjF;;OAEG;IACG,QAAQ,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IA8E3E;;OAEG;IACI,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,cAAc,CAAC,aAAa,CAAC;IA2DlF;;OAEG;IACG,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAgCtE;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAWrC;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAa9B;;OAEG;IACH,2BAA2B,IAAI,MAAM,EAAE;IAIvC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgDzB;;OAEG;IACH,OAAO,CAAC,WAAW;CAcpB"}

package/dist/providers/openai.provider.js

@@ -0,0 +1,273 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIProvider = void 0;
+const core_1 = __importDefault(require("@hazeljs/core"));
+const openai_1 = __importDefault(require("openai"));
+/**
+ * OpenAI Provider
+ * Production-ready implementation with full OpenAI API support
+ */
+class OpenAIProvider {
+    constructor(apiKey, config) {
+        this.name = 'openai';
+        this.client = new openai_1.default({
+            apiKey: apiKey || process.env.OPENAI_API_KEY,
+            baseURL: config?.baseURL,
+        });
+        this.defaultModel = config?.defaultModel || 'gpt-4-turbo-preview';
+        core_1.default.info('OpenAI provider initialized');
+    }
+    /**
+     * Generate completion
+     */
+    async complete(request) {
+        try {
+            core_1.default.debug(`OpenAI completion request for model: ${request.model || this.defaultModel}`);
+            const messages = this.transformMessages(request.messages);
+            // Build tools array from functions (modern API)
+            const tools = request.functions?.map((fn) => ({
+                type: 'function',
+                function: fn,
+            }));
+            const response = await this.client.chat.completions.create({
+                model: request.model || this.defaultModel,
+                messages,
+                temperature: request.temperature ?? 0.7,
+                max_tokens: request.maxTokens,
+                top_p: request.topP,
+                tools: tools && tools.length > 0 ? tools : undefined,
+                tool_choice: request.functionCall === 'auto' ? 'auto' : request.functionCall === 'none' ? 'none' : undefined,
+            });
+            const choice = response.choices[0];
+            if (!choice) {
+                throw new Error('No completion choice returned');
+            }
+            // Extract tool calls from the modern tool_calls response
+            // Filter to function-type calls and cast to access .function safely
+            const rawToolCalls = choice.message.tool_calls;
+            const functionCalls = rawToolCalls?.filter(tc => tc.type === 'function');
+            const firstToolCall = functionCalls?.[0];
+            const result = {
+                id: response.id,
+                content: choice.message.content || '',
+                role: 'assistant',
+                model: response.model,
+                usage: response.usage
+                    ? {
+                        promptTokens: response.usage.prompt_tokens,
+                        completionTokens: response.usage.completion_tokens,
+                        totalTokens: response.usage.total_tokens,
+                    }
+                    : undefined,
+                functionCall: firstToolCall
+                    ? {
+                        name: firstToolCall.function.name,
+                        arguments: firstToolCall.function.arguments,
+                    }
+                    : undefined,
+                toolCalls: functionCalls?.map(tc => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: {
+                        name: tc.function.name,
+                        arguments: tc.function.arguments,
+                    },
+                })),
+                finishReason: choice.finish_reason,
+            };
+            core_1.default.debug('OpenAI completion successful', {
+                tokens: result.usage?.totalTokens,
+                finishReason: result.finishReason,
+            });
+            return result;
+        }
+        catch (error) {
+            core_1.default.error('OpenAI completion failed:', error);
+            throw this.handleError(error);
+        }
+    }
+    /**
+     * Generate streaming completion
+     */
+    async *streamComplete(request) {
+        try {
+            core_1.default.debug('OpenAI streaming completion started');
+            const messages = this.transformMessages(request.messages);
+            const stream = await this.client.chat.completions.create({
+                model: request.model || this.defaultModel,
+                messages,
+                temperature: request.temperature ?? 0.7,
+                max_tokens: request.maxTokens,
+                top_p: request.topP,
+                stream: true,
+            });
+            let fullContent = '';
+            let chunkId = '';
+            for await (const chunk of stream) {
+                const delta = chunk.choices[0]?.delta;
+                const content = delta?.content || '';
+                if (content) {
+                    fullContent += content;
+                    chunkId = chunk.id;
+                    yield {
+                        id: chunk.id,
+                        content: fullContent,
+                        delta: content,
+                        done: false,
+                    };
+                }
+                // Check if stream is done
+                if (chunk.choices[0]?.finish_reason) {
+                    yield {
+                        id: chunkId,
+                        content: fullContent,
+                        delta: '',
+                        done: true,
+                        usage: chunk.usage
+                            ? {
+                                promptTokens: chunk.usage.prompt_tokens,
+                                completionTokens: chunk.usage.completion_tokens,
+                                totalTokens: chunk.usage.total_tokens,
+                            }
+                            : undefined,
+                    };
+                }
+            }
+            core_1.default.debug('OpenAI streaming completed');
+        }
+        catch (error) {
+            core_1.default.error('OpenAI streaming failed:', error);
+            throw this.handleError(error);
+        }
+    }
+    /**
+     * Generate embeddings
+     */
+    async embed(request) {
+        try {
+            core_1.default.debug('OpenAI embedding request');
+            const input = Array.isArray(request.input) ? request.input : [request.input];
+            const response = await this.client.embeddings.create({
+                model: request.model || 'text-embedding-3-small',
+                input,
+            });
+            const result = {
+                embeddings: response.data.map((item) => item.embedding),
+                model: response.model,
+                usage: {
+                    promptTokens: response.usage.prompt_tokens,
+                    totalTokens: response.usage.total_tokens,
+                },
+            };
+            core_1.default.debug('OpenAI embedding successful', {
+                count: result.embeddings.length,
+                dimensions: result.embeddings[0]?.length,
+            });
+            return result;
+        }
+        catch (error) {
+            core_1.default.error('OpenAI embedding failed:', error);
+            throw this.handleError(error);
+        }
+    }
+    /**
+     * Check if provider is available
+     */
+    async isAvailable() {
+        try {
+            // Make a minimal API call to check availability
+            await this.client.models.list();
+            return true;
+        }
+        catch (error) {
+            core_1.default.warn('OpenAI provider not available:', error);
+            return false;
+        }
+    }
+    /**
+     * Get supported models
+     */
+    getSupportedModels() {
+        return [
+            'gpt-4-turbo-preview',
+            'gpt-4-0125-preview',
+            'gpt-4-1106-preview',
+            'gpt-4',
+            'gpt-4-0613',
+            'gpt-3.5-turbo',
+            'gpt-3.5-turbo-0125',
+            'gpt-3.5-turbo-1106',
+        ];
+    }
+    /**
+     * Get supported embedding models
+     */
+    getSupportedEmbeddingModels() {
+        return ['text-embedding-3-small', 'text-embedding-3-large', 'text-embedding-ada-002'];
+    }
+    /**
+     * Transform messages to OpenAI format
+     */
+    transformMessages(messages) {
+        return messages.map((msg) => {
+            // Map legacy 'function' role to modern 'tool' role
+            if (msg.role === 'function' || msg.role === 'tool') {
+                return {
+                    role: 'tool',
+                    content: msg.content,
+                    tool_call_id: msg.toolCallId || msg.name || 'unknown',
+                };
+            }
+            if (msg.role === 'assistant' && (msg.functionCall || msg.toolCalls)) {
+                return {
+                    role: 'assistant',
+                    content: msg.content || null,
+                    tool_calls: msg.toolCalls || (msg.functionCall ? [{
+                            id: msg.functionCall.name,
+                            type: 'function',
+                            function: {
+                                name: msg.functionCall.name,
+                                arguments: msg.functionCall.arguments,
+                            },
+                        }] : undefined),
+                };
+            }
+            if (msg.role === 'system') {
+                return {
+                    role: 'system',
+                    content: msg.content,
+                };
+            }
+            if (msg.role === 'user') {
+                return {
+                    role: 'user',
+                    content: msg.content,
+                };
+            }
+            // Default to assistant
+            return {
+                role: 'assistant',
+                content: msg.content,
+            };
+        });
+    }
+    /**
+     * Handle OpenAI errors
+     */
+    handleError(error) {
+        if (error && typeof error === 'object' && 'status' in error && 'message' in error) {
+            const apiError = error;
+            const status = apiError.status ?? 'unknown';
+            const message = `OpenAI API Error (${status}): ${apiError.message ?? 'Unknown error'}`;
+            return new Error(message);
+        }
+        if (error instanceof Error) {
+            return error;
+        }
+        return new Error('Unknown OpenAI error');
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;

package/dist/tracking/token.tracker.d.ts

@@ -0,0 +1,72 @@
+import { TokenUsage, TokenLimitConfig } from '../ai-enhanced.types';
+/**
+ * Token Usage Tracker
+ * Tracks and limits token usage per user/request
+ */
+export declare class TokenTracker {
+    private usageHistory;
+    private config;
+    private userUsage;
+    private readonly TOKEN_COSTS;
+    constructor(config?: TokenLimitConfig);
+    /**
+     * Track token usage
+     */
+    track(usage: TokenUsage, model?: string): void;
+    /**
+     * Check if request is within limits
+     */
+    checkLimits(userId?: string, requestTokens?: number): Promise<{
+        allowed: boolean;
+        reason?: string;
+        usage?: {
+            today: number;
+            month: number;
+            limit: {
+                daily: number;
+                monthly: number;
+            };
+        };
+    }>;
+    /**
+     * Calculate cost for token usage
+     */
+    calculateCost(usage: TokenUsage, model: string): number;
+    /**
+     * Get usage statistics for a user
+     */
+    getUserStats(userId: string, days?: number): {
+        totalTokens: number;
+        totalCost: number;
+        requestCount: number;
+        averageTokensPerRequest: number;
+        dailyAverage: number;
+    };
+    /**
+     * Get global statistics
+     */
+    getGlobalStats(days?: number): {
+        totalTokens: number;
+        totalCost: number;
+        requestCount: number;
+        uniqueUsers: number;
+        topUsers: Array<{
+            userId: string;
+            tokens: number;
+            cost: number;
+        }>;
+    };
+    /**
+     * Clear old usage data
+     */
+    cleanup(daysToKeep?: number): void;
+    /**
+     * Export usage data
+     */
+    exportData(userId?: string): TokenUsage[];
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<TokenLimitConfig>): void;
+}
+//# sourceMappingURL=token.tracker.d.ts.map

package/dist/tracking/token.tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.tracker.d.ts","sourceRoot":"","sources":["../../src/tracking/token.tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAIpE;;;GAGG;AACH,qBACa,YAAY;IACvB,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,SAAS,CAAwC;IAGzD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAO1B;gBAEU,MAAM,CAAC,EAAE,gBAAgB;IAUrC;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAsB9C;;OAEG;IACG,WAAW,CACf,MAAM,CAAC,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE;YACN,KAAK,EAAE,MAAM,CAAC;YACd,KAAK,EAAE,MAAM,CAAC;YACd,KAAK,EAAE;gBACL,KAAK,EAAE,MAAM,CAAC;gBACd,OAAO,EAAE,MAAM,CAAC;aACjB,CAAC;SACH,CAAC;KACH,CAAC;IA2DF;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAavD;;OAEG;IACH,YAAY,CACV,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,MAAW,GAChB;QACD,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,uBAAuB,EAAE,MAAM,CAAC;QAChC,YAAY,EAAE,MAAM,CAAC;KACtB;IAiBD;;OAEG;IACH,cAAc,CAAC,IAAI,GAAE,MAAW,GAAG;QACjC,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,EAAE,KAAK,CAAC;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACnE;IAsCD;;OAEG;IACH,OAAO,CAAC,UAAU,GAAE,MAAW,GAAG,IAAI;IAmBtC;;OAEG;IACH,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE;IAOzC;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,IAAI;CAItD"}