@hazeljs/ai 0.2.0-alpha.1

package/dist/providers/ollama.provider.test.d.ts

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

package/dist/providers/ollama.provider.test.d.ts.map

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

package/dist/providers/ollama.provider.test.js

@@ -0,0 +1,267 @@
+"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 ollama_provider_1 = require("./ollama.provider");
+describe('OllamaProvider', () => {
+    let provider;
+    let mockFetch;
+    beforeEach(() => {
+        provider = new ollama_provider_1.OllamaProvider();
+        mockFetch = jest.spyOn(global, 'fetch').mockImplementation(() => {
+            throw new Error('fetch not configured in this test');
+        });
+    });
+    afterEach(() => {
+        mockFetch.mockRestore();
+    });
+    describe('constructor', () => {
+        it('sets name to ollama', () => {
+            expect(provider.name).toBe('ollama');
+        });
+        it('accepts custom baseURL and model', () => {
+            const p = new ollama_provider_1.OllamaProvider({ baseURL: 'http://custom:11434', defaultModel: 'mistral' });
+            expect(p).toBeDefined();
+        });
+        it('uses OLLAMA_BASE_URL env var', () => {
+            process.env.OLLAMA_BASE_URL = 'http://env-host:11434';
+            const p = new ollama_provider_1.OllamaProvider();
+            expect(p).toBeDefined();
+            delete process.env.OLLAMA_BASE_URL;
+        });
+    });
+    describe('getSupportedModels()', () => {
+        it('returns list including llama2', () => {
+            const models = provider.getSupportedModels();
+            expect(models).toContain('llama2');
+            expect(models.length).toBeGreaterThan(0);
+        });
+    });
+    describe('getSupportedEmbeddingModels()', () => {
+        it('returns list including llama2', () => {
+            const models = provider.getSupportedEmbeddingModels();
+            expect(models).toContain('llama2');
+        });
+    });
+    describe('complete()', () => {
+        it('returns a completion response for user message', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    model: 'llama2',
+                    response: 'Hello world',
+                    done: true,
+                    prompt_eval_count: 10,
+                    eval_count: 20,
+                }),
+            });
+            const result = await provider.complete({
+                messages: [{ role: 'user', content: 'Say hello' }],
+                model: 'llama2',
+            });
+            expect(result.content).toBe('Hello world');
+            expect(result.role).toBe('assistant');
+            expect(result.usage?.promptTokens).toBe(10);
+            expect(result.usage?.completionTokens).toBe(20);
+            expect(result.usage?.totalTokens).toBe(30);
+            expect(result.finishReason).toBe('stop');
+        });
+        it('uses defaultModel when request has no model', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ model: 'llama2', response: 'ok', done: true }),
+            });
+            const result = await provider.complete({ messages: [{ role: 'user', content: 'hi' }] });
+            expect(result).toBeDefined();
+        });
+        it('returns "length" finishReason when not done', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ model: 'llama2', response: 'partial', done: false }),
+            });
+            const result = await provider.complete({ messages: [{ role: 'user', content: 'hi' }] });
+            expect(result.finishReason).toBe('length');
+        });
+        it('handles zero token counts gracefully', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ model: 'llama2', response: 'ok', done: true }),
+            });
+            const result = await provider.complete({ messages: [{ role: 'user', content: 'hi' }] });
+            expect(result.usage?.promptTokens).toBe(0);
+            expect(result.usage?.completionTokens).toBe(0);
+        });
+        it('transforms all message roles into prompt string', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ model: 'llama2', response: 'ok', done: true }),
+            });
+            await provider.complete({
+                messages: [
+                    { role: 'system', content: 'System prompt' },
+                    { role: 'user', content: 'User message' },
+                    { role: 'assistant', content: 'Assistant response' },
+                ],
+            });
+            const callBody = JSON.parse(mockFetch.mock.calls[0][1].body);
+            expect(callBody.prompt).toContain('System: System prompt');
+            expect(callBody.prompt).toContain('User: User message');
+            expect(callBody.prompt).toContain('Assistant: Assistant response');
+        });
+        it('passes temperature and maxTokens to request', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ model: 'llama2', response: 'ok', done: true }),
+            });
+            await provider.complete({
+                messages: [{ role: 'user', content: 'hi' }],
+                temperature: 0.5,
+                maxTokens: 100,
+                topP: 0.9,
+            });
+            const callBody = JSON.parse(mockFetch.mock.calls[0][1].body);
+            expect(callBody.temperature).toBe(0.5);
+            expect(callBody.num_predict).toBe(100);
+            expect(callBody.top_p).toBe(0.9);
+        });
+        it('throws on API error response', async () => {
+            mockFetch.mockResolvedValue({
+                ok: false,
+                status: 500,
+                text: () => Promise.resolve('Internal Server Error'),
+            });
+            await expect(provider.complete({ messages: [{ role: 'user', content: 'hi' }] })).rejects.toThrow('Ollama API error: 500');
+        });
+    });
+    describe('streamComplete()', () => {
+        it('yields stream chunks', async () => {
+            const encoder = new TextEncoder();
+            const lines = [
+                JSON.stringify({ model: 'llama2', response: 'Hello', done: false, prompt_eval_count: 5 }),
+                JSON.stringify({ model: 'llama2', response: ' world', done: true, eval_count: 10 }),
+            ];
+            let readIdx = 0;
+            const mockReader = {
+                read: jest.fn().mockImplementation(() => {
+                    if (readIdx < lines.length) {
+                        return Promise.resolve({ done: false, value: encoder.encode(lines[readIdx++] + '\n') });
+                    }
+                    return Promise.resolve({ done: true, value: undefined });
+                }),
+                releaseLock: jest.fn(),
+            };
+            mockFetch.mockResolvedValue({
+                ok: true,
+                body: { getReader: () => mockReader },
+            });
+            const results = [];
+            for await (const chunk of provider.streamComplete({
+                messages: [{ role: 'user', content: 'hi' }],
+            })) {
+                results.push(chunk);
+            }
+            expect(results.length).toBeGreaterThan(0);
+        });
+        it('skips invalid JSON lines', async () => {
+            const encoder = new TextEncoder();
+            const lines = [
+                'not-json\n',
+                JSON.stringify({ model: 'llama2', response: 'ok', done: true }) + '\n',
+            ];
+            let readIdx = 0;
+            const mockReader = {
+                read: jest.fn().mockImplementation(() => {
+                    if (readIdx < lines.length) {
+                        return Promise.resolve({ done: false, value: encoder.encode(lines[readIdx++]) });
+                    }
+                    return Promise.resolve({ done: true, value: undefined });
+                }),
+                releaseLock: jest.fn(),
+            };
+            mockFetch.mockResolvedValue({
+                ok: true,
+                body: { getReader: () => mockReader },
+            });
+            const results = [];
+            for await (const chunk of provider.streamComplete({
+                messages: [{ role: 'user', content: 'hi' }],
+            })) {
+                results.push(chunk);
+            }
+            // No error thrown; any valid chunks collected
+            expect(Array.isArray(results)).toBe(true);
+        });
+        it('throws when response is not ok', async () => {
+            mockFetch.mockResolvedValue({
+                ok: false,
+                status: 503,
+                text: () => Promise.resolve('Service Unavailable'),
+            });
+            const gen = provider.streamComplete({ messages: [{ role: 'user', content: 'hi' }] });
+            await expect(gen.next()).rejects.toThrow('Ollama API error: 503');
+        });
+        it('throws when response has no body', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                body: null,
+            });
+            const gen = provider.streamComplete({ messages: [{ role: 'user', content: 'hi' }] });
+            await expect(gen.next()).rejects.toThrow('No response body available for streaming');
+        });
+    });
+    describe('embed()', () => {
+        it('returns embeddings for string input', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ embedding: [0.1, 0.2, 0.3] }),
+            });
+            const result = await provider.embed({ input: 'hello world', model: 'llama2' });
+            expect(result.embeddings).toHaveLength(1);
+            expect(result.embeddings[0]).toEqual([0.1, 0.2, 0.3]);
+            expect(result.usage?.promptTokens).toBe(0);
+        });
+        it('uses first element when input is an array', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ embedding: [0.5, 0.6] }),
+            });
+            const result = await provider.embed({ input: ['first', 'second'] });
+            expect(result.embeddings).toHaveLength(1);
+            // Only first element used
+            const callBody = JSON.parse(mockFetch.mock.calls[0][1].body);
+            expect(callBody.prompt).toBe('first');
+        });
+        it('uses defaultModel when no model specified', async () => {
+            mockFetch.mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({ embedding: [0.1] }),
+            });
+            const result = await provider.embed({ input: 'test' });
+            expect(result.model).toBe('llama2');
+        });
+        it('throws on API error', async () => {
+            mockFetch.mockResolvedValue({
+                ok: false,
+                status: 404,
+                text: () => Promise.resolve('Not Found'),
+            });
+            await expect(provider.embed({ input: 'hello' })).rejects.toThrow('Ollama API error: 404');
+        });
+    });
+    describe('isAvailable()', () => {
+        it('returns true when API responds ok', async () => {
+            mockFetch.mockResolvedValue({ ok: true });
+            expect(await provider.isAvailable()).toBe(true);
+        });
+        it('returns false when API is down (fetch rejects)', async () => {
+            mockFetch.mockRejectedValue(new Error('Connection refused'));
+            expect(await provider.isAvailable()).toBe(false);
+        });
+        it('returns false on non-ok response', async () => {
+            mockFetch.mockResolvedValue({ ok: false });
+            expect(await provider.isAvailable()).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,57 @@
+import { IAIProvider, AIProvider, AICompletionRequest, AICompletionResponse, AIStreamChunk, AIEmbeddingRequest, AIEmbeddingResponse } from '../ai-enhanced.types';
+/**
+ * OpenAI Provider
+ * Production-ready implementation with full OpenAI API support
+ */
+export declare class OpenAIProvider implements IAIProvider {
+    readonly name: AIProvider;
+    private client;
+    private defaultModel;
+    constructor(apiKey?: string, config?: {
+        baseURL?: string;
+        defaultModel?: string;
+    });
+    /**
+     * Generate completion
+     */
+    complete(request: AICompletionRequest): Promise<AICompletionResponse>;
+    /**
+     * Generate streaming completion
+     */
+    streamComplete(request: AICompletionRequest): AsyncGenerator<AIStreamChunk>;
+    /**
+     * Generate embeddings
+     */
+    embed(request: AIEmbeddingRequest): Promise<AIEmbeddingResponse>;
+    /** Valid OpenAI TTS voices (updated to include ash, sage, coral) */
+    private static readonly TTS_VOICES;
+    /**
+     * Generate speech from text (TTS)
+     */
+    speech(input: string, options?: {
+        voice?: string;
+        model?: string;
+        format?: 'mp3' | 'opus';
+    }): Promise<Buffer>;
+    /**
+     * Check if provider is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Get supported models
+     */
+    getSupportedModels(): string[];
+    /**
+     * Get supported embedding models
+     */
+    getSupportedEmbeddingModels(): string[];
+    /**
+     * Transform messages to OpenAI format
+     */
+    private transformMessages;
+    /**
+     * Handle OpenAI errors
+     */
+    private handleError;
+}
+//# sourceMappingURL=openai.provider.d.ts.map

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

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

package/dist/providers/openai.provider.js

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

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

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

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

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