@hazeljs/ai 0.2.0-alpha.1

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/context/context.manager.test.d.ts

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

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

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

package/dist/context/context.manager.test.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@hazeljs/core', () => ({
+    __esModule: true,
+    default: { info: jest.fn(), debug: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+const context_manager_1 = require("./context.manager");
+describe('AIContextManager', () => {
+    let manager;
+    beforeEach(() => {
+        manager = new context_manager_1.AIContextManager(200);
+    });
+    describe('constructor', () => {
+        it('initializes with default maxTokens', () => {
+            const m = new context_manager_1.AIContextManager();
+            expect(m.maxTokens).toBe(4096);
+            expect(m.messages).toEqual([]);
+            expect(m.currentTokens).toBe(0);
+        });
+        it('initializes with custom maxTokens', () => {
+            const m = new context_manager_1.AIContextManager(1000);
+            expect(m.maxTokens).toBe(1000);
+        });
+    });
+    describe('addMessage()', () => {
+        it('adds a user message', () => {
+            manager.addMessage({ role: 'user', content: 'hello' });
+            expect(manager.messages).toHaveLength(1);
+            expect(manager.messages[0].content).toBe('hello');
+        });
+        it('increments currentTokens', () => {
+            manager.addMessage({ role: 'user', content: 'hello' });
+            expect(manager.currentTokens).toBeGreaterThan(0);
+        });
+        it('adds message with name field', () => {
+            manager.addMessage({ role: 'user', content: 'hi', name: 'Alice' });
+            expect(manager.messages[0].name).toBe('Alice');
+        });
+        it('adds message with functionCall field', () => {
+            manager.addMessage({
+                role: 'assistant',
+                content: '',
+                functionCall: { name: 'getWeather', arguments: '{"city":"NYC"}' },
+            });
+            expect(manager.messages).toHaveLength(1);
+        });
+        it('auto-trims when content exceeds token limit', () => {
+            const tightManager = new context_manager_1.AIContextManager(10);
+            tightManager.addMessage({ role: 'user', content: 'a'.repeat(200) });
+            expect(tightManager.currentTokens).toBeLessThanOrEqual(10);
+        });
+        it('adds multiple messages', () => {
+            manager.addMessage({ role: 'user', content: 'first' });
+            manager.addMessage({ role: 'assistant', content: 'second' });
+            expect(manager.messages).toHaveLength(2);
+        });
+    });
+    describe('getMessages()', () => {
+        it('returns a shallow copy of messages', () => {
+            manager.addMessage({ role: 'user', content: 'test' });
+            const msgs = manager.getMessages();
+            msgs.push({ role: 'assistant', content: 'extra' });
+            expect(manager.messages).toHaveLength(1);
+        });
+        it('returns empty array when no messages', () => {
+            expect(manager.getMessages()).toEqual([]);
+        });
+    });
+    describe('clear()', () => {
+        it('clears all messages and resets token count', () => {
+            manager.addMessage({ role: 'user', content: 'test' });
+            manager.clear();
+            expect(manager.messages).toHaveLength(0);
+            expect(manager.currentTokens).toBe(0);
+        });
+    });
+    describe('trimToLimit()', () => {
+        it('preserves system messages', () => {
+            const tightManager = new context_manager_1.AIContextManager(50);
+            tightManager.addMessage({ role: 'system', content: 'You are a helpful assistant' });
+            tightManager.addMessage({ role: 'user', content: 'message 1 to be trimmed maybe' });
+            tightManager.addMessage({ role: 'user', content: 'message 2 to be trimmed maybe' });
+            tightManager.trimToLimit();
+            const systemMsgs = tightManager.getSystemMessages();
+            expect(systemMsgs).toHaveLength(1);
+        });
+        it('keeps most recent conversation messages', () => {
+            const tightManager = new context_manager_1.AIContextManager(30);
+            tightManager.addMessage({ role: 'user', content: 'old' });
+            tightManager.addMessage({ role: 'user', content: 'new' });
+            tightManager.trimToLimit();
+            const msgs = tightManager.getConversationMessages();
+            if (msgs.length > 0) {
+                expect(msgs[msgs.length - 1].content).toBe('new');
+            }
+        });
+        it('trims all conversation messages when system tokens fill the limit', () => {
+            const tightManager = new context_manager_1.AIContextManager(5);
+            tightManager.addMessage({ role: 'system', content: 'sys' });
+            tightManager.addMessage({ role: 'user', content: 'user msg' });
+            tightManager.trimToLimit();
+            expect(tightManager.getSystemMessages()).toHaveLength(1);
+        });
+    });
+    describe('getStats()', () => {
+        it('returns zero stats when empty', () => {
+            const stats = manager.getStats();
+            expect(stats.messageCount).toBe(0);
+            expect(stats.currentTokens).toBe(0);
+            expect(stats.maxTokens).toBe(200);
+            expect(stats.utilizationPercent).toBe(0);
+        });
+        it('returns correct utilization after adding messages', () => {
+            manager.addMessage({ role: 'user', content: 'hello world' });
+            const stats = manager.getStats();
+            expect(stats.messageCount).toBe(1);
+            expect(stats.utilizationPercent).toBeGreaterThan(0);
+        });
+    });
+    describe('setMaxTokens()', () => {
+        it('updates maxTokens', () => {
+            manager.setMaxTokens(500);
+            expect(manager.maxTokens).toBe(500);
+        });
+        it('trims when new limit is lower than current usage', () => {
+            manager.addMessage({ role: 'user', content: 'a'.repeat(200) });
+            manager.setMaxTokens(10);
+            expect(manager.currentTokens).toBeLessThanOrEqual(10);
+        });
+        it('does not trim when new limit is higher', () => {
+            manager.addMessage({ role: 'user', content: 'hello' });
+            const tokensBefore = manager.currentTokens;
+            manager.setMaxTokens(1000);
+            expect(manager.currentTokens).toBe(tokensBefore);
+        });
+    });
+    describe('getSystemMessages()', () => {
+        it('returns only system messages', () => {
+            manager.addMessage({ role: 'system', content: 'system prompt' });
+            manager.addMessage({ role: 'user', content: 'user msg' });
+            expect(manager.getSystemMessages()).toHaveLength(1);
+            expect(manager.getSystemMessages()[0].role).toBe('system');
+        });
+        it('returns empty array when no system messages', () => {
+            manager.addMessage({ role: 'user', content: 'user' });
+            expect(manager.getSystemMessages()).toHaveLength(0);
+        });
+    });
+    describe('getConversationMessages()', () => {
+        it('returns user and assistant messages only', () => {
+            manager.addMessage({ role: 'system', content: 'system' });
+            manager.addMessage({ role: 'user', content: 'user' });
+            manager.addMessage({ role: 'assistant', content: 'assistant' });
+            const conv = manager.getConversationMessages();
+            expect(conv).toHaveLength(2);
+            expect(conv.every((m) => m.role === 'user' || m.role === 'assistant')).toBe(true);
+        });
+    });
+    describe('addSystemMessage()', () => {
+        it('adds a system message', () => {
+            manager.addSystemMessage('You are helpful');
+            expect(manager.messages[0].role).toBe('system');
+            expect(manager.messages[0].content).toBe('You are helpful');
+        });
+    });
+    describe('addUserMessage()', () => {
+        it('adds a user message', () => {
+            manager.addUserMessage('What is the weather?');
+            expect(manager.messages[0].role).toBe('user');
+            expect(manager.messages[0].content).toBe('What is the weather?');
+        });
+    });
+    describe('addAssistantMessage()', () => {
+        it('adds an assistant message', () => {
+            manager.addAssistantMessage('It is sunny');
+            expect(manager.messages[0].role).toBe('assistant');
+            expect(manager.messages[0].content).toBe('It is sunny');
+        });
+    });
+});

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"}

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

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

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

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

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

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

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

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

package/dist/index.d.ts

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

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC5E,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAGxC,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EACL,UAAU,EACV,QAAQ,EACR,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,UAAU,EACV,kBAAkB,EAClB,uBAAuB,EACvB,uBAAuB,EACvB,+BAA+B,GAChC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EACL,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,UAAU,IAAI,cAAc,EACjC,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,GACzB,MAAM,qBAAqB,CAAC"}