@push.rocks/smartai 0.9.0 → 0.10.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartai',
-    version: '0.9.0',
+    version: '0.10.0',
     description: 'SmartAi is a versatile TypeScript library designed to facilitate integration and interaction with various AI models, offering functionalities for chat, audio generation, document processing, and vision tasks.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxxQkFBcUI7SUFDM0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLGtOQUFrTjtDQUNoTyxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxxQkFBcUI7SUFDM0IsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLGtOQUFrTjtDQUNoTyxDQUFBIn0=

package/dist_ts/classes.conversation.d.ts

@@ -13,6 +13,7 @@ export declare class Conversation {
     static createWithExo(smartaiRefArg: SmartAi): Promise<Conversation>;
     static createWithOllama(smartaiRefArg: SmartAi): Promise<Conversation>;
     static createWithGroq(smartaiRefArg: SmartAi): Promise<Conversation>;
+    static createWithMistral(smartaiRefArg: SmartAi): Promise<Conversation>;
     static createWithXai(smartaiRefArg: SmartAi): Promise<Conversation>;
     static createWithElevenlabs(smartaiRefArg: SmartAi): Promise<Conversation>;
     smartaiRef: SmartAi;

package/dist_ts/classes.conversation.js

@@ -70,6 +70,17 @@ export class Conversation {
         });
         return conversation;
     }
+    static async createWithMistral(smartaiRefArg) {
+        if (!smartaiRefArg.mistralProvider) {
+            throw new Error('Mistral provider not available');
+        }
+        const conversation = new Conversation(smartaiRefArg, {
+            processFunction: async (input) => {
+                return ''; // TODO implement proper streaming
+            }
+        });
+        return conversation;
+    }
     static async createWithXai(smartaiRefArg) {
         if (!smartaiRefArg.xaiProvider) {
             throw new Error('XAI provider not available');
@@ -136,4 +147,4 @@ export class Conversation {
         return this.setupOutputStream();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5jb252ZXJzYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9jbGFzc2VzLmNvbnZlcnNhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFRdEQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sWUFBWTtJQUN2QixTQUFTO0lBQ0YsTUFBTSxDQUFDLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxhQUFzQjtRQUN6RCxJQUFJLENBQUMsYUFBYSxDQUFDLGNBQWMsRUFBRSxDQUFDO1lBQ2xDLE1BQU0sSUFBSSxLQUFLLENBQUMsK0JBQStCLENBQUMsQ0FBQztRQUNuRCxDQUFDO1FBQ0QsTUFBTSxZQUFZLEdBQUcsSUFBSSxZQUFZLENBQUMsYUFBYSxFQUFFO1lBQ25ELGVBQWUsRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEVBQUU7Z0JBQy9CLE9BQU8sRUFBRSxDQUFBLENBQUMsa0NBQWtDO1lBQzlDLENBQUM7U0FDRixDQUFDLENBQUM7UUFDSCxPQUFPLFlBQVksQ0FBQztJQUN0QixDQUFDO0lBRU0sTUFBTSxDQUFDLEtBQUssQ0FBQyxtQkFBbUIsQ0FBQyxhQUFzQjtRQUM1RCxJQUFJLENBQUMsYUFBYSxDQUFDLGlCQUFpQixFQUFFLENBQUM7WUFDckMsTUFBTSxJQUFJLEtBQUssQ0FBQyxrQ0FBa0MsQ0FBQyxDQUFDO1FBQ3RELENBQUM7UUFDRCxNQUFNLFlBQVksR0FBRyxJQUFJLFlBQVksQ0FBQyxhQUFhLEVBQUU7WUFDbkQsZUFBZSxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsRUFBRTtnQkFDL0IsT0FBTyxFQUFFLENBQUEsQ0FBQyxrQ0FBa0M7WUFDOUMsQ0FBQztTQUNGLENBQUMsQ0FBQztRQUNILE9BQU8sWUFBWSxDQUFDO0lBQ3RCLENBQUM7SUFFTSxNQUFNLENBQUMsS0FBSyxDQUFDLG9CQUFvQixDQUFDLGFBQXNCO1FBQzdELElBQUksQ0FBQyxhQUFhLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztZQUN0QyxNQUFNLElBQUksS0FBSyxDQUFDLG1DQUFtQyxDQUFDLENBQUM7UUFDdkQsQ0FBQztRQUNELE1BQU0sWUFBWSxHQUFHLElBQUksWUFBWSxDQUFDLGFBQWEsRUFBRTtZQUNuRCxlQUFlLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxFQUFFO2dCQUMvQixPQUFPLEVBQUUsQ0FBQSxDQUFDLGtDQUFrQztZQUM5QyxDQUFDO1NBQ0YsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxZQUFZLENBQUM7SUFDdEIsQ0FBQztJQUVNLE1BQU0sQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUFDLGFBQXNCO1FBQ3RELElBQUksQ0FBQyxhQUFhLENBQUMsV0FBVyxFQUFFLENBQUM7WUFDL0IsTUFBTSxJQUFJLEtBQUssQ0FBQyw0QkFBNEIsQ0FBQyxDQUFDO1FBQ2hELENBQUM7UUFDRCxNQUFNLFlBQVksR0FBRyxJQUFJLFlBQVksQ0FBQyxhQUFhLEVBQUU7WUFDbkQsZUFBZSxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsRUFBRTtnQkFDL0IsT0FBTyxFQUFFLENBQUEsQ0FBQyxrQ0FBa0M7WUFDOUMsQ0FBQztTQUNGLENBQUMsQ0FBQztRQUNILE9BQU8sWUFBWSxDQUFDO0lBQ3RCLENBQUM7SUFFTSxNQUFNLENBQUMsS0FBSyxDQUFDLGdCQUFnQixDQUFDLGFBQXNCO1FBQ3pELElBQUksQ0FBQyxhQUFhLENBQUMsY0FBYyxFQUFFLENBQUM7WUFDbEMsTUFBTSxJQUFJLEtBQUssQ0FBQywrQkFBK0IsQ0FBQyxDQUFDO1FBQ25ELENBQUM7UUFDRCxNQUFNLFlBQVksR0FBRyxJQUFJLFlBQVksQ0FBQyxhQUFhLEVBQUU7WUFDbkQsZUFBZSxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsRUFBRTtnQkFDL0IsT0FBTyxFQUFFLENBQUEsQ0FBQyxrQ0FBa0M7WUFDOUMsQ0FBQztTQUNGLENBQUMsQ0FBQztRQUNILE9BQU8sWUFBWSxDQUFDO0lBQ3RCLENBQUM7SUFFTSxNQUFNLENBQUMsS0FBSyxDQUFDLGNBQWMsQ0FBQyxhQUFzQjtRQUN2RCxJQUFJLENBQUMsYUFBYSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQ2hDLE1BQU0sSUFBSSxLQUFLLENBQUMsNkJBQTZCLENBQUMsQ0FBQztRQUNqRCxDQUFDO1FBQ0QsTUFBTSxZQUFZLEdBQUcsSUFBSSxZQUFZLENBQUMsYUFBYSxFQUFFO1lBQ25ELGVBQWUsRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEVBQUU7Z0JBQy9CLE9BQU8sRUFBRSxDQUFBLENBQUMsa0NBQWtDO1lBQzlDLENBQUM7U0FDRixDQUFDLENBQUM7UUFDSCxPQUFPLFlBQVksQ0FBQztJQUN0QixDQUFDO0lBRU0sTUFBTSxDQUFDLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxhQUFzQjtRQUMxRCxJQUFJLENBQUMsYUFBYSxDQUFDLGVBQWUsRUFBRSxDQUFDO1lBQ25DLE1BQU0sSUFBSSxLQUFLLENBQUMsZ0NBQWdDLENBQUMsQ0FBQztRQUNwRCxDQUFDO1FBQ0QsTUFBTSxZQUFZLEdBQUcsSUFBSSxZQUFZLENBQUMsYUFBYSxFQUFFO1lBQ25ELGVBQWUsRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEVBQUU7Z0JBQy9CLE9BQU8sRUFBRSxDQUFBLENBQUMsa0NBQWtDO1lBQzlDLENBQUM7U0FDRixDQUFDLENBQUM7UUFDSCxPQUFPLFlBQVksQ0FBQztJQUN0QixDQUFDO0lBRU0sTUFBTSxDQUFDLEtBQUssQ0FBQyxhQUFhLENBQUMsYUFBc0I7UUFDdEQsSUFBSSxDQUFDLGFBQWEsQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUMvQixNQUFNLElBQUksS0FBSyxDQUFDLDRCQUE0QixDQUFDLENBQUM7UUFDaEQsQ0FBQztRQUNELE1BQU0sWUFBWSxHQUFHLElBQUksWUFBWSxDQUFDLGFBQWEsRUFBRTtZQUNuRCxlQUFlLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxFQUFFO2dCQUMvQixPQUFPLEVBQUUsQ0FBQSxDQUFDLGtDQUFrQztZQUM5QyxDQUFDO1NBQ0YsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxZQUFZLENBQUM7SUFDdEIsQ0FBQztJQUVNLE1BQU0sQ0FBQyxLQUFLLENBQUMsb0JBQW9CLENBQUMsYUFBc0I7UUFDN0QsSUFBSSxDQUFDLGFBQWEsQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1lBQ3RDLE1BQU0sSUFBSSxLQUFLLENBQUMsbUNBQW1DLENBQUMsQ0FBQztRQUN2RCxDQUFDO1FBQ0QsTUFBTSxZQUFZLEdBQUcsSUFBSSxZQUFZLENBQUMsYUFBYSxFQUFFO1lBQ25ELGVBQWUsRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLEVBQUU7Z0JBQy9CLE9BQU8sRUFBRSxDQUFBLENBQUMsa0NBQWtDO1lBQzlDLENBQUM7U0FDRixDQUFDLENBQUM7UUFDSCxPQUFPLFlBQVksQ0FBQztJQUN0QixDQUFDO0lBU0QsWUFBWSxhQUFzQixFQUFFLE9BQTZCO1FBSHpELHNCQUFpQixHQUErQyxJQUFJLENBQUM7UUFDckUsMkJBQXNCLEdBQW1ELElBQUksQ0FBQztRQUdwRixJQUFJLENBQUMsZUFBZSxHQUFHLE9BQU8sQ0FBQyxlQUFlLENBQUM7SUFDakQsQ0FBQztJQUVNLEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxnQkFBd0I7UUFDcEQsSUFBSSxDQUFDLGFBQWEsR0FBRyxnQkFBZ0IsQ0FBQztJQUN4QyxDQUFDO0lBRU8saUJBQWlCO1FBQ3ZCLE9BQU8sSUFBSSxjQUFjLENBQVM7WUFDaEMsS0FBSyxFQUFFLENBQUMsVUFBVSxFQUFFLEVBQUU7Z0JBQ3BCLElBQUksQ0FBQyxzQkFBc0IsR0FBRyxVQUFVLENBQUM7WUFDM0MsQ0FBQztTQUNGLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTyxnQkFBZ0I7UUFDdEIsTUFBTSxjQUFjLEdBQUcsSUFBSSxjQUFjLENBQVM7WUFDaEQsS0FBSyxFQUFFLEtBQUssRUFBRSxLQUFLLEVBQUUsRUFBRTtnQkFDckIsTUFBTSxhQUFhLEdBQUcsTUFBTSxJQUFJLENBQUMsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDO2dCQUN4RCxJQUFJLElBQUksQ0FBQyxzQkFBc0IsRUFBRSxDQUFDO29CQUNoQyxJQUFJLENBQUMsc0JBQXNCLENBQUMsT0FBTyxDQUFDLGFBQWEsQ0FBQyxDQUFDO2dCQUNyRCxDQUFDO1lBQ0gsQ0FBQztZQUNELEtBQUssRUFBRSxHQUFHLEVBQUU7Z0JBQ1YsSUFBSSxDQUFDLHNCQUFzQixFQUFFLEtBQUssRUFBRSxDQUFDO1lBQ3ZDLENBQUM7WUFDRCxLQUFLLEVBQUUsQ0FBQyxHQUFHLEVBQUUsRUFBRTtnQkFDYixPQUFPLENBQUMsS0FBSyxDQUFDLGdCQUFnQixFQUFFLEdBQUcsQ0FBQyxDQUFDO2dCQUNyQyxJQUFJLENBQUMsc0JBQXNCLEVBQUUsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQzFDLENBQUM7U0FDRixDQUFDLENBQUM7UUFDSCxPQUFPLGNBQWMsQ0FBQztJQUN4QixDQUFDO0lBRU0sb0JBQW9CO1FBQ3pCLElBQUksQ0FBQyxJQUFJLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztZQUM1QixNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQztZQUM1QyxJQUFJLENBQUMsaUJBQWlCLEdBQUcsV0FBVyxDQUFDLFNBQVMsRUFBRSxDQUFDO1FBQ25ELENBQUM7UUFDRCxPQUFPLElBQUksQ0FBQyxpQkFBaUIsQ0FBQztJQUNoQyxDQUFDO0lBRU0sZUFBZTtRQUNwQixPQUFPLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO0lBQ2xDLENBQUM7Q0FDRiJ9

package/dist_ts/classes.smartai.d.ts

@@ -1,6 +1,7 @@
 import { Conversation } from './classes.conversation.js';
 import { AnthropicProvider } from './provider.anthropic.js';
 import { ElevenLabsProvider } from './provider.elevenlabs.js';
+import { MistralProvider } from './provider.mistral.js';
 import { OllamaProvider } from './provider.ollama.js';
 import { OpenAiProvider } from './provider.openai.js';
 import { PerplexityProvider } from './provider.perplexity.js';
@@ -12,12 +13,18 @@ export interface ISmartAiOptions {
     anthropicToken?: string;
     perplexityToken?: string;
     groqToken?: string;
+    mistralToken?: string;
     xaiToken?: string;
     elevenlabsToken?: string;
     exo?: {
         baseUrl?: string;
         apiKey?: string;
     };
+    mistral?: {
+        chatModel?: string;
+        ocrModel?: string;
+        tableFormat?: 'markdown' | 'html';
+    };
     ollama?: {
         baseUrl?: string;
         model?: string;
@@ -28,7 +35,7 @@ export interface ISmartAiOptions {
         defaultModelId?: string;
     };
 }
-export type TProvider = 'openai' | 'anthropic' | 'perplexity' | 'ollama' | 'exo' | 'groq' | 'xai' | 'elevenlabs';
+export type TProvider = 'openai' | 'anthropic' | 'perplexity' | 'ollama' | 'exo' | 'groq' | 'mistral' | 'xai' | 'elevenlabs';
 export declare class SmartAi {
     options: ISmartAiOptions;
     openaiProvider: OpenAiProvider;
@@ -37,6 +44,7 @@ export declare class SmartAi {
     ollamaProvider: OllamaProvider;
     exoProvider: ExoProvider;
     groqProvider: GroqProvider;
+    mistralProvider: MistralProvider;
     xaiProvider: XAIProvider;
     elevenlabsProvider: ElevenLabsProvider;
     constructor(optionsArg: ISmartAiOptions);

package/dist_ts/classes.smartai.js

@@ -2,6 +2,7 @@ import { Conversation } from './classes.conversation.js';
 import * as plugins from './plugins.js';
 import { AnthropicProvider } from './provider.anthropic.js';
 import { ElevenLabsProvider } from './provider.elevenlabs.js';
+import { MistralProvider } from './provider.mistral.js';
 import { OllamaProvider } from './provider.ollama.js';
 import { OpenAiProvider } from './provider.openai.js';
 import { PerplexityProvider } from './provider.perplexity.js';
@@ -37,6 +38,15 @@ export class SmartAi {
             });
             await this.groqProvider.start();
         }
+        if (this.options.mistralToken) {
+            this.mistralProvider = new MistralProvider({
+                mistralToken: this.options.mistralToken,
+                chatModel: this.options.mistral?.chatModel,
+                ocrModel: this.options.mistral?.ocrModel,
+                tableFormat: this.options.mistral?.tableFormat,
+            });
+            await this.mistralProvider.start();
+        }
         if (this.options.xaiToken) {
             this.xaiProvider = new XAIProvider({
                 xaiToken: this.options.xaiToken,
@@ -80,6 +90,9 @@ export class SmartAi {
         if (this.groqProvider) {
             await this.groqProvider.stop();
         }
+        if (this.mistralProvider) {
+            await this.mistralProvider.stop();
+        }
         if (this.xaiProvider) {
             await this.xaiProvider.stop();
         }
@@ -110,6 +123,8 @@ export class SmartAi {
                 return Conversation.createWithOllama(this);
             case 'groq':
                 return Conversation.createWithGroq(this);
+            case 'mistral':
+                return Conversation.createWithMistral(this);
             case 'xai':
                 return Conversation.createWithXai(this);
             case 'elevenlabs':
@@ -119,4 +134,4 @@ export class SmartAi {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -4,6 +4,7 @@ export * from './provider.openai.js';
 export * from './provider.anthropic.js';
 export * from './provider.perplexity.js';
 export * from './provider.groq.js';
+export * from './provider.mistral.js';
 export * from './provider.ollama.js';
 export * from './provider.xai.js';
 export * from './provider.exo.js';

package/dist_ts/index.js

@@ -4,8 +4,9 @@ export * from './provider.openai.js';
 export * from './provider.anthropic.js';
 export * from './provider.perplexity.js';
 export * from './provider.groq.js';
+export * from './provider.mistral.js';
 export * from './provider.ollama.js';
 export * from './provider.xai.js';
 export * from './provider.exo.js';
 export * from './provider.elevenlabs.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLDBCQUEwQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsMEJBQTBCLENBQUMifQ==

package/dist_ts/plugins.d.ts

@@ -10,5 +10,6 @@ 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 mistralai from '@mistralai/mistralai';
 import * as openai from 'openai';
-export { anthropic, openai, };
+export { anthropic, mistralai, openai, };

package/dist_ts/plugins.js

@@ -13,6 +13,7 @@ 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 mistralai from '@mistralai/mistralai';
 import * as openai from 'openai';
-export { anthropic, openai, };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFDTCxJQUFJLEdBQ0wsQ0FBQTtBQUVELG9CQUFvQjtBQUNwQixPQUFPLEtBQUssSUFBSSxNQUFNLGtCQUFrQixDQUFDO0FBQ3pDLE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsT0FBTyxFQUNMLFVBQVUsRUFDVixJQUFJLEVBQ0osU0FBUyxFQUNULFNBQVMsRUFDVCxRQUFRLEVBQ1IsWUFBWSxFQUNaLFlBQVksRUFDWixTQUFTLEdBQ1YsQ0FBQTtBQUVELGNBQWM7QUFDZCxPQUFPLEtBQUssU0FBUyxNQUFNLG1CQUFtQixDQUFDO0FBQy9DLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBRWpDLE9BQU8sRUFDTCxTQUFTLEVBQ1QsTUFBTSxHQUNQLENBQUEifQ==
+export { anthropic, mistralai, openai, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFDTCxJQUFJLEdBQ0wsQ0FBQTtBQUVELG9CQUFvQjtBQUNwQixPQUFPLEtBQUssSUFBSSxNQUFNLGtCQUFrQixDQUFDO0FBQ3pDLE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsT0FBTyxFQUNMLFVBQVUsRUFDVixJQUFJLEVBQ0osU0FBUyxFQUNULFNBQVMsRUFDVCxRQUFRLEVBQ1IsWUFBWSxFQUNaLFlBQVksRUFDWixTQUFTLEdBQ1YsQ0FBQTtBQUVELGNBQWM7QUFDZCxPQUFPLEtBQUssU0FBUyxNQUFNLG1CQUFtQixDQUFDO0FBQy9DLE9BQU8sS0FBSyxTQUFTLE1BQU0sc0JBQXNCLENBQUM7QUFDbEQsT0FBTyxLQUFLLE1BQU0sTUFBTSxRQUFRLENBQUM7QUFFakMsT0FBTyxFQUNMLFNBQVMsRUFDVCxTQUFTLEVBQ1QsTUFBTSxHQUNQLENBQUEifQ==

package/dist_ts/provider.mistral.d.ts

@@ -0,0 +1,61 @@
+import * as plugins from './plugins.js';
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+import type { ChatOptions, ChatResponse, ChatMessage, ResearchOptions, ResearchResponse, ImageGenerateOptions, ImageEditOptions, ImageResponse } from './abstract.classes.multimodal.js';
+export interface IMistralProviderOptions {
+    mistralToken: string;
+    chatModel?: string;
+    ocrModel?: string;
+    tableFormat?: 'markdown' | 'html';
+}
+export declare class MistralProvider extends MultiModalModel {
+    private options;
+    mistralClient: plugins.mistralai.Mistral;
+    constructor(optionsArg: IMistralProviderOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Synchronous chat interaction using Mistral's chat API
+     */
+    chat(optionsArg: ChatOptions): Promise<ChatResponse>;
+    /**
+     * Streaming chat using Mistral's streaming API
+     */
+    chatStream(input: ReadableStream<Uint8Array>): Promise<ReadableStream<string>>;
+    /**
+     * Audio generation is not supported by Mistral
+     */
+    audio(optionsArg: {
+        message: string;
+    }): Promise<NodeJS.ReadableStream>;
+    /**
+     * Vision using Mistral's OCR API for image analysis
+     */
+    vision(optionsArg: {
+        image: Buffer;
+        prompt: string;
+    }): Promise<string>;
+    /**
+     * Document processing using Mistral's OCR API
+     * PDFs are uploaded via Files API first, then processed with OCR
+     */
+    document(optionsArg: {
+        systemMessage: string;
+        userMessage: string;
+        pdfDocuments: Uint8Array[];
+        messageHistory: ChatMessage[];
+    }): Promise<{
+        message: any;
+    }>;
+    /**
+     * Research is not natively supported by Mistral
+     */
+    research(optionsArg: ResearchOptions): Promise<ResearchResponse>;
+    /**
+     * Image generation is not supported by Mistral
+     */
+    imageGenerate(optionsArg: ImageGenerateOptions): Promise<ImageResponse>;
+    /**
+     * Image editing is not supported by Mistral
+     */
+    imageEdit(optionsArg: ImageEditOptions): Promise<ImageResponse>;
+}

package/dist_ts/provider.mistral.js

@@ -0,0 +1,288 @@
+import * as plugins from './plugins.js';
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+export class MistralProvider extends MultiModalModel {
+    constructor(optionsArg) {
+        super();
+        this.options = optionsArg;
+    }
+    async start() {
+        await super.start();
+        this.mistralClient = new plugins.mistralai.Mistral({
+            apiKey: this.options.mistralToken,
+        });
+    }
+    async stop() {
+        await super.stop();
+    }
+    /**
+     * Synchronous chat interaction using Mistral's chat API
+     */
+    async chat(optionsArg) {
+        // Convert message history to Mistral format
+        const messages = [];
+        // Add system message first
+        if (optionsArg.systemMessage) {
+            messages.push({
+                role: 'system',
+                content: optionsArg.systemMessage
+            });
+        }
+        // Add message history
+        for (const msg of optionsArg.messageHistory) {
+            messages.push({
+                role: msg.role === 'system' ? 'system' : msg.role === 'assistant' ? 'assistant' : 'user',
+                content: msg.content
+            });
+        }
+        // Add current user message
+        messages.push({
+            role: 'user',
+            content: optionsArg.userMessage
+        });
+        const result = await this.mistralClient.chat.complete({
+            model: this.options.chatModel || 'mistral-large-latest',
+            messages: messages,
+        });
+        // Extract content from response
+        const choice = result.choices?.[0];
+        let content = '';
+        if (choice?.message?.content) {
+            if (typeof choice.message.content === 'string') {
+                content = choice.message.content;
+            }
+            else if (Array.isArray(choice.message.content)) {
+                // Handle array of content chunks
+                content = choice.message.content
+                    .map((chunk) => {
+                    if (typeof chunk === 'string')
+                        return chunk;
+                    if (chunk && typeof chunk === 'object' && 'text' in chunk)
+                        return chunk.text;
+                    return '';
+                })
+                    .join('');
+            }
+        }
+        return {
+            role: 'assistant',
+            message: content,
+        };
+    }
+    /**
+     * Streaming chat using Mistral's streaming API
+     */
+    async chatStream(input) {
+        const decoder = new TextDecoder();
+        let buffer = '';
+        const mistralClient = this.mistralClient;
+        const chatModel = this.options.chatModel || 'mistral-large-latest';
+        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);
+                            // Build messages array
+                            const messages = [];
+                            if (message.systemMessage) {
+                                messages.push({
+                                    role: 'system',
+                                    content: message.systemMessage
+                                });
+                            }
+                            messages.push({
+                                role: message.role === 'assistant' ? 'assistant' : 'user',
+                                content: message.content
+                            });
+                            // Use Mistral streaming
+                            const stream = await mistralClient.chat.stream({
+                                model: chatModel,
+                                messages: messages,
+                            });
+                            // Process streaming events
+                            for await (const event of stream) {
+                                const delta = event.data?.choices?.[0]?.delta;
+                                if (delta?.content) {
+                                    if (typeof delta.content === 'string') {
+                                        controller.enqueue(delta.content);
+                                    }
+                                    else if (Array.isArray(delta.content)) {
+                                        for (const chunk of delta.content) {
+                                            if (typeof chunk === 'string') {
+                                                controller.enqueue(chunk);
+                                            }
+                                            else if (chunk && typeof chunk === 'object' && 'text' in chunk) {
+                                                controller.enqueue(chunk.text);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        catch (e) {
+                            console.error('Failed to parse message:', e);
+                        }
+                    }
+                }
+            },
+            flush(controller) {
+                if (buffer.trim()) {
+                    try {
+                        const message = JSON.parse(buffer);
+                        controller.enqueue(message.content || '');
+                    }
+                    catch (e) {
+                        console.error('Failed to parse remaining buffer:', e);
+                    }
+                }
+            }
+        });
+        return input.pipeThrough(transform);
+    }
+    /**
+     * Audio generation is not supported by Mistral
+     */
+    async audio(optionsArg) {
+        throw new Error('Audio generation is not supported by Mistral. Please use ElevenLabs or OpenAI provider for audio generation.');
+    }
+    /**
+     * Vision using Mistral's OCR API for image analysis
+     */
+    async vision(optionsArg) {
+        const base64Image = optionsArg.image.toString('base64');
+        // Detect image type from buffer header
+        let mimeType = 'image/jpeg';
+        if (optionsArg.image[0] === 0x89 && optionsArg.image[1] === 0x50) {
+            mimeType = 'image/png';
+        }
+        else if (optionsArg.image[0] === 0x47 && optionsArg.image[1] === 0x49) {
+            mimeType = 'image/gif';
+        }
+        else if (optionsArg.image[0] === 0x52 && optionsArg.image[1] === 0x49) {
+            mimeType = 'image/webp';
+        }
+        // Use OCR API with image data URL
+        const ocrResult = await this.mistralClient.ocr.process({
+            model: this.options.ocrModel || 'mistral-ocr-latest',
+            document: {
+                imageUrl: `data:${mimeType};base64,${base64Image}`,
+                type: 'image_url',
+            },
+        });
+        // Combine markdown from all pages
+        const extractedText = ocrResult.pages.map(page => page.markdown).join('\n\n');
+        // If a prompt is provided, use chat to analyze the extracted text
+        if (optionsArg.prompt && optionsArg.prompt.trim()) {
+            const chatResponse = await this.chat({
+                systemMessage: 'You are an assistant analyzing image content. The following is text extracted from an image using OCR.',
+                userMessage: `${optionsArg.prompt}\n\nExtracted content:\n${extractedText}`,
+                messageHistory: [],
+            });
+            return chatResponse.message;
+        }
+        return extractedText;
+    }
+    /**
+     * Document processing using Mistral's OCR API
+     * PDFs are uploaded via Files API first, then processed with OCR
+     */
+    async document(optionsArg) {
+        const extractedTexts = [];
+        const uploadedFileIds = [];
+        try {
+            // Process each PDF document using Mistral OCR
+            for (let i = 0; i < optionsArg.pdfDocuments.length; i++) {
+                const pdfDocument = optionsArg.pdfDocuments[i];
+                // Upload the PDF to Mistral's Files API first
+                const uploadResult = await this.mistralClient.files.upload({
+                    file: {
+                        fileName: `document_${i + 1}.pdf`,
+                        content: pdfDocument,
+                    },
+                    purpose: 'ocr',
+                });
+                uploadedFileIds.push(uploadResult.id);
+                // Now use OCR with the uploaded file
+                const ocrResult = await this.mistralClient.ocr.process({
+                    model: this.options.ocrModel || 'mistral-ocr-latest',
+                    document: {
+                        type: 'file',
+                        fileId: uploadResult.id,
+                    },
+                    tableFormat: this.options.tableFormat || 'markdown',
+                });
+                // Combine all page markdown with page separators
+                const pageTexts = ocrResult.pages.map((page, index) => {
+                    let pageContent = `--- Page ${index + 1} ---\n${page.markdown}`;
+                    // Include tables if present
+                    if (page.tables && page.tables.length > 0) {
+                        pageContent += '\n\n**Tables:**\n' + page.tables.map((t) => t.markdown || t.html || '').join('\n');
+                    }
+                    // Include header/footer if present
+                    if (page.header) {
+                        pageContent = `Header: ${page.header}\n${pageContent}`;
+                    }
+                    if (page.footer) {
+                        pageContent += `\nFooter: ${page.footer}`;
+                    }
+                    return pageContent;
+                }).join('\n\n');
+                extractedTexts.push(pageTexts);
+            }
+            // Combine all document texts
+            const allDocumentText = extractedTexts.length === 1
+                ? extractedTexts[0]
+                : extractedTexts.map((text, i) => `=== Document ${i + 1} ===\n${text}`).join('\n\n');
+            // Use chat API to process the extracted text with the user's query
+            const chatResponse = await this.chat({
+                systemMessage: optionsArg.systemMessage || 'You are a helpful assistant analyzing document content.',
+                userMessage: `${optionsArg.userMessage}\n\n---\nDocument Content:\n${allDocumentText}`,
+                messageHistory: optionsArg.messageHistory,
+            });
+            return {
+                message: {
+                    role: 'assistant',
+                    content: chatResponse.message
+                }
+            };
+        }
+        finally {
+            // Clean up uploaded files
+            for (const fileId of uploadedFileIds) {
+                try {
+                    await this.mistralClient.files.delete({ fileId });
+                }
+                catch (cleanupError) {
+                    // Ignore cleanup errors - files may have already been auto-deleted
+                    console.warn(`Failed to delete temporary file ${fileId}:`, cleanupError);
+                }
+            }
+        }
+    }
+    /**
+     * Research is not natively supported by Mistral
+     */
+    async research(optionsArg) {
+        throw new Error('Research/web search is not supported by Mistral. Please use Perplexity or Anthropic provider for research capabilities.');
+    }
+    /**
+     * Image generation is not supported by Mistral
+     */
+    async imageGenerate(optionsArg) {
+        throw new Error('Image generation is not supported by Mistral. Please use OpenAI provider for image generation.');
+    }
+    /**
+     * Image editing is not supported by Mistral
+     */
+    async imageEdit(optionsArg) {
+        throw new Error('Image editing is not supported by Mistral. Please use OpenAI provider for image editing.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.mistral.js","sourceRoot":"","sources":["../ts/provider.mistral.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartai",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "private": false,
   "description": "SmartAi is a versatile TypeScript library designed to facilitate integration and interaction with various AI models, offering functionalities for chat, audio generation, document processing, and vision tasks.",
   "main": "dist_ts/index.js",
@@ -25,6 +25,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.71.2",
+    "@mistralai/mistralai": "^1.11.0",
     "@push.rocks/smartarray": "^1.1.0",
     "@push.rocks/smartfile": "^11.2.7",
     "@push.rocks/smartpath": "^6.0.0",

package/readme.hints.md

@@ -5,6 +5,7 @@
 - Uses `@git.zone/tstest` v3.x for testing (import from `@git.zone/tstest/tapbundle`)
 - `@push.rocks/smartfile` is kept at v11 to avoid migration to factory pattern
 - `@anthropic-ai/sdk` v0.71.x with extended thinking support
+- `@mistralai/mistralai` v1.x for Mistral OCR and chat capabilities
 - `@push.rocks/smartrequest` v5.x - uses `response.stream()` + `Readable.fromWeb()` for streaming
 
 ## Important Notes
@@ -12,6 +13,68 @@
 - When extended thinking is enabled, temperature parameter must NOT be set (or set to 1)
 - The `streamNode()` method was removed in smartrequest v5, use `response.stream()` with `Readable.fromWeb()` instead
 
+## Mistral Provider Integration
+
+### Overview
+
+The Mistral provider supports:
+- **Document AI** via Mistral OCR 3 (December 2025) - native PDF processing without image conversion
+- **Chat capabilities** using Mistral's chat models (`mistral-large-latest`, etc.)
+
+### Key Advantage: Native PDF Support
+
+Unlike other providers that require converting PDFs to images (using SmartPdf), Mistral OCR natively accepts PDF documents as base64-encoded data. This makes document processing potentially faster and more accurate for text extraction.
+
+### Configuration
+
+```typescript
+import * as smartai from '@push.rocks/smartai';
+
+const provider = new smartai.MistralProvider({
+  mistralToken: 'your-token-here',
+  chatModel: 'mistral-large-latest',  // default
+  ocrModel: 'mistral-ocr-latest',     // default
+  tableFormat: 'markdown',             // 'markdown' or 'html'
+});
+
+await provider.start();
+```
+
+### Supported Methods
+
+| Method | Support | Notes |
+|--------|---------|-------|
+| `chat()` | ✅ | Standard chat completion |
+| `chatStream()` | ✅ | Streaming chat responses |
+| `document()` | ✅ | Native PDF OCR - no image conversion needed |
+| `vision()` | ✅ | Image OCR with optional chat analysis |
+| `audio()` | ❌ | Not supported - use ElevenLabs |
+| `research()` | ❌ | Not supported - use Perplexity |
+| `imageGenerate()` | ❌ | Not supported - use OpenAI |
+| `imageEdit()` | ❌ | Not supported - use OpenAI |
+
+### Document Processing
+
+The `document()` method uses Mistral OCR to extract text from PDFs, then uses Mistral chat to process the user's query with the extracted content.
+
+```typescript
+const result = await provider.document({
+  systemMessage: 'You are a document analyst.',
+  userMessage: 'Summarize this document.',
+  pdfDocuments: [pdfBuffer],
+  messageHistory: [],
+});
+```
+
+### API Key
+
+Tests require `MISTRAL_API_KEY` in `.nogit/env.json`.
+
+### Pricing (as of December 2025)
+
+- OCR: $2 per 1,000 pages ($1 with Batch API)
+- Chat: Varies by model (see Mistral pricing page)
+
 ## Anthropic Extended Thinking Feature
 
 ### Overview

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartai',
-  version: '0.9.0',
+  version: '0.10.0',
   description: 'SmartAi is a versatile TypeScript library designed to facilitate integration and interaction with various AI models, offering functionalities for chat, audio generation, document processing, and vision tasks.'
 }

package/ts/classes.conversation.ts

@@ -84,6 +84,18 @@ export class Conversation {
     return conversation;
   }
 
+  public static async createWithMistral(smartaiRefArg: SmartAi) {
+    if (!smartaiRefArg.mistralProvider) {
+      throw new Error('Mistral provider not available');
+    }
+    const conversation = new Conversation(smartaiRefArg, {
+      processFunction: async (input) => {
+        return '' // TODO implement proper streaming
+      }
+    });
+    return conversation;
+  }
+
   public static async createWithXai(smartaiRefArg: SmartAi) {
     if (!smartaiRefArg.xaiProvider) {
       throw new Error('XAI provider not available');

package/ts/classes.smartai.ts

@@ -2,6 +2,7 @@ import { Conversation } from './classes.conversation.js';
 import * as plugins from './plugins.js';
 import { AnthropicProvider } from './provider.anthropic.js';
 import { ElevenLabsProvider } from './provider.elevenlabs.js';
+import { MistralProvider } from './provider.mistral.js';
 import { OllamaProvider } from './provider.ollama.js';
 import { OpenAiProvider } from './provider.openai.js';
 import { PerplexityProvider } from './provider.perplexity.js';
@@ -15,12 +16,18 @@ export interface ISmartAiOptions {
   anthropicToken?: string;
   perplexityToken?: string;
   groqToken?: string;
+  mistralToken?: string;
   xaiToken?: string;
   elevenlabsToken?: string;
   exo?: {
     baseUrl?: string;
     apiKey?: string;
   };
+  mistral?: {
+    chatModel?: string;
+    ocrModel?: string;
+    tableFormat?: 'markdown' | 'html';
+  };
   ollama?: {
     baseUrl?: string;
     model?: string;
@@ -32,7 +39,7 @@ export interface ISmartAiOptions {
   };
 }
 
-export type TProvider = 'openai' | 'anthropic' | 'perplexity' | 'ollama' | 'exo' | 'groq' | 'xai' | 'elevenlabs';
+export type TProvider = 'openai' | 'anthropic' | 'perplexity' | 'ollama' | 'exo' | 'groq' | 'mistral' | 'xai' | 'elevenlabs';
 
 export class SmartAi {
   public options: ISmartAiOptions;
@@ -43,6 +50,7 @@ export class SmartAi {
   public ollamaProvider: OllamaProvider;
   public exoProvider: ExoProvider;
   public groqProvider: GroqProvider;
+  public mistralProvider: MistralProvider;
   public xaiProvider: XAIProvider;
   public elevenlabsProvider: ElevenLabsProvider;
 
@@ -75,6 +83,15 @@ export class SmartAi {
       });
       await this.groqProvider.start();
     }
+    if (this.options.mistralToken) {
+      this.mistralProvider = new MistralProvider({
+        mistralToken: this.options.mistralToken,
+        chatModel: this.options.mistral?.chatModel,
+        ocrModel: this.options.mistral?.ocrModel,
+        tableFormat: this.options.mistral?.tableFormat,
+      });
+      await this.mistralProvider.start();
+    }
     if (this.options.xaiToken) {
       this.xaiProvider = new XAIProvider({
         xaiToken: this.options.xaiToken,
@@ -119,6 +136,9 @@ export class SmartAi {
     if (this.groqProvider) {
       await this.groqProvider.stop();
     }
+    if (this.mistralProvider) {
+      await this.mistralProvider.stop();
+    }
     if (this.xaiProvider) {
       await this.xaiProvider.stop();
     }
@@ -150,6 +170,8 @@ export class SmartAi {
         return Conversation.createWithOllama(this);
       case 'groq':
         return Conversation.createWithGroq(this);
+      case 'mistral':
+        return Conversation.createWithMistral(this);
       case 'xai':
         return Conversation.createWithXai(this);
       case 'elevenlabs':

package/ts/index.ts

@@ -4,6 +4,7 @@ export * from './provider.openai.js';
 export * from './provider.anthropic.js';
 export * from './provider.perplexity.js';
 export * from './provider.groq.js';
+export * from './provider.mistral.js';
 export * from './provider.ollama.js';
 export * from './provider.xai.js';
 export * from './provider.exo.js';

package/ts/plugins.ts

@@ -28,9 +28,11 @@ export {
 
 // third party
 import * as anthropic from '@anthropic-ai/sdk';
+import * as mistralai from '@mistralai/mistralai';
 import * as openai from 'openai';
 
 export {
   anthropic,
+  mistralai,
   openai,
 }

package/ts/provider.mistral.ts

@@ -0,0 +1,352 @@
+import * as plugins from './plugins.js';
+import { MultiModalModel } from './abstract.classes.multimodal.js';
+import type {
+  ChatOptions,
+  ChatResponse,
+  ChatMessage,
+  ResearchOptions,
+  ResearchResponse,
+  ImageGenerateOptions,
+  ImageEditOptions,
+  ImageResponse
+} from './abstract.classes.multimodal.js';
+
+export interface IMistralProviderOptions {
+  mistralToken: string;
+  chatModel?: string;       // default: 'mistral-large-latest'
+  ocrModel?: string;        // default: 'mistral-ocr-latest'
+  tableFormat?: 'markdown' | 'html';
+}
+
+export class MistralProvider extends MultiModalModel {
+  private options: IMistralProviderOptions;
+  public mistralClient: plugins.mistralai.Mistral;
+
+  constructor(optionsArg: IMistralProviderOptions) {
+    super();
+    this.options = optionsArg;
+  }
+
+  async start() {
+    await super.start();
+    this.mistralClient = new plugins.mistralai.Mistral({
+      apiKey: this.options.mistralToken,
+    });
+  }
+
+  async stop() {
+    await super.stop();
+  }
+
+  /**
+   * Synchronous chat interaction using Mistral's chat API
+   */
+  public async chat(optionsArg: ChatOptions): Promise<ChatResponse> {
+    // Convert message history to Mistral format
+    const messages: Array<{
+      role: 'system' | 'user' | 'assistant';
+      content: string;
+    }> = [];
+
+    // Add system message first
+    if (optionsArg.systemMessage) {
+      messages.push({
+        role: 'system',
+        content: optionsArg.systemMessage
+      });
+    }
+
+    // Add message history
+    for (const msg of optionsArg.messageHistory) {
+      messages.push({
+        role: msg.role === 'system' ? 'system' : msg.role === 'assistant' ? 'assistant' : 'user',
+        content: msg.content
+      });
+    }
+
+    // Add current user message
+    messages.push({
+      role: 'user',
+      content: optionsArg.userMessage
+    });
+
+    const result = await this.mistralClient.chat.complete({
+      model: this.options.chatModel || 'mistral-large-latest',
+      messages: messages,
+    });
+
+    // Extract content from response
+    const choice = result.choices?.[0];
+    let content = '';
+
+    if (choice?.message?.content) {
+      if (typeof choice.message.content === 'string') {
+        content = choice.message.content;
+      } else if (Array.isArray(choice.message.content)) {
+        // Handle array of content chunks
+        content = choice.message.content
+          .map((chunk: any) => {
+            if (typeof chunk === 'string') return chunk;
+            if (chunk && typeof chunk === 'object' && 'text' in chunk) return chunk.text;
+            return '';
+          })
+          .join('');
+      }
+    }
+
+    return {
+      role: 'assistant',
+      message: content,
+    };
+  }
+
+  /**
+   * Streaming chat using Mistral's streaming API
+   */
+  public async chatStream(input: ReadableStream<Uint8Array>): Promise<ReadableStream<string>> {
+    const decoder = new TextDecoder();
+    let buffer = '';
+    const mistralClient = this.mistralClient;
+    const chatModel = this.options.chatModel || 'mistral-large-latest';
+
+    const transform = new TransformStream<Uint8Array, string>({
+      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);
+
+              // Build messages array
+              const messages: Array<{
+                role: 'system' | 'user' | 'assistant';
+                content: string;
+              }> = [];
+
+              if (message.systemMessage) {
+                messages.push({
+                  role: 'system',
+                  content: message.systemMessage
+                });
+              }
+
+              messages.push({
+                role: message.role === 'assistant' ? 'assistant' : 'user',
+                content: message.content
+              });
+
+              // Use Mistral streaming
+              const stream = await mistralClient.chat.stream({
+                model: chatModel,
+                messages: messages,
+              });
+
+              // Process streaming events
+              for await (const event of stream) {
+                const delta = event.data?.choices?.[0]?.delta;
+                if (delta?.content) {
+                  if (typeof delta.content === 'string') {
+                    controller.enqueue(delta.content);
+                  } else if (Array.isArray(delta.content)) {
+                    for (const chunk of delta.content) {
+                      if (typeof chunk === 'string') {
+                        controller.enqueue(chunk);
+                      } else if (chunk && typeof chunk === 'object' && 'text' in chunk) {
+                        controller.enqueue((chunk as any).text);
+                      }
+                    }
+                  }
+                }
+              }
+            } catch (e) {
+              console.error('Failed to parse message:', e);
+            }
+          }
+        }
+      },
+
+      flush(controller) {
+        if (buffer.trim()) {
+          try {
+            const message = JSON.parse(buffer);
+            controller.enqueue(message.content || '');
+          } catch (e) {
+            console.error('Failed to parse remaining buffer:', e);
+          }
+        }
+      }
+    });
+
+    return input.pipeThrough(transform);
+  }
+
+  /**
+   * Audio generation is not supported by Mistral
+   */
+  public async audio(optionsArg: { message: string }): Promise<NodeJS.ReadableStream> {
+    throw new Error('Audio generation is not supported by Mistral. Please use ElevenLabs or OpenAI provider for audio generation.');
+  }
+
+  /**
+   * Vision using Mistral's OCR API for image analysis
+   */
+  public async vision(optionsArg: { image: Buffer; prompt: string }): Promise<string> {
+    const base64Image = optionsArg.image.toString('base64');
+
+    // Detect image type from buffer header
+    let mimeType = 'image/jpeg';
+    if (optionsArg.image[0] === 0x89 && optionsArg.image[1] === 0x50) {
+      mimeType = 'image/png';
+    } else if (optionsArg.image[0] === 0x47 && optionsArg.image[1] === 0x49) {
+      mimeType = 'image/gif';
+    } else if (optionsArg.image[0] === 0x52 && optionsArg.image[1] === 0x49) {
+      mimeType = 'image/webp';
+    }
+
+    // Use OCR API with image data URL
+    const ocrResult = await this.mistralClient.ocr.process({
+      model: this.options.ocrModel || 'mistral-ocr-latest',
+      document: {
+        imageUrl: `data:${mimeType};base64,${base64Image}`,
+        type: 'image_url',
+      },
+    });
+
+    // Combine markdown from all pages
+    const extractedText = ocrResult.pages.map(page => page.markdown).join('\n\n');
+
+    // If a prompt is provided, use chat to analyze the extracted text
+    if (optionsArg.prompt && optionsArg.prompt.trim()) {
+      const chatResponse = await this.chat({
+        systemMessage: 'You are an assistant analyzing image content. The following is text extracted from an image using OCR.',
+        userMessage: `${optionsArg.prompt}\n\nExtracted content:\n${extractedText}`,
+        messageHistory: [],
+      });
+      return chatResponse.message;
+    }
+
+    return extractedText;
+  }
+
+  /**
+   * Document processing using Mistral's OCR API
+   * PDFs are uploaded via Files API first, then processed with OCR
+   */
+  public async document(optionsArg: {
+    systemMessage: string;
+    userMessage: string;
+    pdfDocuments: Uint8Array[];
+    messageHistory: ChatMessage[];
+  }): Promise<{ message: any }> {
+    const extractedTexts: string[] = [];
+    const uploadedFileIds: string[] = [];
+
+    try {
+      // Process each PDF document using Mistral OCR
+      for (let i = 0; i < optionsArg.pdfDocuments.length; i++) {
+        const pdfDocument = optionsArg.pdfDocuments[i];
+
+        // Upload the PDF to Mistral's Files API first
+        const uploadResult = await this.mistralClient.files.upload({
+          file: {
+            fileName: `document_${i + 1}.pdf`,
+            content: pdfDocument,
+          },
+          purpose: 'ocr',
+        });
+
+        uploadedFileIds.push(uploadResult.id);
+
+        // Now use OCR with the uploaded file
+        const ocrResult = await this.mistralClient.ocr.process({
+          model: this.options.ocrModel || 'mistral-ocr-latest',
+          document: {
+            type: 'file',
+            fileId: uploadResult.id,
+          },
+          tableFormat: this.options.tableFormat || 'markdown',
+        });
+
+        // Combine all page markdown with page separators
+        const pageTexts = ocrResult.pages.map((page, index) => {
+          let pageContent = `--- Page ${index + 1} ---\n${page.markdown}`;
+
+          // Include tables if present
+          if (page.tables && page.tables.length > 0) {
+            pageContent += '\n\n**Tables:**\n' + page.tables.map((t: any) => t.markdown || t.html || '').join('\n');
+          }
+
+          // Include header/footer if present
+          if (page.header) {
+            pageContent = `Header: ${page.header}\n${pageContent}`;
+          }
+          if (page.footer) {
+            pageContent += `\nFooter: ${page.footer}`;
+          }
+
+          return pageContent;
+        }).join('\n\n');
+
+        extractedTexts.push(pageTexts);
+      }
+
+      // Combine all document texts
+      const allDocumentText = extractedTexts.length === 1
+        ? extractedTexts[0]
+        : extractedTexts.map((text, i) => `=== Document ${i + 1} ===\n${text}`).join('\n\n');
+
+      // Use chat API to process the extracted text with the user's query
+      const chatResponse = await this.chat({
+        systemMessage: optionsArg.systemMessage || 'You are a helpful assistant analyzing document content.',
+        userMessage: `${optionsArg.userMessage}\n\n---\nDocument Content:\n${allDocumentText}`,
+        messageHistory: optionsArg.messageHistory,
+      });
+
+      return {
+        message: {
+          role: 'assistant',
+          content: chatResponse.message
+        }
+      };
+    } finally {
+      // Clean up uploaded files
+      for (const fileId of uploadedFileIds) {
+        try {
+          await this.mistralClient.files.delete({ fileId });
+        } catch (cleanupError) {
+          // Ignore cleanup errors - files may have already been auto-deleted
+          console.warn(`Failed to delete temporary file ${fileId}:`, cleanupError);
+        }
+      }
+    }
+  }
+
+  /**
+   * Research is not natively supported by Mistral
+   */
+  public async research(optionsArg: ResearchOptions): Promise<ResearchResponse> {
+    throw new Error('Research/web search is not supported by Mistral. Please use Perplexity or Anthropic provider for research capabilities.');
+  }
+
+  /**
+   * Image generation is not supported by Mistral
+   */
+  public async imageGenerate(optionsArg: ImageGenerateOptions): Promise<ImageResponse> {
+    throw new Error('Image generation is not supported by Mistral. Please use OpenAI provider for image generation.');
+  }
+
+  /**
+   * Image editing is not supported by Mistral
+   */
+  public async imageEdit(optionsArg: ImageEditOptions): Promise<ImageResponse> {
+    throw new Error('Image editing is not supported by Mistral. Please use OpenAI provider for image editing.');
+  }
+}