@hazeljs/ai 0.2.0-beta.1

package/dist/ai.module.d.ts

@@ -0,0 +1,12 @@
+import { AIProvider } from './ai-enhanced.types';
+export interface AIModuleOptions {
+    defaultProvider?: AIProvider;
+    providers?: AIProvider[];
+    apiKeys?: Partial<Record<AIProvider, string>>;
+}
+export declare class AIModule {
+    private static options;
+    static register(options: AIModuleOptions): typeof AIModule;
+    static getOptions(): AIModuleOptions;
+}
+//# sourceMappingURL=ai.module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai.module.d.ts","sourceRoot":"","sources":["../src/ai.module.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD,MAAM,WAAW,eAAe;IAC9B,eAAe,CAAC,EAAE,UAAU,CAAC;IAC7B,SAAS,CAAC,EAAE,UAAU,EAAE,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;CAC/C;AAED,qBAIa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAC,OAAO,CAAuB;IAE7C,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,QAAQ;IAqB1D,MAAM,CAAC,UAAU,IAAI,eAAe;CAGrC"}

package/dist/ai.module.js

@@ -0,0 +1,44 @@
+"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 AIModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIModule = void 0;
+const core_1 = require("@hazeljs/core");
+const ai_service_1 = require("./ai.service");
+const ai_enhanced_service_1 = require("./ai-enhanced.service");
+let AIModule = AIModule_1 = class AIModule {
+    static register(options) {
+        AIModule_1.options = options;
+        // Set API keys in environment if provided (allows runtime configuration)
+        if (options.apiKeys) {
+            const keyMap = {
+                openai: 'OPENAI_API_KEY',
+                anthropic: 'ANTHROPIC_API_KEY',
+                gemini: 'GEMINI_API_KEY',
+                cohere: 'COHERE_API_KEY',
+            };
+            for (const [provider, key] of Object.entries(options.apiKeys)) {
+                if (key && keyMap[provider]) {
+                    process.env[keyMap[provider]] = key;
+                }
+            }
+        }
+        return AIModule_1;
+    }
+    static getOptions() {
+        return AIModule_1.options;
+    }
+};
+exports.AIModule = AIModule;
+AIModule.options = {};
+exports.AIModule = AIModule = AIModule_1 = __decorate([
+    (0, core_1.HazelModule)({
+        providers: [ai_service_1.AIService, ai_enhanced_service_1.AIEnhancedService],
+        exports: [ai_service_1.AIService, ai_enhanced_service_1.AIEnhancedService],
+    })
+], AIModule);

package/dist/ai.service.d.ts

@@ -0,0 +1,10 @@
+import { AITaskConfig, AITaskResult } from './ai.types';
+export declare class AIService {
+    private providers;
+    constructor();
+    private initializeProviders;
+    private formatPrompt;
+    private parseResponse;
+    executeTask(config: AITaskConfig, input: unknown): Promise<AITaskResult>;
+}
+//# sourceMappingURL=ai.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai.service.d.ts","sourceRoot":"","sources":["../src/ai.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAiB,YAAY,EAAE,MAAM,YAAY,CAAC;AAYvE,qBACa,SAAS;IACpB,OAAO,CAAC,SAAS,CAAsC;;IAOvD,OAAO,CAAC,mBAAmB;IAqL3B,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,aAAa;IAkBf,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,YAAY,CAAC;CAkC/E"}

package/dist/ai.service.js

@@ -0,0 +1,261 @@
+"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.AIService = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+const openai_1 = __importDefault(require("openai"));
+let AIService = class AIService {
+    constructor() {
+        this.providers = new Map();
+        // Initialize providers
+        this.initializeProviders();
+    }
+    initializeProviders() {
+        core_2.default.debug('Initializing AI providers');
+        // OpenAI provider
+        this.providers.set('openai', {
+            execute: async (config, input) => {
+                core_2.default.debug('OpenAI provider execute called with config:', {
+                    name: config.name,
+                    model: config.model,
+                    stream: config.stream,
+                    provider: config.provider,
+                });
+                const openai = new openai_1.default({
+                    apiKey: process.env.OPENAI_API_KEY,
+                });
+                core_2.default.debug('OpenAI client initialized');
+                if (config.stream) {
+                    try {
+                        core_2.default.debug('Creating OpenAI stream with config:', {
+                            model: config.model,
+                            temperature: config.temperature,
+                            prompt: this.formatPrompt(config, input),
+                        });
+                        const stream = await openai.chat.completions.create({
+                            model: config.model,
+                            messages: [
+                                {
+                                    role: 'system',
+                                    content: this.formatPrompt(config, input),
+                                },
+                            ],
+                            temperature: config.temperature || 0.7,
+                            max_tokens: config.maxTokens,
+                            stream: true,
+                        });
+                        core_2.default.debug('OpenAI stream created successfully');
+                        return {
+                            // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+                            stream: (async function* () {
+                                try {
+                                    core_2.default.debug('Starting to iterate over stream chunks');
+                                    for await (const chunk of stream) {
+                                        const content = chunk.choices[0]?.delta?.content;
+                                        if (content) {
+                                            core_2.default.debug('Yielding chunk:', { content });
+                                            yield content;
+                                        }
+                                    }
+                                    core_2.default.debug('Finished iterating over stream chunks');
+                                }
+                                catch (error) {
+                                    core_2.default.error('Error in OpenAI stream:', error);
+                                    throw error;
+                                }
+                            })(),
+                        };
+                    }
+                    catch (error) {
+                        core_2.default.error('Error creating OpenAI stream:', error);
+                        return { error: error instanceof Error ? error.message : 'Failed to create stream' };
+                    }
+                }
+                try {
+                    const response = await openai.chat.completions.create({
+                        model: config.model,
+                        messages: [
+                            {
+                                role: 'system',
+                                content: this.formatPrompt(config, input),
+                            },
+                        ],
+                        temperature: config.temperature || 0.7,
+                        max_tokens: config.maxTokens,
+                    });
+                    return this.parseResponse(response.choices[0].message.content, config.outputType);
+                }
+                catch (error) {
+                    core_2.default.error('Error in OpenAI request:', error);
+                    return { error: error instanceof Error ? error.message : 'Failed to get response' };
+                }
+            },
+        });
+        // Ollama provider
+        this.providers.set('ollama', {
+            execute: async (config, input) => {
+                if (config.stream) {
+                    const response = await fetch('http://localhost:11434/api/generate', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            model: config.model,
+                            prompt: this.formatPrompt(config, input),
+                            temperature: config.temperature || 0.7,
+                            max_tokens: config.maxTokens,
+                            stream: true,
+                        }),
+                    });
+                    if (!response.body) {
+                        throw new Error('No response body available for streaming');
+                    }
+                    const reader = response.body.getReader();
+                    const decoder = new TextDecoder();
+                    return {
+                        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+                        stream: (async function* () {
+                            try {
+                                while (true) {
+                                    const { done, value } = await reader.read();
+                                    if (done)
+                                        break;
+                                    const chunk = decoder.decode(value);
+                                    const lines = chunk.split('\n').filter(Boolean);
+                                    for (const line of lines) {
+                                        try {
+                                            const data = JSON.parse(line);
+                                            if (data.response) {
+                                                yield data.response;
+                                            }
+                                        }
+                                        catch {
+                                            // Skip invalid JSON lines
+                                            continue;
+                                        }
+                                    }
+                                }
+                            }
+                            finally {
+                                reader.releaseLock();
+                            }
+                        })(),
+                    };
+                }
+                const response = await fetch('http://localhost:11434/api/generate', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        model: config.model,
+                        prompt: this.formatPrompt(config, input),
+                        temperature: config.temperature || 0.7,
+                        max_tokens: config.maxTokens,
+                    }),
+                });
+                const data = (await response.json());
+                return this.parseResponse(data.response, config.outputType);
+            },
+        });
+        // Custom provider
+        this.providers.set('custom', {
+            execute: async (config, input) => {
+                if (!config.customProvider) {
+                    throw new Error('Custom provider configuration is required');
+                }
+                const { url, headers, transformRequest, transformResponse } = config.customProvider;
+                const requestBody = transformRequest ? transformRequest(input) : input;
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...headers,
+                    },
+                    body: JSON.stringify(requestBody),
+                });
+                const data = await response.json();
+                const transformedData = transformResponse ? transformResponse(data) : data;
+                return this.parseResponse(transformedData, config.outputType);
+            },
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    formatPrompt(config, input) {
+        const context = {
+            taskName: config.name,
+            description: config.prompt,
+            inputExample: 'JSON object with input data',
+            outputExample: `Expected ${config.outputType} output`,
+            input: input,
+        };
+        return config.prompt.replace(/{{(\w+)}}/g, (_, key) => {
+            return String(context[key] || '');
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    parseResponse(response, outputType) {
+        try {
+            switch (outputType) {
+                case 'json':
+                    return { data: JSON.parse(response) };
+                case 'number':
+                    return { data: Number(response) };
+                case 'boolean':
+                    return { data: response.toLowerCase() === 'true' };
+                default:
+                    return { data: response };
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return { error: `Failed to parse response: ${errorMessage}` };
+        }
+    }
+    async executeTask(config, input) {
+        try {
+            core_2.default.debug('Executing AI task:', {
+                task: config.name,
+                provider: config.provider,
+                stream: config.stream,
+                model: config.model,
+            });
+            const provider = this.providers.get(config.provider);
+            if (!provider) {
+                core_2.default.error('Provider not found:', config.provider);
+                throw new Error(`Provider ${config.provider} not supported`);
+            }
+            core_2.default.debug('Found provider, executing task');
+            const result = await provider.execute(config, input);
+            core_2.default.debug('AI task completed:', {
+                task: config.name,
+                hasStream: !!result.stream,
+                hasError: !!result.error,
+            });
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            core_2.default.error('AI task failed:', {
+                task: config.name,
+                error: errorMessage,
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            return { error: errorMessage };
+        }
+    }
+};
+exports.AIService = AIService;
+exports.AIService = AIService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], AIService);

package/dist/ai.types.d.ts

@@ -0,0 +1,30 @@
+export type LLMProvider = 'openai' | 'ollama' | 'anthropic' | 'custom';
+export interface AITaskConfig {
+    name: string;
+    prompt: string;
+    provider: LLMProvider;
+    model: string;
+    outputType: 'string' | 'json' | 'number' | 'boolean';
+    temperature?: number;
+    maxTokens?: number;
+    stream?: boolean;
+    customProvider?: {
+        url: string;
+        headers?: Record<string, string>;
+        transformRequest?: (input: unknown) => unknown;
+        transformResponse?: (response: unknown) => unknown;
+    };
+}
+export interface AITaskContext {
+    taskName: string;
+    description: string;
+    inputExample: string;
+    outputExample: string;
+    input: unknown;
+}
+export interface AITaskResult<T = unknown> {
+    data?: T;
+    error?: string;
+    stream?: AsyncIterable<string>;
+}
+//# sourceMappingURL=ai.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai.types.d.ts","sourceRoot":"","sources":["../src/ai.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,CAAC;AAEvE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;IACrD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE;QACf,GAAG,EAAE,MAAM,CAAC;QACZ,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACjC,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;QAC/C,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,OAAO,CAAC;KACpD,CAAC;CACH;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO;IACvC,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAChC"}

package/dist/ai.types.js

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

package/dist/context/context.manager.d.ts

@@ -0,0 +1,69 @@
+import { AIContext, AIMessage } from '../ai-enhanced.types';
+/**
+ * AI Context Manager
+ * Manages conversation context and token limits
+ */
+export declare class AIContextManager implements AIContext {
+    messages: AIMessage[];
+    maxTokens: number;
+    currentTokens: number;
+    private readonly TOKENS_PER_MESSAGE;
+    private readonly TOKENS_PER_NAME;
+    constructor(maxTokens?: number);
+    /**
+     * Add message to context
+     */
+    addMessage(message: AIMessage): void;
+    /**
+     * Get all messages
+     */
+    getMessages(): AIMessage[];
+    /**
+     * Clear all messages
+     */
+    clear(): void;
+    /**
+     * Trim messages to fit within token limit
+     * Keeps system messages and removes oldest user/assistant messages
+     */
+    trimToLimit(): void;
+    /**
+     * Estimate tokens for a message
+     * This is a rough estimation. For accurate counting, use tiktoken library
+     */
+    private estimateTokens;
+    /**
+     * Get context statistics
+     */
+    getStats(): {
+        messageCount: number;
+        currentTokens: number;
+        maxTokens: number;
+        utilizationPercent: number;
+    };
+    /**
+     * Set max tokens limit
+     */
+    setMaxTokens(maxTokens: number): void;
+    /**
+     * Get system messages
+     */
+    getSystemMessages(): AIMessage[];
+    /**
+     * Get conversation messages (user + assistant)
+     */
+    getConversationMessages(): AIMessage[];
+    /**
+     * Add system message
+     */
+    addSystemMessage(content: string): void;
+    /**
+     * Add user message
+     */
+    addUserMessage(content: string): void;
+    /**
+     * Add assistant message
+     */
+    addAssistantMessage(content: string): void;
+}
+//# sourceMappingURL=context.manager.d.ts.map

package/dist/context/context.manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.manager.d.ts","sourceRoot":"","sources":["../../src/context/context.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAG5D;;;GAGG;AACH,qBAAa,gBAAiB,YAAW,SAAS;IAChD,QAAQ,EAAE,SAAS,EAAE,CAAM;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAK;IAC1B,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAK;IACxC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAK;gBAEzB,SAAS,GAAE,MAAa;IAKpC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI;IAiBpC;;OAEG;IACH,WAAW,IAAI,SAAS,EAAE;IAI1B;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;;OAGG;IACH,WAAW,IAAI,IAAI;IAwCnB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAoBtB;;OAEG;IACH,QAAQ,IAAI;QACV,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,SAAS,EAAE,MAAM,CAAC;QAClB,kBAAkB,EAAE,MAAM,CAAC;KAC5B;IASD;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IASrC;;OAEG;IACH,iBAAiB,IAAI,SAAS,EAAE;IAIhC;;OAEG;IACH,uBAAuB,IAAI,SAAS,EAAE;IAItC;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAOvC;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAOrC;;OAEG;IACH,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAM3C"}

package/dist/context/context.manager.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIContextManager = void 0;
+const core_1 = __importDefault(require("@hazeljs/core"));
+/**
+ * AI Context Manager
+ * Manages conversation context and token limits
+ */
+class AIContextManager {
+    constructor(maxTokens = 4096) {
+        this.messages = [];
+        this.currentTokens = 0;
+        this.TOKENS_PER_MESSAGE = 4; // Approximate overhead per message
+        this.TOKENS_PER_NAME = 1; // Approximate overhead for name field
+        this.maxTokens = maxTokens;
+        core_1.default.debug(`AI Context Manager initialized with max tokens: ${maxTokens}`);
+    }
+    /**
+     * Add message to context
+     */
+    addMessage(message) {
+        const tokens = this.estimateTokens(message);
+        this.messages.push(message);
+        this.currentTokens += tokens;
+        core_1.default.debug(`Message added to context`, {
+            role: message.role,
+            tokens,
+            totalTokens: this.currentTokens,
+        });
+        // Auto-trim if exceeds limit
+        if (this.currentTokens > this.maxTokens) {
+            this.trimToLimit();
+        }
+    }
+    /**
+     * Get all messages
+     */
+    getMessages() {
+        return [...this.messages];
+    }
+    /**
+     * Clear all messages
+     */
+    clear() {
+        this.messages = [];
+        this.currentTokens = 0;
+        core_1.default.debug('Context cleared');
+    }
+    /**
+     * Trim messages to fit within token limit
+     * Keeps system messages and removes oldest user/assistant messages
+     */
+    trimToLimit() {
+        core_1.default.debug('Trimming context to fit token limit');
+        // Separate system messages from conversation messages
+        const systemMessages = this.messages.filter((m) => m.role === 'system');
+        const conversationMessages = this.messages.filter((m) => m.role !== 'system');
+        // Calculate tokens for system messages
+        const systemTokens = systemMessages.reduce((sum, msg) => sum + this.estimateTokens(msg), 0);
+        // Available tokens for conversation
+        const availableTokens = this.maxTokens - systemTokens;
+        // Keep most recent messages that fit
+        const keptMessages = [];
+        let conversationTokens = 0;
+        for (let i = conversationMessages.length - 1; i >= 0; i--) {
+            const msg = conversationMessages[i];
+            const tokens = this.estimateTokens(msg);
+            if (conversationTokens + tokens <= availableTokens) {
+                keptMessages.unshift(msg);
+                conversationTokens += tokens;
+            }
+            else {
+                break;
+            }
+        }
+        // Combine system messages with kept conversation messages
+        this.messages = [...systemMessages, ...keptMessages];
+        this.currentTokens = systemTokens + conversationTokens;
+        core_1.default.debug('Context trimmed', {
+            removedMessages: conversationMessages.length - keptMessages.length,
+            remainingMessages: this.messages.length,
+            currentTokens: this.currentTokens,
+        });
+    }
+    /**
+     * Estimate tokens for a message
+     * This is a rough estimation. For accurate counting, use tiktoken library
+     */
+    estimateTokens(message) {
+        let tokens = this.TOKENS_PER_MESSAGE;
+        // Add tokens for content (rough estimate: 1 token ≈ 4 characters)
+        tokens += Math.ceil(message.content.length / 4);
+        // Add tokens for name if present
+        if (message.name) {
+            tokens += this.TOKENS_PER_NAME;
+        }
+        // Add tokens for function call if present
+        if (message.functionCall) {
+            tokens += Math.ceil(message.functionCall.name.length / 4);
+            tokens += Math.ceil(message.functionCall.arguments.length / 4);
+        }
+        return tokens;
+    }
+    /**
+     * Get context statistics
+     */
+    getStats() {
+        return {
+            messageCount: this.messages.length,
+            currentTokens: this.currentTokens,
+            maxTokens: this.maxTokens,
+            utilizationPercent: Math.round((this.currentTokens / this.maxTokens) * 100),
+        };
+    }
+    /**
+     * Set max tokens limit
+     */
+    setMaxTokens(maxTokens) {
+        this.maxTokens = maxTokens;
+        core_1.default.debug(`Max tokens updated to: ${maxTokens}`);
+        if (this.currentTokens > maxTokens) {
+            this.trimToLimit();
+        }
+    }
+    /**
+     * Get system messages
+     */
+    getSystemMessages() {
+        return this.messages.filter((m) => m.role === 'system');
+    }
+    /**
+     * Get conversation messages (user + assistant)
+     */
+    getConversationMessages() {
+        return this.messages.filter((m) => m.role === 'user' || m.role === 'assistant');
+    }
+    /**
+     * Add system message
+     */
+    addSystemMessage(content) {
+        this.addMessage({
+            role: 'system',
+            content,
+        });
+    }
+    /**
+     * Add user message
+     */
+    addUserMessage(content) {
+        this.addMessage({
+            role: 'user',
+            content,
+        });
+    }
+    /**
+     * Add assistant message
+     */
+    addAssistantMessage(content) {
+        this.addMessage({
+            role: 'assistant',
+            content,
+        });
+    }
+}
+exports.AIContextManager = AIContextManager;

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

@@ -0,0 +1,42 @@
+import 'reflect-metadata';
+import { AIFunctionOptions } from '../ai-enhanced.types';
+/**
+ * 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
+ * }
+ * ```
+ */
+export declare function AIFunction(options: AIFunctionOptions): MethodDecorator;
+/**
+ * Get AI function metadata
+ */
+export declare function getAIFunctionMetadata(target: object, propertyKey: string | symbol): AIFunctionOptions | undefined;
+/**
+ * Check if method has AI function metadata
+ */
+export declare function hasAIFunctionMetadata(target: object, propertyKey: string | symbol): boolean;
+/**
+ * AIPrompt parameter decorator
+ *
+ * @example
+ * ```typescript
+ * async generateContent(@AIPrompt() prompt: string) {
+ *   // prompt parameter is marked for AI processing
+ * }
+ * ```
+ */
+export declare function AIPrompt(): ParameterDecorator;
+/**
+ * Get AI prompt parameter metadata
+ */
+export declare function getAIPromptMetadata(target: object, propertyKey: string | symbol): number[];
+//# sourceMappingURL=ai-function.decorator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai-function.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/ai-function.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAMzD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,eAAe,CAgBtE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,GAC3B,iBAAiB,GAAG,SAAS,CAE/B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAE3F;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,IAAI,kBAAkB,CAM7C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAK1F"}