@push.rocks/smartai 0.0.7 → 0.0.14

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartai',
-    version: '0.0.7',
-    description: 'a standardaized interface to talk to AI models'
+    version: '0.0.14',
+    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxxQkFBcUI7SUFDM0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLGdEQUFnRDtDQUM5RCxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxxQkFBcUI7SUFDM0IsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLCtJQUErSTtDQUM3SixDQUFBIn0=

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

@@ -1,5 +1,27 @@
-export declare abstract class MultiModal {
+export declare abstract class MultiModalModel {
+    /**
+     * starts the model
+     */
     abstract start(): Promise<void>;
+    /**
+     * stops the model
+     */
     abstract stop(): Promise<void>;
-    abstract chatStream(input: ReadableStream<string>): ReadableStream<string>;
+    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
+     */
+    abstract chatStream(input: ReadableStream<string>): Promise<ReadableStream<string>>;
 }

package/dist_ts/abstract.classes.multimodal.js

@@ -1,3 +1,3 @@
-export class MultiModal {
+export class MultiModalModel {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QuY2xhc3Nlcy5tdWx0aW1vZGFsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvYWJzdHJhY3QuY2xhc3Nlcy5tdWx0aW1vZGFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBZ0IsVUFBVTtDQU8vQiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QuY2xhc3Nlcy5tdWx0aW1vZGFsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvYWJzdHJhY3QuY2xhc3Nlcy5tdWx0aW1vZGFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBZ0IsZUFBZTtDQStCcEMifQ==

package/dist_ts/classes.conversation.d.ts

@@ -0,0 +1,26 @@
+import type { SmartAi } from "./classes.smartai.js";
+type TProcessFunction = (input: string) => Promise<string>;
+export interface IConversationOptions {
+    processFunction: TProcessFunction;
+}
+/**
+ * a conversation
+ */
+export declare class Conversation {
+    static createWithOpenAi(smartaiRefArg: SmartAi): Promise<Conversation>;
+    static createWithAnthropic(smartaiRefArg: SmartAi): Promise<Conversation>;
+    static createWithPerplexity(smartaiRefArg: SmartAi): Promise<Conversation>;
+    static createWithOllama(smartaiRefArg: SmartAi): Promise<Conversation>;
+    smartaiRef: SmartAi;
+    private systemMessage;
+    private processFunction;
+    private inputStreamWriter;
+    private outputStreamController;
+    constructor(smartairefArg: SmartAi, options: IConversationOptions);
+    setSystemMessage(systemMessageArg: string): Promise<void>;
+    private setupOutputStream;
+    private setupInputStream;
+    getInputStreamWriter(): WritableStreamDefaultWriter<string>;
+    getOutputStream(): ReadableStream<string>;
+}
+export {};

package/dist_ts/classes.conversation.js

@@ -0,0 +1,95 @@
+import { OpenAiProvider } from "./provider.openai.js";
+/**
+ * a conversation
+ */
+export class Conversation {
+    // STATIC
+    static async createWithOpenAi(smartaiRefArg) {
+        if (!smartaiRefArg.openaiProvider) {
+            throw new Error('OpenAI provider not available');
+        }
+        const conversation = new Conversation(smartaiRefArg, {
+            processFunction: async (input) => {
+                return ''; // TODO implement proper streaming
+            }
+        });
+        return conversation;
+    }
+    static async createWithAnthropic(smartaiRefArg) {
+        if (!smartaiRefArg.anthropicProvider) {
+            throw new Error('Anthropic provider not available');
+        }
+        const conversation = new Conversation(smartaiRefArg, {
+            processFunction: async (input) => {
+                return ''; // TODO implement proper streaming
+            }
+        });
+        return conversation;
+    }
+    static async createWithPerplexity(smartaiRefArg) {
+        if (!smartaiRefArg.perplexityProvider) {
+            throw new Error('Perplexity provider not available');
+        }
+        const conversation = new Conversation(smartaiRefArg, {
+            processFunction: async (input) => {
+                return ''; // TODO implement proper streaming
+            }
+        });
+        return conversation;
+    }
+    static async createWithOllama(smartaiRefArg) {
+        if (!smartaiRefArg.ollamaProvider) {
+            throw new Error('Ollama provider not available');
+        }
+        const conversation = new Conversation(smartaiRefArg, {
+            processFunction: async (input) => {
+                return ''; // TODO implement proper streaming
+            }
+        });
+        return conversation;
+    }
+    constructor(smartairefArg, options) {
+        this.inputStreamWriter = null;
+        this.outputStreamController = null;
+        this.processFunction = options.processFunction;
+    }
+    async setSystemMessage(systemMessageArg) {
+        this.systemMessage = systemMessageArg;
+    }
+    setupOutputStream() {
+        return new ReadableStream({
+            start: (controller) => {
+                this.outputStreamController = controller;
+            }
+        });
+    }
+    setupInputStream() {
+        const writableStream = new WritableStream({
+            write: async (chunk) => {
+                const processedData = await this.processFunction(chunk);
+                if (this.outputStreamController) {
+                    this.outputStreamController.enqueue(processedData);
+                }
+            },
+            close: () => {
+                this.outputStreamController?.close();
+            },
+            abort: (err) => {
+                console.error('Stream aborted', err);
+                this.outputStreamController?.error(err);
+            }
+        });
+        return writableStream;
+    }
+    getInputStreamWriter() {
+        if (!this.inputStreamWriter) {
+            const inputStream = this.setupInputStream();
+            this.inputStreamWriter = inputStream.getWriter();
+        }
+        return this.inputStreamWriter;
+    }
+    getOutputStream() {
+        return this.setupOutputStream();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.smartai.d.ts

@@ -0,0 +1,25 @@
+import { Conversation } from './classes.conversation.js';
+import { AnthropicProvider } from './provider.anthropic.js';
+import type { OllamaProvider } from './provider.ollama.js';
+import { OpenAiProvider } from './provider.openai.js';
+import type { PerplexityProvider } from './provider.perplexity.js';
+export interface ISmartAiOptions {
+    openaiToken?: string;
+    anthropicToken?: string;
+    perplexityToken?: string;
+}
+export type TProvider = 'openai' | 'anthropic' | 'perplexity' | 'ollama';
+export declare class SmartAi {
+    options: ISmartAiOptions;
+    openaiProvider: OpenAiProvider;
+    anthropicProvider: AnthropicProvider;
+    perplexityProvider: PerplexityProvider;
+    ollamaProvider: OllamaProvider;
+    constructor(optionsArg: ISmartAiOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * create a new conversation
+     */
+    createConversation(provider: TProvider): Promise<Conversation>;
+}

package/dist_ts/classes.smartai.js

@@ -0,0 +1,41 @@
+import { Conversation } from './classes.conversation.js';
+import * as plugins from './plugins.js';
+import { AnthropicProvider } from './provider.anthropic.js';
+import { OpenAiProvider } from './provider.openai.js';
+export class SmartAi {
+    constructor(optionsArg) {
+        this.options = optionsArg;
+    }
+    async start() {
+        if (this.options.openaiToken) {
+            this.openaiProvider = new OpenAiProvider({
+                openaiToken: this.options.openaiToken,
+            });
+            await this.openaiProvider.start();
+        }
+        if (this.options.anthropicToken) {
+            this.anthropicProvider = new AnthropicProvider({
+                anthropicToken: this.options.anthropicToken,
+            });
+        }
+    }
+    async stop() { }
+    /**
+     * create a new conversation
+     */
+    createConversation(provider) {
+        switch (provider) {
+            case 'openai':
+                return Conversation.createWithOpenAi(this);
+            case 'anthropic':
+                return Conversation.createWithAnthropic(this);
+            case 'perplexity':
+                return Conversation.createWithPerplexity(this);
+            case 'ollama':
+                return Conversation.createWithOllama(this);
+            default:
+                throw new Error('Provider not available');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zbWFydGFpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY2xhc3Nlcy5zbWFydGFpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUN6RCxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUU1RCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFZdEQsTUFBTSxPQUFPLE9BQU87SUFRbEIsWUFBWSxVQUEyQjtRQUNyQyxJQUFJLENBQUMsT0FBTyxHQUFHLFVBQVUsQ0FBQztJQUM1QixDQUFDO0lBRU0sS0FBSyxDQUFDLEtBQUs7UUFDaEIsSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQzdCLElBQUksQ0FBQyxjQUFjLEdBQUcsSUFBSSxjQUFjLENBQUM7Z0JBQ3ZDLFdBQVcsRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLFdBQVc7YUFDdEMsQ0FBQyxDQUFDO1lBQ0gsTUFBTSxJQUFJLENBQUMsY0FBYyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3BDLENBQUM7UUFDRCxJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMsY0FBYyxFQUFFLENBQUM7WUFDaEMsSUFBSSxDQUFDLGlCQUFpQixHQUFHLElBQUksaUJBQWlCLENBQUM7Z0JBQzdDLGNBQWMsRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLGNBQWM7YUFDNUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztJQUNILENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSSxLQUFJLENBQUM7SUFFdEI7O09BRUc7SUFDSCxrQkFBa0IsQ0FBQyxRQUFtQjtRQUNwQyxRQUFRLFFBQVEsRUFBRSxDQUFDO1lBQ2pCLEtBQUssUUFBUTtnQkFDWCxPQUFPLFlBQVksQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUM3QyxLQUFLLFdBQVc7Z0JBQ2QsT0FBTyxZQUFZLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDaEQsS0FBSyxZQUFZO2dCQUNmLE9BQU8sWUFBWSxDQUFDLG9CQUFvQixDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ2pELEtBQUssUUFBUTtnQkFDWCxPQUFPLFlBQVksQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUM3QztnQkFDRSxNQUFNLElBQUksS0FBSyxDQUFDLHdCQUF3QixDQUFDLENBQUM7UUFDOUMsQ0FBQztJQUNILENBQUM7Q0FDRiJ9

package/dist_ts/classes.tts.d.ts

@@ -0,0 +1,6 @@
+import type { SmartAi } from './classes.smartai.js';
+export declare class TTS {
+    static createWithOpenAi(smartaiRef: SmartAi): Promise<TTS>;
+    smartaiRef: SmartAi;
+    constructor(smartairefArg: SmartAi);
+}

package/dist_ts/classes.tts.js

@@ -0,0 +1,10 @@
+import * as plugins from './plugins.js';
+export class TTS {
+    static async createWithOpenAi(smartaiRef) {
+        return new TTS(smartaiRef);
+    }
+    constructor(smartairefArg) {
+        this.smartaiRef = smartairefArg;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy50dHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9jbGFzc2VzLnR0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4QyxNQUFNLE9BQU8sR0FBRztJQUNQLE1BQU0sQ0FBQyxLQUFLLENBQUMsZ0JBQWdCLENBQUMsVUFBbUI7UUFDdEQsT0FBTyxJQUFJLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUM3QixDQUFDO0lBS0QsWUFBWSxhQUFzQjtRQUNoQyxJQUFJLENBQUMsVUFBVSxHQUFHLGFBQWEsQ0FBQztJQUNsQyxDQUFDO0NBQ0YifQ==

package/dist_ts/index.d.ts

@@ -1,3 +1,3 @@
-export * from './smartai.classes.smartai.js';
+export * from './classes.smartai.js';
 export * from './abstract.classes.multimodal.js';
 export * from './provider.openai.js';

package/dist_ts/index.js

@@ -1,4 +1,4 @@
-export * from './smartai.classes.smartai.js';
+export * from './classes.smartai.js';
 export * from './abstract.classes.multimodal.js';
 export * from './provider.openai.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxzQkFBc0IsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxzQkFBc0IsQ0FBQyJ9

package/dist_ts/interfaces.d.ts

@@ -0,0 +1 @@
+export {};

package/dist_ts/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/plugins.d.ts

@@ -2,9 +2,14 @@
 import * as path from 'path';
 export { path, };
 import * as qenv from '@push.rocks/qenv';
+import * as smartarray from '@push.rocks/smartarray';
+import * as smartfile from '@push.rocks/smartfile';
 import * as smartpath from '@push.rocks/smartpath';
+import * as smartpdf from '@push.rocks/smartpdf';
 import * as smartpromise from '@push.rocks/smartpromise';
-import * as smartfile from '@push.rocks/smartfile';
-export { qenv, smartpath, smartpromise, smartfile, };
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as webstream from '@push.rocks/webstream';
+export { smartarray, qenv, smartfile, smartpath, smartpdf, smartpromise, smartrequest, webstream, };
+import * as anthropic from '@anthropic-ai/sdk';
 import * as openai from 'openai';
-export { openai, };
+export { anthropic, openai, };

package/dist_ts/plugins.js

@@ -3,11 +3,16 @@ import * as path from 'path';
 export { path, };
 // @push.rocks scope
 import * as qenv from '@push.rocks/qenv';
+import * as smartarray from '@push.rocks/smartarray';
+import * as smartfile from '@push.rocks/smartfile';
 import * as smartpath from '@push.rocks/smartpath';
+import * as smartpdf from '@push.rocks/smartpdf';
 import * as smartpromise from '@push.rocks/smartpromise';
-import * as smartfile from '@push.rocks/smartfile';
-export { qenv, smartpath, smartpromise, smartfile, };
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as webstream from '@push.rocks/webstream';
+export { smartarray, qenv, smartfile, smartpath, smartpdf, smartpromise, smartrequest, webstream, };
 // third party
+import * as anthropic from '@anthropic-ai/sdk';
 import * as openai from 'openai';
-export { openai, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFDTCxJQUFJLEdBQ0wsQ0FBQTtBQUVELG9CQUFvQjtBQUNwQixPQUFPLEtBQUssSUFBSSxNQUFNLGtCQUFrQixDQUFDO0FBQ3pDLE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFDTCxJQUFJLEVBQ0osU0FBUyxFQUNULFlBQVksRUFDWixTQUFTLEdBQ1YsQ0FBQTtBQUVELGNBQWM7QUFDZCxPQUFPLEtBQUssTUFBTSxNQUFNLFFBQVEsQ0FBQztBQUVqQyxPQUFPLEVBQ0wsTUFBTSxHQUNQLENBQUEifQ==
+export { anthropic, openai, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFDTCxJQUFJLEdBQ0wsQ0FBQTtBQUVELG9CQUFvQjtBQUNwQixPQUFPLEtBQUssSUFBSSxNQUFNLGtCQUFrQixDQUFDO0FBQ3pDLE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsT0FBTyxFQUNMLFVBQVUsRUFDVixJQUFJLEVBQ0osU0FBUyxFQUNULFNBQVMsRUFDVCxRQUFRLEVBQ1IsWUFBWSxFQUNaLFlBQVksRUFDWixTQUFTLEdBQ1YsQ0FBQTtBQUVELGNBQWM7QUFDZCxPQUFPLEtBQUssU0FBUyxNQUFNLG1CQUFtQixDQUFDO0FBQy9DLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBRWpDLE9BQU8sRUFDTCxTQUFTLEVBQ1QsTUFBTSxHQUNQLENBQUEifQ==

package/dist_ts/provider.anthropic.d.ts

@@ -0,0 +1,25 @@
+import * as plugins from './plugins.js';
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+export interface IAnthropicProviderOptions {
+    anthropicToken: string;
+}
+export declare class AnthropicProvider extends MultiModalModel {
+    private options;
+    anthropicApiClient: plugins.anthropic.default;
+    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";
+        message: string;
+    }>;
+    private audio;
+}

package/dist_ts/provider.anthropic.js

@@ -0,0 +1,41 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+export class AnthropicProvider extends MultiModalModel {
+    constructor(optionsArg) {
+        super();
+        this.options = optionsArg; // Ensure the token is stored
+    }
+    async start() {
+        this.anthropicApiClient = new plugins.anthropic.default({
+            apiKey: this.options.anthropicToken,
+        });
+    }
+    async stop() { }
+    async chatStream(input) {
+        // TODO: implement for OpenAI
+        const returnStream = new ReadableStream();
+        return returnStream;
+    }
+    // Implementing the synchronous chat interaction
+    async chat(optionsArg) {
+        const result = await this.anthropicApiClient.messages.create({
+            model: 'claude-3-opus-20240229',
+            system: optionsArg.systemMessage,
+            messages: [
+                ...optionsArg.messageHistory,
+                { role: 'user', content: optionsArg.userMessage },
+            ],
+            max_tokens: 4000,
+        });
+        return {
+            role: result.role,
+            message: result.content.join('\n'),
+        };
+    }
+    async audio(messageArg) {
+        // 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

package/dist_ts/provider.ollama.d.ts

@@ -0,0 +1,2 @@
+export declare class OllamaProvider {
+}

package/dist_ts/provider.ollama.js

@@ -0,0 +1,4 @@
+import * as plugins from './plugins.js';
+export class OllamaProvider {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXIub2xsYW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvcHJvdmlkZXIub2xsYW1hLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBRXhDLE1BQU0sT0FBTyxjQUFjO0NBQUcifQ==

package/dist_ts/provider.openai.d.ts

@@ -1,17 +1,40 @@
+/// <reference types="node" resolution-mode="require"/>
 import * as plugins from './plugins.js';
-import { MultiModal } from './abstract.classes.multimodal.js';
-export declare class OpenAiProvider extends MultiModal {
-    private openAiToken;
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+export interface IOpenaiProviderOptions {
+    openaiToken: string;
+}
+export declare class OpenAiProvider extends MultiModalModel {
+    private options;
     openAiApiClient: plugins.openai.default;
-    constructor(openaiToken: string);
+    smartpdfInstance: plugins.smartpdf.SmartPdf;
+    constructor(optionsArg: IOpenaiProviderOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
-    chatStream(input: ReadableStream<string>): ReadableStream<string>;
-    chat(systemMessage: string, userMessage: string, messageHistory: {
-        role: 'assistant' | 'user';
-        content: string;
-    }[]): Promise<{
+    chatStream(input: ReadableStream<string>): Promise<ReadableStream<string>>;
+    chat(optionsArg: {
+        systemMessage: string;
+        userMessage: string;
+        messageHistory: {
+            role: 'assistant' | 'user';
+            content: string;
+        }[];
+    }): Promise<{
+        role: "assistant";
+        message: string;
+    }>;
+    audio(optionsArg: {
+        message: string;
+    }): Promise<NodeJS.ReadableStream>;
+    document(optionsArg: {
+        systemMessage: string;
+        userMessage: string;
+        pdfDocuments: Uint8Array[];
+        messageHistory: {
+            role: 'assistant' | 'user';
+            content: any;
+        }[];
+    }): Promise<{
         message: import("openai/resources/index.mjs").ChatCompletionMessage;
     }>;
-    audio(messageArg: string): Promise<unknown>;
 }

package/dist_ts/provider.openai.js

@@ -1,70 +1,92 @@
 import * as plugins from './plugins.js';
 import * as paths from './paths.js';
-import { MultiModal } from './abstract.classes.multimodal.js';
-export class OpenAiProvider extends MultiModal {
-    constructor(openaiToken) {
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+export class OpenAiProvider extends MultiModalModel {
+    constructor(optionsArg) {
         super();
-        this.openAiToken = openaiToken; // Ensure the token is stored
+        this.options = optionsArg;
     }
     async start() {
         this.openAiApiClient = new plugins.openai.default({
-            apiKey: this.openAiToken,
+            apiKey: this.options.openaiToken,
             dangerouslyAllowBrowser: true,
         });
+        this.smartpdfInstance = new plugins.smartpdf.SmartPdf();
     }
     async stop() { }
-    chatStream(input) {
-        const decoder = new TextDecoder();
-        let messageHistory = [];
-        return new ReadableStream({
-            async start(controller) {
-                const reader = input.getReader();
-                try {
-                    let done, value;
-                    while ((({ done, value } = await reader.read()), !done)) {
-                        const userMessage = decoder.decode(value, { stream: true });
-                        messageHistory.push({ role: 'user', content: userMessage });
-                        const aiResponse = await this.chat('', userMessage, messageHistory);
-                        messageHistory.push({ role: 'assistant', content: aiResponse.message });
-                        // Directly enqueue the string response instead of encoding it first
-                        controller.enqueue(aiResponse.message);
-                    }
-                    controller.close();
-                }
-                catch (err) {
-                    controller.error(err);
-                }
-            },
-        });
+    async chatStream(input) {
+        // TODO: implement for OpenAI
+        const returnStream = new ReadableStream();
+        return returnStream;
     }
     // Implementing the synchronous chat interaction
-    async chat(systemMessage, userMessage, messageHistory) {
+    async chat(optionsArg) {
         const result = await this.openAiApiClient.chat.completions.create({
-            model: 'gpt-3.5-turbo-16k-0613',
+            model: 'gpt-4-turbo-preview',
             messages: [
-                { role: 'system', content: systemMessage },
-                ...messageHistory,
-                { role: 'user', content: userMessage },
+                { role: 'system', content: optionsArg.systemMessage },
+                ...optionsArg.messageHistory,
+                { role: 'user', content: optionsArg.userMessage },
             ],
         });
         return {
-            message: result.choices[0].message,
+            role: result.choices[0].message.role,
+            message: result.choices[0].message.content,
         };
     }
-    async audio(messageArg) {
+    async audio(optionsArg) {
         const done = plugins.smartpromise.defer();
         const result = await this.openAiApiClient.audio.speech.create({
             model: 'tts-1-hd',
-            input: messageArg,
+            input: optionsArg.message,
             voice: 'nova',
             response_format: 'mp3',
             speed: 1,
         });
-        const stream = result.body.pipe(plugins.smartfile.fsStream.createWriteStream(plugins.path.join(paths.nogitDir, 'output.mp3')));
-        stream.on('finish', () => {
-            done.resolve();
-        });
+        const stream = result.body;
+        done.resolve(stream);
         return done.promise;
     }
+    async document(optionsArg) {
+        let pdfDocumentImageBytesArray = [];
+        for (const pdfDocument of optionsArg.pdfDocuments) {
+            const documentImageArray = await this.smartpdfInstance.convertPDFToPngBytes(pdfDocument);
+            pdfDocumentImageBytesArray = pdfDocumentImageBytesArray.concat(documentImageArray);
+        }
+        console.log(`image smartfile array`);
+        console.log(pdfDocumentImageBytesArray.map((smartfile) => smartfile.length));
+        const smartfileArray = await plugins.smartarray.map(pdfDocumentImageBytesArray, async (pdfDocumentImageBytes) => {
+            return plugins.smartfile.SmartFile.fromBuffer('pdfDocumentImage.jpg', Buffer.from(pdfDocumentImageBytes));
+        });
+        const result = await this.openAiApiClient.chat.completions.create({
+            model: 'gpt-4-vision-preview',
+            // response_format: { type: "json_object" }, // not supported for now
+            messages: [
+                { role: 'system', content: optionsArg.systemMessage },
+                ...optionsArg.messageHistory,
+                {
+                    role: 'user',
+                    content: [
+                        { type: 'text', text: optionsArg.userMessage },
+                        ...(() => {
+                            const returnArray = [];
+                            for (const imageBytes of pdfDocumentImageBytesArray) {
+                                returnArray.push({
+                                    type: 'image_url',
+                                    image_url: {
+                                        url: 'data:image/png;base64,' + Buffer.from(imageBytes).toString('base64'),
+                                    },
+                                });
+                            }
+                            return returnArray;
+                        })(),
+                    ],
+                },
+            ],
+        });
+        return {
+            message: result.choices[0].message,
+        };
+    }
 }
-//# 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

@@ -0,0 +1,2 @@
+export declare class PerplexityProvider {
+}

package/dist_ts/provider.perplexity.js

@@ -0,0 +1,4 @@
+import * as plugins from './plugins.js';
+export class PerplexityProvider {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXIucGVycGxleGl0eS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3Byb3ZpZGVyLnBlcnBsZXhpdHkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFFeEMsTUFBTSxPQUFPLGtCQUFrQjtDQUFHIn0=