@hazeljs/ai 0.2.0-beta.54 → 0.2.0-beta.55

package/README.md

@@ -494,4 +494,4 @@ Apache 2.0 © [HazelJS](https://hazeljs.com)
 - [Documentation](https://hazeljs.com/docs/packages/ai)
 - [GitHub](https://github.com/hazel-js/hazeljs)
 - [Issues](https://github.com/hazel-js/hazeljs/issues)
-- [Discord](https://discord.gg/hazeljs)
+- [Discord](https://discord.com/channels/1448263814238965833/1448263814859456575)

package/dist/ai-enhanced.service.js

@@ -340,6 +340,6 @@ let AIEnhancedService = class AIEnhancedService {
 };
 exports.AIEnhancedService = AIEnhancedService;
 exports.AIEnhancedService = AIEnhancedService = __decorate([
-    (0, core_1.Injectable)(),
+    (0, core_1.Service)(),
     __metadata("design:paramtypes", [token_tracker_1.TokenTracker, cache_1.CacheService])
 ], AIEnhancedService);

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

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

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

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

package/dist/ai-enhanced.test.js

@@ -0,0 +1,587 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 vector_service_1 = require("./vector/vector.service");
+const ai_function_decorator_1 = require("./decorators/ai-function.decorator");
+const ai_validate_decorator_1 = require("./decorators/ai-validate.decorator");
+// Mock the providers to avoid real API calls
+jest.mock('./providers/anthropic.provider');
+jest.mock('./providers/gemini.provider');
+jest.mock('./providers/cohere.provider');
+describe('AnthropicProvider', () => {
+    let provider;
+    let mockComplete;
+    let mockStreamComplete;
+    beforeEach(() => {
+        mockComplete = jest.fn().mockResolvedValue({
+            id: 'claude-123',
+            content: 'Mock response',
+            role: 'assistant',
+            model: 'claude-3-5-sonnet-20241022',
+            usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+            finishReason: 'end_turn',
+        });
+        mockStreamComplete = jest.fn().mockImplementation(async function* () {
+            yield { id: 'claude-stream', content: 'Mock', delta: 'Mock', done: false };
+            yield {
+                id: 'claude-stream',
+                content: 'Mock stream',
+                delta: ' stream',
+                done: true,
+                usage: { promptTokens: 5, completionTokens: 2, totalTokens: 7 },
+            };
+        });
+        anthropic_provider_1.AnthropicProvider.mockImplementation(() => ({
+            complete: mockComplete,
+            streamComplete: mockStreamComplete,
+            embed: jest.fn().mockRejectedValue(new Error('Anthropic does not support embeddings')),
+            isAvailable: jest.fn().mockResolvedValue(true),
+            getSupportedModels: jest
+                .fn()
+                .mockReturnValue([
+                'claude-3-5-sonnet-20241022',
+                'claude-3-opus-20240229',
+                'claude-3-sonnet-20240229',
+                'claude-3-haiku-20240307',
+            ]),
+            name: 'anthropic',
+        }));
+        provider = new anthropic_provider_1.AnthropicProvider();
+    });
+    describe('complete', () => {
+        it('should generate completion', async () => {
+            const response = await provider.complete({
+                messages: [{ role: 'user', content: 'Hello' }],
+            });
+            expect(response).toBeDefined();
+            expect(response.id).toContain('claude-');
+            expect(response.content).toBeDefined();
+            expect(response.role).toBe('assistant');
+            expect(response.usage).toBeDefined();
+        });
+        it('should use specified model', async () => {
+            const response = await provider.complete({
+                messages: [{ role: 'user', content: 'Hello' }],
+                model: 'claude-3-sonnet-20240229',
+            });
+            expect(response.model).toBe('claude-3-5-sonnet-20241022');
+        });
+    });
+    describe('streamComplete', () => {
+        it('should stream completion', async () => {
+            const chunks = [];
+            for await (const chunk of provider.streamComplete({
+                messages: [{ role: 'user', content: 'Hello' }],
+            })) {
+                chunks.push(chunk.delta);
+                expect(chunk.id).toContain('claude-stream');
+                expect(chunk.content).toBeDefined();
+            }
+            expect(chunks.length).toBeGreaterThan(0);
+        });
+        it('should mark last chunk as done', async () => {
+            let lastChunk;
+            for await (const chunk of provider.streamComplete({
+                messages: [{ role: 'user', content: 'Hello' }],
+            })) {
+                lastChunk = chunk;
+            }
+            expect(lastChunk?.done).toBe(true);
+            expect(lastChunk?.usage).toBeDefined();
+        });
+    });
+    describe('embed', () => {
+        it('should throw error for embeddings', async () => {
+            await expect(provider.embed({ input: 'test' })).rejects.toThrow('Anthropic does not support embeddings');
+        });
+    });
+    describe('isAvailable', () => {
+        it('should check availability', async () => {
+            const available = await provider.isAvailable();
+            expect(typeof available).toBe('boolean');
+        });
+    });
+    describe('getSupportedModels', () => {
+        it('should return supported models', () => {
+            const models = provider.getSupportedModels();
+            expect(Array.isArray(models)).toBe(true);
+            expect(models).toContain('claude-3-opus-20240229');
+            expect(models).toContain('claude-3-sonnet-20240229');
+        });
+    });
+});
+describe('GeminiProvider', () => {
+    let provider;
+    let mockComplete;
+    let mockStreamComplete;
+    let mockEmbed;
+    beforeEach(() => {
+        mockComplete = jest.fn().mockResolvedValue({
+            id: 'gemini-123',
+            content: 'Mock response',
+            role: 'assistant',
+            model: 'gemini-pro',
+            usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+            finishReason: 'STOP',
+        });
+        mockStreamComplete = jest.fn().mockImplementation(async function* () {
+            yield { id: 'gemini-stream', content: 'Mock', delta: 'Mock', done: false };
+            yield { id: 'gemini-stream', content: 'Mock stream', delta: ' stream', done: true };
+        });
+        mockEmbed = jest.fn().mockImplementation((request) => {
+            const inputArray = Array.isArray(request.input) ? request.input : [request.input];
+            return Promise.resolve({
+                embeddings: inputArray.map(() => new Array(768).fill(0.1)),
+                model: 'text-embedding-004',
+                usage: { promptTokens: 10, totalTokens: 10 },
+            });
+        });
+        gemini_provider_1.GeminiProvider.mockImplementation(() => ({
+            complete: mockComplete,
+            streamComplete: mockStreamComplete,
+            embed: mockEmbed,
+            isAvailable: jest.fn().mockResolvedValue(true),
+            getSupportedModels: jest
+                .fn()
+                .mockReturnValue([
+                'gemini-pro',
+                'gemini-pro-vision',
+                'gemini-1.5-pro',
+                'gemini-1.5-flash',
+                'text-embedding-004',
+            ]),
+            name: 'gemini',
+        }));
+        provider = new gemini_provider_1.GeminiProvider();
+    });
+    describe('complete', () => {
+        it('should generate completion', async () => {
+            const response = await provider.complete({
+                messages: [{ role: 'user', content: 'Hello' }],
+            });
+            expect(response).toBeDefined();
+            expect(response.id).toContain('gemini-');
+            expect(response.content).toBeDefined();
+            expect(response.model).toBe('gemini-pro');
+        });
+    });
+    describe('streamComplete', () => {
+        it('should stream completion', async () => {
+            const chunks = [];
+            for await (const chunk of provider.streamComplete({
+                messages: [{ role: 'user', content: 'Hello' }],
+            })) {
+                chunks.push(chunk.delta);
+            }
+            expect(chunks.length).toBeGreaterThan(0);
+        });
+    });
+    describe('embed', () => {
+        it('should generate embeddings', async () => {
+            const response = await provider.embed({
+                input: 'test text',
+            });
+            expect(response).toBeDefined();
+            expect(response.embeddings).toHaveLength(1);
+            expect(response.embeddings[0]).toHaveLength(768);
+            expect(response.model).toBe('text-embedding-004');
+        });
+        it('should handle multiple inputs', async () => {
+            const response = await provider.embed({
+                input: ['text1', 'text2', 'text3'],
+            });
+            expect(response.embeddings).toHaveLength(3);
+            expect(response.usage).toBeDefined();
+        });
+    });
+    describe('getSupportedModels', () => {
+        it('should return supported models', () => {
+            const models = provider.getSupportedModels();
+            expect(models).toContain('gemini-pro');
+            expect(models).toContain('text-embedding-004');
+        });
+    });
+});
+describe('CohereProvider', () => {
+    let provider;
+    let mockComplete;
+    let mockStreamComplete;
+    let mockEmbed;
+    let mockRerank;
+    beforeEach(() => {
+        mockComplete = jest.fn().mockResolvedValue({
+            id: 'cohere-123',
+            content: 'Mock response',
+            role: 'assistant',
+            model: 'command',
+            usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+            finishReason: 'COMPLETE',
+        });
+        mockStreamComplete = jest.fn().mockImplementation(async function* () {
+            yield { id: 'cohere-stream', content: 'Mock', delta: 'Mock', done: false };
+            yield { id: 'cohere-stream', content: 'Mock stream', delta: ' stream', done: true };
+        });
+        mockEmbed = jest.fn().mockImplementation((request) => {
+            const inputArray = Array.isArray(request.input) ? request.input : [request.input];
+            return Promise.resolve({
+                embeddings: inputArray.map(() => new Array(1024).fill(0.1)),
+                model: 'embed-english-v3.0',
+                usage: { promptTokens: 10, totalTokens: 10 },
+            });
+        });
+        mockRerank = jest.fn().mockImplementation((query, documents, topN) => {
+            const results = documents.map((doc, index) => ({
+                index,
+                score: 0.9 - index * 0.1,
+                document: doc,
+            }));
+            return Promise.resolve(topN ? results.slice(0, topN) : results);
+        });
+        cohere_provider_1.CohereProvider.mockImplementation(() => ({
+            complete: mockComplete,
+            streamComplete: mockStreamComplete,
+            embed: mockEmbed,
+            rerank: mockRerank,
+            isAvailable: jest.fn().mockResolvedValue(true),
+            getSupportedModels: jest
+                .fn()
+                .mockReturnValue([
+                'command',
+                'command-light',
+                'command-r',
+                'command-r-plus',
+                'embed-english-v3.0',
+                'embed-multilingual-v3.0',
+            ]),
+            name: 'cohere',
+        }));
+        provider = new cohere_provider_1.CohereProvider();
+    });
+    describe('complete', () => {
+        it('should generate completion', async () => {
+            const response = await provider.complete({
+                messages: [{ role: 'user', content: 'Hello' }],
+            });
+            expect(response).toBeDefined();
+            expect(response.id).toContain('cohere-');
+            expect(response.content).toBeDefined();
+            expect(response.model).toBe('command');
+        });
+    });
+    describe('streamComplete', () => {
+        it('should stream completion', async () => {
+            const chunks = [];
+            for await (const chunk of provider.streamComplete({
+                messages: [{ role: 'user', content: 'Hello' }],
+            })) {
+                chunks.push(chunk.delta);
+            }
+            expect(chunks.length).toBeGreaterThan(0);
+        });
+    });
+    describe('embed', () => {
+        it('should generate embeddings', async () => {
+            const response = await provider.embed({
+                input: 'test text',
+            });
+            expect(response).toBeDefined();
+            expect(response.embeddings).toHaveLength(1);
+            expect(response.embeddings[0]).toHaveLength(1024);
+            expect(response.model).toBe('embed-english-v3.0');
+        });
+        it('should handle multiple inputs', async () => {
+            const response = await provider.embed({
+                input: ['text1', 'text2'],
+            });
+            expect(response.embeddings).toHaveLength(2);
+        });
+    });
+    describe('rerank', () => {
+        it('should rerank documents', async () => {
+            const documents = ['doc1', 'doc2', 'doc3'];
+            const results = await provider.rerank('query', documents);
+            expect(results).toHaveLength(3);
+            expect(results[0]).toHaveProperty('index');
+            expect(results[0]).toHaveProperty('score');
+            expect(results[0]).toHaveProperty('document');
+        });
+        it('should limit results with topN', async () => {
+            const documents = ['doc1', 'doc2', 'doc3', 'doc4', 'doc5'];
+            const results = await provider.rerank('query', documents, 2);
+            expect(results).toHaveLength(2);
+        });
+        it('should sort by score descending', async () => {
+            const documents = ['doc1', 'doc2', 'doc3'];
+            const results = await provider.rerank('query', documents);
+            for (let i = 0; i < results.length - 1; i++) {
+                expect(results[i].score).toBeGreaterThanOrEqual(results[i + 1].score);
+            }
+        });
+    });
+    describe('getSupportedModels', () => {
+        it('should return supported models', () => {
+            const models = provider.getSupportedModels();
+            expect(models).toContain('command');
+            expect(models).toContain('embed-english-v3.0');
+        });
+    });
+});
+describe('VectorService', () => {
+    let service;
+    beforeEach(async () => {
+        service = new vector_service_1.VectorService();
+        await service.initialize({
+            database: 'pinecone',
+            index: 'test-index',
+        });
+    });
+    afterEach(async () => {
+        await service.clear();
+    });
+    describe('upsert', () => {
+        it('should upsert documents', async () => {
+            const documents = [
+                { id: '1', content: 'Document 1' },
+                { id: '2', content: 'Document 2' },
+            ];
+            await service.upsert(documents);
+            const doc1 = await service.get('1');
+            expect(doc1).toBeDefined();
+            expect(doc1?.content).toBe('Document 1');
+        });
+        it('should generate embeddings if not provided', async () => {
+            const documents = [{ id: '1', content: 'Test' }];
+            await service.upsert(documents);
+            const doc = await service.get('1');
+            expect(doc?.embedding).toBeDefined();
+            expect(doc?.embedding?.length).toBeGreaterThan(0);
+        });
+        it('should use provided embeddings', async () => {
+            const embedding = Array.from({ length: 1536 }, () => 0.5);
+            const documents = [{ id: '1', content: 'Test', embedding }];
+            await service.upsert(documents);
+            const doc = await service.get('1');
+            expect(doc?.embedding).toEqual(embedding);
+        });
+    });
+    describe('search', () => {
+        beforeEach(async () => {
+            await service.upsert([
+                { id: '1', content: 'Machine learning basics' },
+                { id: '2', content: 'Deep learning tutorial' },
+                { id: '3', content: 'Natural language processing' },
+            ]);
+        });
+        it('should search for similar documents', async () => {
+            const results = await service.search({
+                query: 'AI and machine learning',
+                topK: 2,
+            });
+            expect(results).toHaveLength(2);
+            expect(results[0]).toHaveProperty('id');
+            expect(results[0]).toHaveProperty('content');
+            expect(results[0]).toHaveProperty('score');
+        });
+        it('should return results sorted by score', async () => {
+            const results = await service.search({
+                query: 'test query',
+                topK: 3,
+            });
+            for (let i = 0; i < results.length - 1; i++) {
+                expect(results[i].score).toBeGreaterThanOrEqual(results[i + 1].score);
+            }
+        });
+        it('should respect topK parameter', async () => {
+            const results = await service.search({
+                query: 'test',
+                topK: 1,
+            });
+            expect(results).toHaveLength(1);
+        });
+    });
+    describe('delete', () => {
+        it('should delete documents', async () => {
+            await service.upsert([
+                { id: '1', content: 'Doc 1' },
+                { id: '2', content: 'Doc 2' },
+            ]);
+            await service.delete(['1']);
+            const doc = await service.get('1');
+            expect(doc).toBeNull();
+            const doc2 = await service.get('2');
+            expect(doc2).toBeDefined();
+        });
+        it('should delete multiple documents', async () => {
+            await service.upsert([
+                { id: '1', content: 'Doc 1' },
+                { id: '2', content: 'Doc 2' },
+                { id: '3', content: 'Doc 3' },
+            ]);
+            await service.delete(['1', '2']);
+            expect(await service.get('1')).toBeNull();
+            expect(await service.get('2')).toBeNull();
+            expect(await service.get('3')).toBeDefined();
+        });
+    });
+    describe('get', () => {
+        it('should get document by ID', async () => {
+            await service.upsert([{ id: '1', content: 'Test' }]);
+            const doc = await service.get('1');
+            expect(doc).toBeDefined();
+            expect(doc?.id).toBe('1');
+            expect(doc?.content).toBe('Test');
+        });
+        it('should return null for non-existent ID', async () => {
+            const doc = await service.get('nonexistent');
+            expect(doc).toBeNull();
+        });
+    });
+    describe('clear', () => {
+        it('should clear all documents', async () => {
+            await service.upsert([
+                { id: '1', content: 'Doc 1' },
+                { id: '2', content: 'Doc 2' },
+            ]);
+            await service.clear();
+            const stats = await service.getStats();
+            expect(stats.count).toBe(0);
+        });
+    });
+    describe('getStats', () => {
+        it('should return statistics', async () => {
+            await service.upsert([
+                { id: '1', content: 'Doc 1' },
+                { id: '2', content: 'Doc 2' },
+            ]);
+            const stats = await service.getStats();
+            expect(stats.count).toBe(2);
+            expect(stats.database).toBe('pinecone');
+        });
+    });
+});
+describe('AI Decorators', () => {
+    describe('@AIFunction', () => {
+        it('should store AI function metadata', () => {
+            class TestClass {
+                testMethod() {
+                    return 'test';
+                }
+            }
+            __decorate([
+                (0, ai_function_decorator_1.AIFunction)({
+                    provider: 'openai',
+                    model: 'gpt-4',
+                    streaming: true,
+                }),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestClass.prototype, "testMethod", null);
+            const instance = new TestClass();
+            const metadata = (0, ai_function_decorator_1.getAIFunctionMetadata)(instance, 'testMethod');
+            expect(metadata).toBeDefined();
+            expect(metadata?.provider).toBe('openai');
+            expect(metadata?.model).toBe('gpt-4');
+            expect(metadata?.streaming).toBe(true);
+        });
+        it('should apply default values', () => {
+            class TestClass {
+                testMethod() {
+                    return 'test';
+                }
+            }
+            __decorate([
+                (0, ai_function_decorator_1.AIFunction)({
+                    provider: 'anthropic',
+                    model: 'claude-3-opus-20240229',
+                }),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestClass.prototype, "testMethod", null);
+            const instance = new TestClass();
+            const metadata = (0, ai_function_decorator_1.getAIFunctionMetadata)(instance, 'testMethod');
+            expect(metadata?.streaming).toBe(false);
+            expect(metadata?.temperature).toBe(0.7);
+            expect(metadata?.maxTokens).toBe(1000);
+        });
+        it('should check if method has AI function metadata', () => {
+            class TestClass {
+                decorated() { }
+                notDecorated() { }
+            }
+            __decorate([
+                (0, ai_function_decorator_1.AIFunction)({ provider: 'openai', model: 'gpt-4' }),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestClass.prototype, "decorated", null);
+            const instance = new TestClass();
+            expect((0, ai_function_decorator_1.hasAIFunctionMetadata)(instance, 'decorated')).toBe(true);
+            expect((0, ai_function_decorator_1.hasAIFunctionMetadata)(instance, 'notDecorated')).toBe(false);
+        });
+    });
+    describe('@AIPrompt', () => {
+        it('should mark parameter as prompt', () => {
+            // Decorator is applied, test passes if no errors
+            expect(true).toBe(true);
+        });
+    });
+    describe('@AIValidate', () => {
+        it('should store AI validation metadata', () => {
+            let TestDto = class TestDto {
+            };
+            TestDto = __decorate([
+                (0, ai_validate_decorator_1.AIValidate)({
+                    provider: 'openai',
+                    instruction: 'Validate email',
+                })
+            ], TestDto);
+            const metadata = (0, ai_validate_decorator_1.getAIValidationMetadata)(TestDto);
+            expect(metadata).toBeDefined();
+            expect(metadata?.provider).toBe('openai');
+            expect(metadata?.instruction).toBe('Validate email');
+        });
+        it('should apply default values', () => {
+            let TestDto = class TestDto {
+            };
+            TestDto = __decorate([
+                (0, ai_validate_decorator_1.AIValidate)({
+                    provider: 'anthropic',
+                    instruction: 'Validate',
+                })
+            ], TestDto);
+            const metadata = (0, ai_validate_decorator_1.getAIValidationMetadata)(TestDto);
+            expect(metadata?.model).toBe('gpt-3.5-turbo');
+            expect(metadata?.failOnInvalid).toBe(true);
+        });
+        it('should check if class has AI validation metadata', () => {
+            let DecoratedDto = class DecoratedDto {
+            };
+            DecoratedDto = __decorate([
+                (0, ai_validate_decorator_1.AIValidate)({ provider: 'openai', instruction: 'Test' })
+            ], DecoratedDto);
+            class NotDecoratedDto {
+            }
+            expect((0, ai_validate_decorator_1.hasAIValidationMetadata)(DecoratedDto)).toBe(true);
+            expect((0, ai_validate_decorator_1.hasAIValidationMetadata)(NotDecoratedDto)).toBe(false);
+        });
+    });
+    describe('@AIValidateProperty', () => {
+        it('should mark property for validation', () => {
+            // Decorator is applied, test passes if no errors
+            expect(true).toBe(true);
+        });
+    });
+});

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

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

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

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

package/dist/ai.decorator.test.js

@@ -0,0 +1,189 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ai_decorator_1 = require("./ai.decorator");
+const ai_service_1 = require("./ai.service");
+const core_1 = require("@hazeljs/core");
+const core_2 = require("@hazeljs/core");
+// Mock the AIService
+jest.mock('./ai.service', () => {
+    const mockAIService = jest.fn().mockImplementation(() => ({
+        executeTask: jest.fn().mockImplementation(async (config, input) => ({
+            data: `Processed: ${input}`,
+        })),
+    }));
+    return {
+        AIService: mockAIService,
+    };
+});
+describe('AITask Decorator', () => {
+    let container;
+    let mockAIService;
+    beforeEach(() => {
+        container = core_1.Container.getInstance();
+        container.clear();
+        // Create a mock instance
+        mockAIService = new ai_service_1.AIService();
+        // Register AIService with the mock instance
+        container.register(ai_service_1.AIService, mockAIService);
+    });
+    afterEach(() => {
+        container.clear();
+        jest.clearAllMocks();
+    });
+    it('should inject AIService', () => {
+        let TestClass = class TestClass {
+            constructor(aiService) {
+                this.aiService = aiService;
+            }
+            async testMethod(input) {
+                return input;
+            }
+        };
+        __decorate([
+            (0, ai_decorator_1.AITask)({
+                name: 'test-task',
+                prompt: 'Test prompt',
+                provider: 'openai',
+                model: 'gpt-3.5-turbo',
+                outputType: 'string',
+            }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [String]),
+            __metadata("design:returntype", Promise)
+        ], TestClass.prototype, "testMethod", null);
+        TestClass = __decorate([
+            (0, core_2.Injectable)(),
+            __metadata("design:paramtypes", [ai_service_1.AIService])
+        ], TestClass);
+        // Register the test class
+        container.register(TestClass, new TestClass(mockAIService));
+        const instance = container.resolve(TestClass);
+        expect(instance.aiService).toBeDefined();
+        expect(instance.aiService).toBe(mockAIService);
+    });
+    it('should work with multiple dependencies', () => {
+        let OtherService = class OtherService {
+        };
+        OtherService = __decorate([
+            (0, core_2.Injectable)()
+        ], OtherService);
+        let TestClass = class TestClass {
+            constructor(aiService, otherService) {
+                this.aiService = aiService;
+                this.otherService = otherService;
+            }
+            async testMethod(input) {
+                return input;
+            }
+        };
+        __decorate([
+            (0, ai_decorator_1.AITask)({
+                name: 'test-task',
+                prompt: 'Test prompt',
+                provider: 'openai',
+                model: 'gpt-3.5-turbo',
+                outputType: 'string',
+            }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [String]),
+            __metadata("design:returntype", Promise)
+        ], TestClass.prototype, "testMethod", null);
+        TestClass = __decorate([
+            (0, core_2.Injectable)(),
+            __metadata("design:paramtypes", [ai_service_1.AIService,
+                OtherService])
+        ], TestClass);
+        // Register both services
+        const otherService = new OtherService();
+        container.register(OtherService, otherService);
+        container.register(TestClass, new TestClass(mockAIService, otherService));
+        const instance = container.resolve(TestClass);
+        expect(instance.aiService).toBeDefined();
+        expect(instance.aiService).toBe(mockAIService);
+        expect(instance.otherService).toBeDefined();
+        expect(instance.otherService).toBe(otherService);
+    });
+    it('should throw error if AIService is not registered', async () => {
+        let TestClass = class TestClass {
+            constructor(aiService) {
+                this.aiService = aiService;
+            }
+            async testMethod(input) {
+                return input;
+            }
+        };
+        __decorate([
+            (0, ai_decorator_1.AITask)({
+                name: 'test-task',
+                prompt: 'Test prompt',
+                provider: 'openai',
+                model: 'gpt-3.5-turbo',
+                outputType: 'string',
+            }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [String]),
+            __metadata("design:returntype", Promise)
+        ], TestClass.prototype, "testMethod", null);
+        TestClass = __decorate([
+            (0, core_2.Injectable)(),
+            __metadata("design:paramtypes", [ai_service_1.AIService])
+        ], TestClass);
+        container.clear();
+        // Don't register AIService
+        const instance = new TestClass(null);
+        container.register(TestClass, instance);
+        const resolved = container.resolve(TestClass);
+        // The error should be thrown when trying to execute the decorated method
+        await expect(resolved.testMethod('test')).rejects.toThrow('AI task execution failed: AI service not found. Make sure to inject AIService in the constructor.');
+    });
+    it('should execute AI task', async () => {
+        let TestClass = class TestClass {
+            constructor(aiService) {
+                this.aiService = aiService;
+            }
+            async testMethod(input) {
+                return input;
+            }
+        };
+        __decorate([
+            (0, ai_decorator_1.AITask)({
+                name: 'test-task',
+                prompt: 'Test prompt',
+                provider: 'openai',
+                model: 'gpt-4',
+                temperature: 0.7,
+                outputType: 'string',
+            }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [String]),
+            __metadata("design:returntype", Promise)
+        ], TestClass.prototype, "testMethod", null);
+        TestClass = __decorate([
+            (0, core_2.Injectable)(),
+            __metadata("design:paramtypes", [ai_service_1.AIService])
+        ], TestClass);
+        // Register the test class with AIService
+        container.register(TestClass, new TestClass(mockAIService));
+        const instance = container.resolve(TestClass);
+        const result = await instance.testMethod('test input');
+        expect(result).toBeDefined();
+        expect(result).toBe('Processed: test input');
+        expect(mockAIService.executeTask).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'test-task',
+            provider: 'openai',
+            model: 'gpt-4',
+            temperature: 0.7,
+            prompt: 'Test prompt',
+            outputType: 'string',
+        }), 'test input');
+    });
+});

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

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

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

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

package/dist/ai.module.test.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ai_module_1 = require("./ai.module");
+const ai_service_1 = require("./ai.service");
+const core_1 = require("@hazeljs/core");
+describe('AIModule', () => {
+    it('should be defined', () => {
+        expect(ai_module_1.AIModule).toBeDefined();
+    });
+    it('should provide AIService', () => {
+        const app = new core_1.HazelApp(ai_module_1.AIModule);
+        const container = app.getContainer();
+        const aiService = container.resolve(ai_service_1.AIService);
+        expect(aiService).toBeInstanceOf(ai_service_1.AIService);
+    });
+    it('should provide AIService as singleton', () => {
+        const app = new core_1.HazelApp(ai_module_1.AIModule);
+        const container = app.getContainer();
+        const service1 = container.resolve(ai_service_1.AIService);
+        const service2 = container.resolve(ai_service_1.AIService);
+        expect(service1).toBe(service2);
+    });
+});

package/dist/ai.service.js

@@ -256,6 +256,6 @@ let AIService = class AIService {
 };
 exports.AIService = AIService;
 exports.AIService = AIService = __decorate([
-    (0, core_1.Injectable)(),
+    (0, core_1.Service)(),
     __metadata("design:paramtypes", [])
 ], AIService);

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

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

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

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

package/dist/ai.service.test.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ai_service_1 = require("./ai.service");
+// Mock OpenAI
+const mockCreate = jest.fn();
+jest.mock('openai', () => ({
+    __esModule: true,
+    default: jest.fn().mockImplementation(() => ({
+        chat: {
+            completions: {
+                create: mockCreate,
+            },
+        },
+    })),
+}));
+// Mock fetch
+global.fetch = jest.fn();
+describe('AIService', () => {
+    let service;
+    beforeEach(() => {
+        service = new ai_service_1.AIService();
+        jest.clearAllMocks();
+        mockCreate.mockReset();
+    });
+    describe('executeTask', () => {
+        const mockConfig = {
+            name: 'test-task',
+            provider: 'openai',
+            model: 'gpt-3.5-turbo',
+            prompt: 'Test prompt with {{input}}',
+            outputType: 'json',
+            temperature: 0.7,
+            maxTokens: 100,
+        };
+        const mockInput = { test: 'data' };
+        it('should execute task with OpenAI provider', async () => {
+            mockCreate.mockResolvedValueOnce({
+                choices: [
+                    {
+                        message: {
+                            content: '{"result": "test"}',
+                        },
+                    },
+                ],
+            });
+            const result = await service.executeTask(mockConfig, mockInput);
+            expect(result).toEqual({ data: { result: 'test' } });
+            expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
+                model: 'gpt-3.5-turbo',
+                messages: [
+                    expect.objectContaining({
+                        role: 'system',
+                        content: expect.stringContaining('Test prompt with'),
+                    }),
+                ],
+                temperature: 0.7,
+                max_tokens: 100,
+            }));
+        });
+        it('should execute task with Ollama provider', async () => {
+            global.fetch.mockResolvedValueOnce({
+                json: () => Promise.resolve({ response: '{"result": "test"}' }),
+            });
+            const result = await service.executeTask({
+                ...mockConfig,
+                provider: 'ollama',
+            }, mockInput);
+            expect(result).toEqual({ data: { result: 'test' } });
+            expect(global.fetch).toHaveBeenCalledWith('http://localhost:11434/api/generate', expect.objectContaining({
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: expect.stringContaining('"model":"gpt-3.5-turbo"'),
+            }));
+        });
+        it('should execute task with custom provider', async () => {
+            global.fetch.mockResolvedValueOnce({
+                json: () => Promise.resolve({ result: '{"result":"test"}' }),
+            });
+            const result = await service.executeTask({
+                ...mockConfig,
+                provider: 'custom',
+                customProvider: {
+                    url: 'http://custom-api.com',
+                    headers: { 'X-API-Key': 'test' },
+                    transformRequest: (input) => ({ transformed: input }),
+                    transformResponse: (data) => data.result,
+                },
+            }, mockInput);
+            expect(result).toEqual({ data: { result: 'test' } });
+            expect(global.fetch).toHaveBeenCalledWith('http://custom-api.com', expect.objectContaining({
+                method: 'POST',
+                headers: expect.objectContaining({
+                    'Content-Type': 'application/json',
+                    'X-API-Key': 'test',
+                }),
+                body: JSON.stringify({ transformed: mockInput }),
+            }));
+        });
+        it('should handle unsupported provider', async () => {
+            const result = await service.executeTask({
+                ...mockConfig,
+                provider: 'anthropic',
+            }, mockInput);
+            expect(result).toEqual({
+                error: 'Provider anthropic not supported',
+            });
+        });
+        it('should handle OpenAI API errors', async () => {
+            mockCreate.mockRejectedValueOnce(new Error('API Error'));
+            const result = await service.executeTask(mockConfig, mockInput);
+            expect(result).toEqual({
+                error: 'API Error',
+            });
+        });
+        it('should handle Ollama API errors', async () => {
+            global.fetch.mockRejectedValueOnce(new Error('Network Error'));
+            const result = await service.executeTask({
+                ...mockConfig,
+                provider: 'ollama',
+            }, mockInput);
+            expect(result).toEqual({
+                error: 'Network Error',
+            });
+        });
+        it('should handle custom provider errors', async () => {
+            global.fetch.mockRejectedValueOnce(new Error('Custom API Error'));
+            const result = await service.executeTask({
+                ...mockConfig,
+                provider: 'custom',
+                customProvider: {
+                    url: 'http://custom-api.com',
+                },
+            }, mockInput);
+            expect(result).toEqual({
+                error: 'Custom API Error',
+            });
+        });
+        it('should handle invalid JSON response', async () => {
+            mockCreate.mockResolvedValueOnce({
+                choices: [
+                    {
+                        message: {
+                            content: 'invalid json',
+                        },
+                    },
+                ],
+            });
+            const result = await service.executeTask(mockConfig, mockInput);
+            expect(result.error).toContain('Failed to parse response');
+        });
+        it('should handle different output types', async () => {
+            // Test number output
+            mockCreate.mockResolvedValueOnce({
+                choices: [
+                    {
+                        message: {
+                            content: '42',
+                        },
+                    },
+                ],
+            });
+            const numberResult = await service.executeTask({
+                ...mockConfig,
+                outputType: 'number',
+            }, mockInput);
+            expect(numberResult).toEqual({ data: 42 });
+            // Test boolean output
+            mockCreate.mockResolvedValueOnce({
+                choices: [
+                    {
+                        message: {
+                            content: 'true',
+                        },
+                    },
+                ],
+            });
+            const booleanResult = await service.executeTask({
+                ...mockConfig,
+                outputType: 'boolean',
+            }, mockInput);
+            expect(booleanResult).toEqual({ data: true });
+            // Test string output
+            mockCreate.mockResolvedValueOnce({
+                choices: [
+                    {
+                        message: {
+                            content: 'test string',
+                        },
+                    },
+                ],
+            });
+            const stringResult = await service.executeTask({
+                ...mockConfig,
+                outputType: 'string',
+            }, mockInput);
+            expect(stringResult).toEqual({ data: 'test string' });
+        });
+        it('should format prompt with context variables', async () => {
+            mockCreate.mockResolvedValueOnce({
+                choices: [
+                    {
+                        message: {
+                            content: '{"result": "test"}',
+                        },
+                    },
+                ],
+            });
+            const config = {
+                ...mockConfig,
+                prompt: 'Task: {{taskName}}\nInput: {{input}}\nDescription: {{description}}',
+            };
+            await service.executeTask(config, mockInput);
+            expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
+                messages: [
+                    expect.objectContaining({
+                        content: expect.stringContaining('Task: test-task'),
+                    }),
+                ],
+            }));
+        });
+    });
+});

package/dist/tracking/token.tracker.js

@@ -217,6 +217,6 @@ let TokenTracker = class TokenTracker {
 };
 exports.TokenTracker = TokenTracker;
 exports.TokenTracker = TokenTracker = __decorate([
-    (0, core_1.Injectable)(),
+    (0, core_1.Service)(),
     __metadata("design:paramtypes", [Object])
 ], TokenTracker);

package/dist/vector/vector.service.js

@@ -159,5 +159,5 @@ let VectorService = class VectorService {
 };
 exports.VectorService = VectorService;
 exports.VectorService = VectorService = __decorate([
-    (0, core_1.Injectable)()
+    (0, core_1.Service)()
 ], VectorService);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/ai",
-  "version": "0.2.0-beta.54",
+  "version": "0.2.0-beta.55",
   "description": "AI integration module for HazelJS framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -55,5 +55,5 @@
     "@hazeljs/cache": ">=0.2.0-beta.0",
     "@hazeljs/core": ">=0.2.0-beta.0"
   },
-  "gitHead": "c593ce33447cdc62d7bd2386cc2db47840292fcb"
+  "gitHead": "f2e54f346eea552595a44607999454a9e388cb9e"
 }