@hazeljs/ai 0.2.0-alpha.1

package/dist/ai.service.js

@@ -0,0 +1,266 @@
+"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"));
+const prompts_1 = require("@hazeljs/prompts");
+require("./prompts/task.prompt");
+const task_prompt_1 = require("./prompts/task.prompt");
+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);
+            },
+        });
+    }
+    formatPrompt(config, input) {
+        const context = {
+            taskName: config.name,
+            description: config.prompt,
+            inputExample: 'JSON object with input data',
+            outputExample: `Expected ${config.outputType} output`,
+            input: input,
+        };
+        // Normalise legacy {{variable}} to {variable} and render via PromptTemplate
+        const normalizedTemplate = config.prompt.replace(/\{\{(\w+)\}\}/g, '{$1}');
+        const tpl = new prompts_1.PromptTemplate(normalizedTemplate, {
+            name: task_prompt_1.AI_TASK_FORMAT_KEY,
+        });
+        return tpl.render(context);
+    }
+    // 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.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/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"}