@push.rocks/smartai 0.0.14 → 0.0.19

package/dist_ts/00_commitinfo_data.d.ts

@@ -1,5 +1,5 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export declare const commitinfo: {
     name: string;

package/dist_ts/00_commitinfo_data.js

@@ -1,9 +1,9 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
     name: '@push.rocks/smartai',
-    version: '0.0.14',
+    version: '0.0.19',
     description: 'A TypeScript library for integrating and interacting with multiple AI models, offering capabilities for chat and potentially audio responses.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxxQkFBcUI7SUFDM0IsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLCtJQUErSTtDQUM3SixDQUFBIn0=

package/dist_ts/abstract.classes.multimodal.d.ts

@@ -1,27 +1,60 @@
+/**
+ * Message format for chat interactions
+ */
+export interface ChatMessage {
+    role: 'assistant' | 'user' | 'system';
+    content: string;
+}
+/**
+ * Options for chat interactions
+ */
+export interface ChatOptions {
+    systemMessage: string;
+    userMessage: string;
+    messageHistory: ChatMessage[];
+}
+/**
+ * Response format for chat interactions
+ */
+export interface ChatResponse {
+    role: 'assistant';
+    message: string;
+}
+/**
+ * Abstract base class for multi-modal AI models.
+ * Provides a common interface for different AI providers (OpenAI, Anthropic, Perplexity, Ollama)
+ */
 export declare abstract class MultiModalModel {
     /**
-     * starts the model
+     * Initializes the model and any necessary resources
+     * Should be called before using any other methods
      */
     abstract start(): Promise<void>;
     /**
-     * stops the model
+     * Cleans up any resources used by the model
+     * Should be called when the model is no longer needed
      */
     abstract stop(): Promise<void>;
-    abstract chat(optionsArg: {
-        systemMessage: string;
-        userMessage: string;
-        messageHistory: {
-            role: 'assistant' | 'user';
-            content: string;
-        }[];
-    }): Promise<{
-        role: 'assistant';
-        message: string;
-    }>;
     /**
-     * Defines a streaming interface for chat interactions.
-     * The implementation will vary based on the specific AI model.
-     * @param input
+     * Synchronous chat interaction with the model
+     * @param optionsArg Options containing system message, user message, and message history
+     * @returns Promise resolving to the assistant's response
      */
-    abstract chatStream(input: ReadableStream<string>): Promise<ReadableStream<string>>;
+    abstract chat(optionsArg: ChatOptions): Promise<ChatResponse>;
+    /**
+     * Streaming interface for chat interactions
+     * Allows for real-time responses from the model
+     * @param input Stream of user messages
+     * @returns Stream of model responses
+     */
+    abstract chatStream(input: ReadableStream<Uint8Array>): Promise<ReadableStream<string>>;
+    /**
+     * Text-to-speech conversion
+     * @param optionsArg Options containing the message to convert to speech
+     * @returns Promise resolving to a readable stream of audio data
+     * @throws Error if the provider doesn't support audio generation
+     */
+    abstract audio(optionsArg: {
+        message: string;
+    }): Promise<NodeJS.ReadableStream>;
 }

package/dist_ts/abstract.classes.multimodal.js

@@ -1,3 +1,7 @@
+/**
+ * Abstract base class for multi-modal AI models.
+ * Provides a common interface for different AI providers (OpenAI, Anthropic, Perplexity, Ollama)
+ */
 export class MultiModalModel {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QuY2xhc3Nlcy5tdWx0aW1vZGFsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvYWJzdHJhY3QuY2xhc3Nlcy5tdWx0aW1vZGFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBZ0IsZUFBZTtDQStCcEMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QuY2xhc3Nlcy5tdWx0aW1vZGFsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvYWJzdHJhY3QuY2xhc3Nlcy5tdWx0aW1vZGFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQXlCQTs7O0dBR0c7QUFDSCxNQUFNLE9BQWdCLGVBQWU7Q0FtQ3BDIn0=

package/dist_ts/plugins.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import * as path from 'path';
 export { path, };
 import * as qenv from '@push.rocks/qenv';

package/dist_ts/provider.anthropic.d.ts

@@ -1,5 +1,6 @@
 import * as plugins from './plugins.js';
 import { MultiModalModel } from './abstract.classes.multimodal.js';
+import type { ChatOptions, ChatResponse } from './abstract.classes.multimodal.js';
 export interface IAnthropicProviderOptions {
     anthropicToken: string;
 }
@@ -9,17 +10,9 @@ export declare class AnthropicProvider extends MultiModalModel {
     constructor(optionsArg: IAnthropicProviderOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
-    chatStream(input: ReadableStream<string>): Promise<ReadableStream<string>>;
-    chat(optionsArg: {
-        systemMessage: string;
-        userMessage: string;
-        messageHistory: {
-            role: 'assistant' | 'user';
-            content: string;
-        }[];
-    }): Promise<{
-        role: "assistant";
+    chatStream(input: ReadableStream<Uint8Array>): Promise<ReadableStream<string>>;
+    chat(optionsArg: ChatOptions): Promise<ChatResponse>;
+    audio(optionsArg: {
         message: string;
-    }>;
-    private audio;
+    }): Promise<NodeJS.ReadableStream>;
 }

package/dist_ts/provider.anthropic.js

@@ -13,29 +13,99 @@ export class AnthropicProvider extends MultiModalModel {
     }
     async stop() { }
     async chatStream(input) {
-        // TODO: implement for OpenAI
-        const returnStream = new ReadableStream();
-        return returnStream;
+        // Create a TextDecoder to handle incoming chunks
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let currentMessage = null;
+        // Create a TransformStream to process the input
+        const transform = new TransformStream({
+            async transform(chunk, controller) {
+                buffer += decoder.decode(chunk, { stream: true });
+                // Try to parse complete JSON messages from the buffer
+                while (true) {
+                    const newlineIndex = buffer.indexOf('\n');
+                    if (newlineIndex === -1)
+                        break;
+                    const line = buffer.slice(0, newlineIndex);
+                    buffer = buffer.slice(newlineIndex + 1);
+                    if (line.trim()) {
+                        try {
+                            const message = JSON.parse(line);
+                            currentMessage = {
+                                role: message.role || 'user',
+                                content: message.content || '',
+                            };
+                        }
+                        catch (e) {
+                            console.error('Failed to parse message:', e);
+                        }
+                    }
+                }
+                // If we have a complete message, send it to Anthropic
+                if (currentMessage) {
+                    const stream = await this.anthropicApiClient.messages.create({
+                        model: 'claude-3-opus-20240229',
+                        messages: [{ role: currentMessage.role, content: currentMessage.content }],
+                        system: '',
+                        stream: true,
+                        max_tokens: 4000,
+                    });
+                    // Process each chunk from Anthropic
+                    for await (const chunk of stream) {
+                        const content = chunk.delta?.text;
+                        if (content) {
+                            controller.enqueue(content);
+                        }
+                    }
+                    currentMessage = null;
+                }
+            },
+            flush(controller) {
+                if (buffer) {
+                    try {
+                        const message = JSON.parse(buffer);
+                        controller.enqueue(message.content || '');
+                    }
+                    catch (e) {
+                        console.error('Failed to parse remaining buffer:', e);
+                    }
+                }
+            }
+        });
+        // Connect the input to our transform stream
+        return input.pipeThrough(transform);
     }
     // Implementing the synchronous chat interaction
     async chat(optionsArg) {
+        // Convert message history to Anthropic format
+        const messages = optionsArg.messageHistory.map(msg => ({
+            role: msg.role === 'assistant' ? 'assistant' : 'user',
+            content: msg.content
+        }));
         const result = await this.anthropicApiClient.messages.create({
             model: 'claude-3-opus-20240229',
             system: optionsArg.systemMessage,
             messages: [
-                ...optionsArg.messageHistory,
-                { role: 'user', content: optionsArg.userMessage },
+                ...messages,
+                { role: 'user', content: optionsArg.userMessage }
             ],
             max_tokens: 4000,
         });
+        // Extract text content from the response
+        let message = '';
+        for (const block of result.content) {
+            if ('text' in block) {
+                message += block.text;
+            }
+        }
         return {
-            role: result.role,
-            message: result.content.join('\n'),
+            role: 'assistant',
+            message,
         };
     }
-    async audio(messageArg) {
+    async audio(optionsArg) {
         // Anthropic does not provide an audio API, so this method is not implemented.
         throw new Error('Audio generation is not yet supported by Anthropic.');
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXIuYW50aHJvcGljLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvcHJvdmlkZXIuYW50aHJvcGljLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBQ3hDLE9BQU8sS0FBSyxLQUFLLE1BQU0sWUFBWSxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQU1uRSxNQUFNLE9BQU8saUJBQWtCLFNBQVEsZUFBZTtJQUlwRCxZQUFZLFVBQXFDO1FBQy9DLEtBQUssRUFBRSxDQUFDO1FBQ1IsSUFBSSxDQUFDLE9BQU8sR0FBRyxVQUFVLENBQUEsQ0FBQyw2QkFBNkI7SUFDekQsQ0FBQztJQUVELEtBQUssQ0FBQyxLQUFLO1FBQ1QsSUFBSSxDQUFDLGtCQUFrQixHQUFHLElBQUksT0FBTyxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUM7WUFDdEQsTUFBTSxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsY0FBYztTQUNwQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQsS0FBSyxDQUFDLElBQUksS0FBSSxDQUFDO0lBRVIsS0FBSyxDQUFDLFVBQVUsQ0FBQyxLQUE2QjtRQUNuRCw2QkFBNkI7UUFFN0IsTUFBTSxZQUFZLEdBQUcsSUFBSSxjQUFjLEVBQUUsQ0FBQztRQUMxQyxPQUFPLFlBQVksQ0FBQztJQUN0QixDQUFDO0lBRUQsZ0RBQWdEO0lBQ3pDLEtBQUssQ0FBQyxJQUFJLENBQUMsVUFPakI7UUFDQyxNQUFNLE1BQU0sR0FBRyxNQUFNLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDO1lBQzNELEtBQUssRUFBRSx3QkFBd0I7WUFDL0IsTUFBTSxFQUFFLFVBQVUsQ0FBQyxhQUFhO1lBQ2hDLFFBQVEsRUFBRTtnQkFDUixHQUFHLFVBQVUsQ0FBQyxjQUFjO2dCQUM1QixFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLFVBQVUsQ0FBQyxXQUFXLEVBQUU7YUFDbEQ7WUFDRCxVQUFVLEVBQUUsSUFBSTtTQUNqQixDQUFDLENBQUM7UUFFSCxPQUFPO1lBQ0wsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFtQjtZQUNoQyxPQUFPLEVBQUUsTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDO1NBQ25DLENBQUM7SUFDSixDQUFDO0lBRU8sS0FBSyxDQUFDLEtBQUssQ0FBQyxVQUFrQjtRQUNwQyw4RUFBOEU7UUFDOUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxxREFBcUQsQ0FBQyxDQUFDO0lBQ3pFLENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/provider.groq.d.ts

@@ -0,0 +1,18 @@
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+import type { ChatOptions, ChatResponse } from './abstract.classes.multimodal.js';
+export interface IGroqProviderOptions {
+    groqToken: string;
+    model?: string;
+}
+export declare class GroqProvider extends MultiModalModel {
+    private options;
+    private baseUrl;
+    constructor(optionsArg: IGroqProviderOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    chatStream(input: ReadableStream<Uint8Array>): Promise<ReadableStream<string>>;
+    chat(optionsArg: ChatOptions): Promise<ChatResponse>;
+    audio(optionsArg: {
+        message: string;
+    }): Promise<NodeJS.ReadableStream>;
+}

package/dist_ts/provider.groq.js

@@ -0,0 +1,157 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+export class GroqProvider extends MultiModalModel {
+    constructor(optionsArg) {
+        super();
+        this.baseUrl = 'https://api.groq.com/v1';
+        this.options = {
+            ...optionsArg,
+            model: optionsArg.model || 'llama-3.3-70b-versatile', // Default model
+        };
+    }
+    async start() { }
+    async stop() { }
+    async chatStream(input) {
+        // Create a TextDecoder to handle incoming chunks
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let currentMessage = null;
+        // Create a TransformStream to process the input
+        const transform = new TransformStream({
+            async transform(chunk, controller) {
+                buffer += decoder.decode(chunk, { stream: true });
+                // Try to parse complete JSON messages from the buffer
+                while (true) {
+                    const newlineIndex = buffer.indexOf('\n');
+                    if (newlineIndex === -1)
+                        break;
+                    const line = buffer.slice(0, newlineIndex);
+                    buffer = buffer.slice(newlineIndex + 1);
+                    if (line.trim()) {
+                        try {
+                            const message = JSON.parse(line);
+                            currentMessage = {
+                                role: message.role || 'user',
+                                content: message.content || '',
+                            };
+                        }
+                        catch (e) {
+                            console.error('Failed to parse message:', e);
+                        }
+                    }
+                }
+                // If we have a complete message, send it to Groq
+                if (currentMessage) {
+                    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+                        method: 'POST',
+                        headers: {
+                            'Authorization': `Bearer ${this.options.groqToken}`,
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({
+                            model: this.options.model,
+                            messages: [{ role: currentMessage.role, content: currentMessage.content }],
+                            stream: true,
+                        }),
+                    });
+                    // Process each chunk from Groq
+                    const reader = response.body?.getReader();
+                    if (reader) {
+                        try {
+                            while (true) {
+                                const { done, value } = await reader.read();
+                                if (done)
+                                    break;
+                                const chunk = new TextDecoder().decode(value);
+                                const lines = chunk.split('\n');
+                                for (const line of lines) {
+                                    if (line.startsWith('data: ')) {
+                                        const data = line.slice(6);
+                                        if (data === '[DONE]')
+                                            break;
+                                        try {
+                                            const parsed = JSON.parse(data);
+                                            const content = parsed.choices[0]?.delta?.content;
+                                            if (content) {
+                                                controller.enqueue(content);
+                                            }
+                                        }
+                                        catch (e) {
+                                            console.error('Failed to parse SSE data:', e);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        finally {
+                            reader.releaseLock();
+                        }
+                    }
+                    currentMessage = null;
+                }
+            },
+            flush(controller) {
+                if (buffer) {
+                    try {
+                        const message = JSON.parse(buffer);
+                        controller.enqueue(message.content || '');
+                    }
+                    catch (e) {
+                        console.error('Failed to parse remaining buffer:', e);
+                    }
+                }
+            }
+        });
+        // Connect the input to our transform stream
+        return input.pipeThrough(transform);
+    }
+    // Implementing the synchronous chat interaction
+    async chat(optionsArg) {
+        const messages = [
+            // System message
+            {
+                role: 'system',
+                content: optionsArg.systemMessage,
+            },
+            // Message history
+            ...optionsArg.messageHistory.map(msg => ({
+                role: msg.role,
+                content: msg.content,
+            })),
+            // User message
+            {
+                role: 'user',
+                content: optionsArg.userMessage,
+            },
+        ];
+        const response = await fetch(`${this.baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.options.groqToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this.options.model,
+                messages,
+                temperature: 0.7,
+                max_completion_tokens: 1024,
+                stream: false,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Groq API error: ${error.message || response.statusText}`);
+        }
+        const result = await response.json();
+        return {
+            role: 'assistant',
+            message: result.choices[0].message.content,
+        };
+    }
+    async audio(optionsArg) {
+        // Groq does not provide an audio API, so this method is not implemented.
+        throw new Error('Audio generation is not yet supported by Groq.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/provider.ollama.d.ts

@@ -1,2 +1,19 @@
-export declare class OllamaProvider {
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+import type { ChatOptions, ChatResponse } from './abstract.classes.multimodal.js';
+export interface IOllamaProviderOptions {
+    baseUrl?: string;
+    model?: string;
+}
+export declare class OllamaProvider extends MultiModalModel {
+    private options;
+    private baseUrl;
+    private model;
+    constructor(optionsArg?: IOllamaProviderOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    chatStream(input: ReadableStream<Uint8Array>): Promise<ReadableStream<string>>;
+    chat(optionsArg: ChatOptions): Promise<ChatResponse>;
+    audio(optionsArg: {
+        message: string;
+    }): Promise<NodeJS.ReadableStream>;
 }

package/dist_ts/provider.ollama.js

@@ -1,4 +1,147 @@
 import * as plugins from './plugins.js';
-export class OllamaProvider {
+import * as paths from './paths.js';
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+export class OllamaProvider extends MultiModalModel {
+    constructor(optionsArg = {}) {
+        super();
+        this.options = optionsArg;
+        this.baseUrl = optionsArg.baseUrl || 'http://localhost:11434';
+        this.model = optionsArg.model || 'llama2';
+    }
+    async start() {
+        // Verify Ollama is running
+        try {
+            const response = await fetch(`${this.baseUrl}/api/tags`);
+            if (!response.ok) {
+                throw new Error('Failed to connect to Ollama server');
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to Ollama server at ${this.baseUrl}: ${error.message}`);
+        }
+    }
+    async stop() { }
+    async chatStream(input) {
+        // Create a TextDecoder to handle incoming chunks
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let currentMessage = null;
+        // Create a TransformStream to process the input
+        const transform = new TransformStream({
+            async transform(chunk, controller) {
+                buffer += decoder.decode(chunk, { stream: true });
+                // Try to parse complete JSON messages from the buffer
+                while (true) {
+                    const newlineIndex = buffer.indexOf('\n');
+                    if (newlineIndex === -1)
+                        break;
+                    const line = buffer.slice(0, newlineIndex);
+                    buffer = buffer.slice(newlineIndex + 1);
+                    if (line.trim()) {
+                        try {
+                            const message = JSON.parse(line);
+                            currentMessage = {
+                                role: message.role || 'user',
+                                content: message.content || '',
+                            };
+                        }
+                        catch (e) {
+                            console.error('Failed to parse message:', e);
+                        }
+                    }
+                }
+                // If we have a complete message, send it to Ollama
+                if (currentMessage) {
+                    const response = await fetch(`${this.baseUrl}/api/chat`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({
+                            model: this.model,
+                            messages: [{ role: currentMessage.role, content: currentMessage.content }],
+                            stream: true,
+                        }),
+                    });
+                    // Process each chunk from Ollama
+                    const reader = response.body?.getReader();
+                    if (reader) {
+                        try {
+                            while (true) {
+                                const { done, value } = await reader.read();
+                                if (done)
+                                    break;
+                                const chunk = new TextDecoder().decode(value);
+                                const lines = chunk.split('\n');
+                                for (const line of lines) {
+                                    if (line.trim()) {
+                                        try {
+                                            const parsed = JSON.parse(line);
+                                            const content = parsed.message?.content;
+                                            if (content) {
+                                                controller.enqueue(content);
+                                            }
+                                        }
+                                        catch (e) {
+                                            console.error('Failed to parse Ollama response:', e);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        finally {
+                            reader.releaseLock();
+                        }
+                    }
+                    currentMessage = null;
+                }
+            },
+            flush(controller) {
+                if (buffer) {
+                    try {
+                        const message = JSON.parse(buffer);
+                        controller.enqueue(message.content || '');
+                    }
+                    catch (e) {
+                        console.error('Failed to parse remaining buffer:', e);
+                    }
+                }
+            }
+        });
+        // Connect the input to our transform stream
+        return input.pipeThrough(transform);
+    }
+    // Implementing the synchronous chat interaction
+    async chat(optionsArg) {
+        // Format messages for Ollama
+        const messages = [
+            { role: 'system', content: optionsArg.systemMessage },
+            ...optionsArg.messageHistory,
+            { role: 'user', content: optionsArg.userMessage }
+        ];
+        // Make API call to Ollama
+        const response = await fetch(`${this.baseUrl}/api/chat`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this.model,
+                messages: messages,
+                stream: false
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama API error: ${response.statusText}`);
+        }
+        const result = await response.json();
+        return {
+            role: 'assistant',
+            message: result.message.content,
+        };
+    }
+    async audio(optionsArg) {
+        throw new Error('Audio generation is not supported by Ollama.');
+    }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXIub2xsYW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvcHJvdmlkZXIub2xsYW1hLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBRXhDLE1BQU0sT0FBTyxjQUFjO0NBQUcifQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/provider.openai.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import * as plugins from './plugins.js';
 import { MultiModalModel } from './abstract.classes.multimodal.js';
 export interface IOpenaiProviderOptions {
@@ -11,7 +10,7 @@ export declare class OpenAiProvider extends MultiModalModel {
     constructor(optionsArg: IOpenaiProviderOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
-    chatStream(input: ReadableStream<string>): Promise<ReadableStream<string>>;
+    chatStream(input: ReadableStream<Uint8Array>): Promise<ReadableStream<string>>;
     chat(optionsArg: {
         systemMessage: string;
         userMessage: string;