@push.rocks/smartai 0.0.17 → 0.1.0

package/dist_ts/provider.ollama.js

@@ -1,4 +1,212 @@
 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';
+        this.visionModel = optionsArg.visionModel || 'llava';
+    }
+    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.');
+    }
+    async vision(optionsArg) {
+        const base64Image = optionsArg.image.toString('base64');
+        const response = await fetch(`${this.baseUrl}/api/chat`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this.visionModel,
+                messages: [{
+                        role: 'user',
+                        content: optionsArg.prompt,
+                        images: [base64Image]
+                    }],
+                stream: false
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama API error: ${response.statusText}`);
+        }
+        const result = await response.json();
+        return result.message.content;
+    }
+    async document(optionsArg) {
+        // Convert PDF documents to images using SmartPDF
+        const smartpdfInstance = new plugins.smartpdf.SmartPdf();
+        let documentImageBytesArray = [];
+        for (const pdfDocument of optionsArg.pdfDocuments) {
+            const documentImageArray = await smartpdfInstance.convertPDFToPngBytes(pdfDocument);
+            documentImageBytesArray = documentImageBytesArray.concat(documentImageArray);
+        }
+        // Convert images to base64
+        const base64Images = documentImageBytesArray.map(bytes => Buffer.from(bytes).toString('base64'));
+        // Send request to Ollama with images
+        const response = await fetch(`${this.baseUrl}/api/chat`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this.visionModel,
+                messages: [
+                    { role: 'system', content: optionsArg.systemMessage },
+                    ...optionsArg.messageHistory,
+                    {
+                        role: 'user',
+                        content: optionsArg.userMessage,
+                        images: base64Images
+                    }
+                ],
+                stream: false
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama API error: ${response.statusText}`);
+        }
+        const result = await response.json();
+        return {
+            message: {
+                role: 'assistant',
+                content: result.message.content
+            }
+        };
+    }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXIub2xsYW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvcHJvdmlkZXIub2xsYW1hLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBRXhDLE1BQU0sT0FBTyxjQUFjO0NBQUcifQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.ollama.js","sourceRoot":"","sources":["../ts/provider.ollama.ts"],"names":[],"mappings":"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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;
@@ -37,4 +36,8 @@ export declare class OpenAiProvider extends MultiModalModel {
     }): Promise<{
         message: import("openai/resources/index.mjs").ChatCompletionMessage;
     }>;
+    vision(optionsArg: {
+        image: Buffer;
+        prompt: string;
+    }): Promise<string>;
 }

package/dist_ts/provider.openai.js

@@ -15,9 +15,65 @@ export class OpenAiProvider 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 OpenAI
+                if (currentMessage) {
+                    const stream = await this.openAiApiClient.chat.completions.create({
+                        model: 'gpt-4',
+                        messages: [{ role: currentMessage.role, content: currentMessage.content }],
+                        stream: true,
+                    });
+                    // Process each chunk from OpenAI
+                    for await (const chunk of stream) {
+                        const content = chunk.choices[0]?.delta?.content;
+                        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) {
@@ -88,5 +144,26 @@ export class OpenAiProvider extends MultiModalModel {
             message: result.choices[0].message,
         };
     }
+    async vision(optionsArg) {
+        const result = await this.openAiApiClient.chat.completions.create({
+            model: 'gpt-4-vision-preview',
+            messages: [
+                {
+                    role: 'user',
+                    content: [
+                        { type: 'text', text: optionsArg.prompt },
+                        {
+                            type: 'image_url',
+                            image_url: {
+                                url: `data:image/jpeg;base64,${optionsArg.image.toString('base64')}`
+                            }
+                        }
+                    ]
+                }
+            ],
+            max_tokens: 300
+        });
+        return result.choices[0].message.content || '';
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/provider.perplexity.d.ts

@@ -1,2 +1,28 @@
-export declare class PerplexityProvider {
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+import type { ChatOptions, ChatResponse, ChatMessage } from './abstract.classes.multimodal.js';
+export interface IPerplexityProviderOptions {
+    perplexityToken: string;
+}
+export declare class PerplexityProvider extends MultiModalModel {
+    private options;
+    constructor(optionsArg: IPerplexityProviderOptions);
+    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>;
+    vision(optionsArg: {
+        image: Buffer;
+        prompt: string;
+    }): Promise<string>;
+    document(optionsArg: {
+        systemMessage: string;
+        userMessage: string;
+        pdfDocuments: Uint8Array[];
+        messageHistory: ChatMessage[];
+    }): Promise<{
+        message: any;
+    }>;
 }

package/dist_ts/provider.perplexity.js

@@ -1,4 +1,144 @@
 import * as plugins from './plugins.js';
-export class PerplexityProvider {
+import * as paths from './paths.js';
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+export class PerplexityProvider extends MultiModalModel {
+    constructor(optionsArg) {
+        super();
+        this.options = optionsArg;
+    }
+    async start() {
+        // Initialize any necessary clients or resources
+    }
+    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 Perplexity
+                if (currentMessage) {
+                    const response = await fetch('https://api.perplexity.ai/chat/completions', {
+                        method: 'POST',
+                        headers: {
+                            'Authorization': `Bearer ${this.options.perplexityToken}`,
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({
+                            model: 'mixtral-8x7b-instruct',
+                            messages: [{ role: currentMessage.role, content: currentMessage.content }],
+                            stream: true,
+                        }),
+                    });
+                    // Process each chunk from Perplexity
+                    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) {
+        // Make API call to Perplexity
+        const response = await fetch('https://api.perplexity.ai/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.options.perplexityToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: 'mixtral-8x7b-instruct', // Using Mixtral model
+                messages: [
+                    { role: 'system', content: optionsArg.systemMessage },
+                    ...optionsArg.messageHistory,
+                    { role: 'user', content: optionsArg.userMessage }
+                ],
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Perplexity API error: ${response.statusText}`);
+        }
+        const result = await response.json();
+        return {
+            role: 'assistant',
+            message: result.choices[0].message.content,
+        };
+    }
+    async audio(optionsArg) {
+        throw new Error('Audio generation is not supported by Perplexity.');
+    }
+    async vision(optionsArg) {
+        throw new Error('Vision tasks are not supported by Perplexity.');
+    }
+    async document(optionsArg) {
+        throw new Error('Document processing is not supported by Perplexity.');
+    }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXIucGVycGxleGl0eS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3Byb3ZpZGVyLnBlcnBsZXhpdHkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFFeEMsTUFBTSxPQUFPLGtCQUFrQjtDQUFHIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartai",
-  "version": "0.0.17",
+  "version": "0.1.0",
   "private": false,
   "description": "A TypeScript library for integrating and interacting with multiple AI models, offering capabilities for chat and potentially audio responses.",
   "main": "dist_ts/index.js",
@@ -9,33 +9,33 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.76",
+    "@git.zone/tsbuild": "^2.1.84",
     "@git.zone/tsbundle": "^2.0.5",
-    "@git.zone/tsrun": "^1.2.46",
+    "@git.zone/tsrun": "^1.2.49",
     "@git.zone/tstest": "^1.0.90",
     "@push.rocks/qenv": "^6.0.5",
-    "@push.rocks/tapbundle": "^5.0.23",
-    "@types/node": "^20.12.12"
+    "@push.rocks/tapbundle": "^5.3.0",
+    "@types/node": "^22.5.5"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.21.0",
+    "@anthropic-ai/sdk": "^0.27.3",
     "@push.rocks/smartarray": "^1.0.8",
-    "@push.rocks/smartfile": "^11.0.14",
+    "@push.rocks/smartfile": "^11.0.21",
     "@push.rocks/smartpath": "^5.0.18",
     "@push.rocks/smartpdf": "^3.1.6",
-    "@push.rocks/smartpromise": "^4.0.3",
+    "@push.rocks/smartpromise": "^4.0.4",
     "@push.rocks/smartrequest": "^2.0.22",
-    "@push.rocks/webstream": "^1.0.8",
-    "openai": "^4.47.1"
+    "@push.rocks/webstream": "^1.0.10",
+    "openai": "^4.62.1"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://code.foss.global/push.rocks/smartai.git"
+    "url": "https://code.foss.global/push.rocks/smartai.git"
   },
   "bugs": {
     "url": "https://code.foss.global/push.rocks/smartai/issues"
   },
-  "homepage": "https://code.foss.global/push.rocks/smartai#readme",
+  "homepage": "https://code.foss.global/push.rocks/smartai",
   "browserslist": [
     "last 1 chrome versions"
   ],