@push.rocks/smartai 0.13.2 → 2.0.0

package/ts/abstract.classes.multimodal.ts

@@ -1,240 +0,0 @@
-import * as plugins from './plugins.js';
-
-/**
- * Message format for chat interactions
- */
-export interface ChatMessage {
-  role: 'assistant' | 'user' | 'system';
-  content: string;
-  /** Base64-encoded images for vision-capable models */
-  images?: string[];
-  /** Chain-of-thought reasoning for GPT-OSS models (e.g., Ollama) */
-  reasoning?: string;
-}
-
-/**
- * Options for chat interactions
- */
-export interface ChatOptions {
-  systemMessage: string;
-  userMessage: string;
-  messageHistory: ChatMessage[];
-  /** Base64-encoded images for the current message (vision-capable models) */
-  images?: string[];
-}
-
-/**
- * Options for streaming chat interactions
- */
-export interface StreamingChatOptions extends ChatOptions {
-  /** Callback fired for each token during generation */
-  onToken?: (token: string) => void;
-}
-
-/**
- * Response format for chat interactions
- */
-export interface ChatResponse {
-  role: 'assistant';
-  message: string;
-  /** Chain-of-thought reasoning from reasoning models */
-  reasoning?: string;
-}
-
-/**
- * Options for research interactions
- */
-export interface ResearchOptions {
-  query: string;
-  searchDepth?: 'basic' | 'advanced' | 'deep';
-  maxSources?: number;
-  includeWebSearch?: boolean;
-  background?: boolean;
-}
-
-/**
- * Response format for research interactions
- */
-export interface ResearchResponse {
-  answer: string;
-  sources: Array<{
-    url: string;
-    title: string;
-    snippet: string;
-  }>;
-  searchQueries?: string[];
-  metadata?: any;
-}
-
-/**
- * Options for image generation
- */
-export interface ImageGenerateOptions {
-  prompt: string;
-  model?: 'gpt-image-1' | 'dall-e-3' | 'dall-e-2';
-  quality?: 'low' | 'medium' | 'high' | 'standard' | 'hd' | 'auto';
-  size?: '256x256' | '512x512' | '1024x1024' | '1536x1024' | '1024x1536' | '1792x1024' | '1024x1792' | 'auto';
-  style?: 'vivid' | 'natural';
-  background?: 'transparent' | 'opaque' | 'auto';
-  outputFormat?: 'png' | 'jpeg' | 'webp';
-  outputCompression?: number; // 0-100 for webp/jpeg
-  moderation?: 'low' | 'auto';
-  n?: number; // Number of images to generate
-  stream?: boolean;
-  partialImages?: number; // 0-3 for streaming
-}
-
-/**
- * Options for image editing
- */
-export interface ImageEditOptions {
-  image: Buffer;
-  prompt: string;
-  mask?: Buffer;
-  model?: 'gpt-image-1' | 'dall-e-2';
-  quality?: 'low' | 'medium' | 'high' | 'standard' | 'auto';
-  size?: '256x256' | '512x512' | '1024x1024' | '1536x1024' | '1024x1536' | 'auto';
-  background?: 'transparent' | 'opaque' | 'auto';
-  outputFormat?: 'png' | 'jpeg' | 'webp';
-  outputCompression?: number;
-  n?: number;
-  stream?: boolean;
-  partialImages?: number;
-}
-
-/**
- * Response format for image operations
- */
-export interface ImageResponse {
-  images: Array<{
-    b64_json?: string;
-    url?: string;
-    revisedPrompt?: string;
-  }>;
-  metadata?: {
-    model: string;
-    quality?: string;
-    size?: string;
-    outputFormat?: string;
-    tokensUsed?: number;
-  };
-}
-
-/**
- * Abstract base class for multi-modal AI models.
- * Provides a common interface for different AI providers (OpenAI, Anthropic, Perplexity, Ollama)
- */
-export abstract class MultiModalModel {
-  /**
-   * SmartPdf instance for document processing
-   * Lazy-loaded only when PDF processing is needed to avoid starting browser unnecessarily
-   */
-  protected smartpdfInstance: plugins.smartpdf.SmartPdf | null = null;
-
-  /**
-   * Ensures SmartPdf instance is initialized and ready
-   * Call this before using smartpdfInstance in document processing methods
-   */
-  protected async ensureSmartpdfReady(): Promise<void> {
-    if (!this.smartpdfInstance) {
-      this.smartpdfInstance = new plugins.smartpdf.SmartPdf();
-      await this.smartpdfInstance.start();
-    }
-  }
-
-  /**
-   * Initializes the model and any necessary resources
-   * Should be called before using any other methods
-   */
-  public async start(): Promise<void> {
-    // SmartPdf is now lazy-loaded only when needed for PDF processing
-    // This avoids starting a browser unless document() method is actually used
-  }
-
-  /**
-   * Cleans up any resources used by the model
-   * Should be called when the model is no longer needed
-   */
-  public async stop(): Promise<void> {
-    if (this.smartpdfInstance) {
-      await this.smartpdfInstance.stop();
-      this.smartpdfInstance = null;
-    }
-  }
-
-  /**
-   * Synchronous chat interaction with the model
-   * @param optionsArg Options containing system message, user message, and message history
-   * @returns Promise resolving to the assistant's response
-   */
-  public abstract chat(optionsArg: ChatOptions): Promise<ChatResponse>;
-
-  /**
-   * Streaming interface for chat interactions
-   * Allows for real-time responses from the model
-   * @param input Stream of user messages
-   * @returns Stream of model responses
-   */
-  public abstract chatStream(input: ReadableStream<Uint8Array>): Promise<ReadableStream<string>>;
-
-  /**
-   * Streaming chat with token callback
-   * Calls onToken for each token generated, returns final response
-   * @param optionsArg Options containing system message, user message, message history, and onToken callback
-   * @returns Promise resolving to the assistant's response
-   */
-  public chatStreaming?(optionsArg: StreamingChatOptions): Promise<ChatResponse>;
-
-  /**
-   * Text-to-speech conversion
-   * @param optionsArg Options containing the message to convert to speech
-   * @returns Promise resolving to a readable stream of audio data
-   * @throws Error if the provider doesn't support audio generation
-   */
-  public abstract audio(optionsArg: { message: string }): Promise<NodeJS.ReadableStream>;
-
-  /**
-   * Vision-language processing
-   * @param optionsArg Options containing the image and prompt for analysis
-   * @returns Promise resolving to the model's description or analysis of the image
-   * @throws Error if the provider doesn't support vision tasks
-   */
-  public abstract vision(optionsArg: { image: Buffer; prompt: string }): Promise<string>;
-
-  /**
-   * Document analysis and processing
-   * @param optionsArg Options containing system message, user message, PDF documents, and message history
-   * @returns Promise resolving to the model's analysis of the documents
-   * @throws Error if the provider doesn't support document processing
-   */
-  public abstract document(optionsArg: {
-    systemMessage: string;
-    userMessage: string;
-    pdfDocuments: Uint8Array[];
-    messageHistory: ChatMessage[];
-  }): Promise<{ message: any }>;
-
-  /**
-   * Research and web search capabilities
-   * @param optionsArg Options containing the research query and configuration
-   * @returns Promise resolving to the research results with sources
-   * @throws Error if the provider doesn't support research capabilities
-   */
-  public abstract research(optionsArg: ResearchOptions): Promise<ResearchResponse>;
-
-  /**
-   * Image generation from text prompts
-   * @param optionsArg Options containing the prompt and generation parameters
-   * @returns Promise resolving to the generated image(s)
-   * @throws Error if the provider doesn't support image generation
-   */
-  public abstract imageGenerate(optionsArg: ImageGenerateOptions): Promise<ImageResponse>;
-
-  /**
-   * Image editing and inpainting
-   * @param optionsArg Options containing the image, prompt, and editing parameters
-   * @returns Promise resolving to the edited image(s)
-   * @throws Error if the provider doesn't support image editing
-   */
-  public abstract imageEdit(optionsArg: ImageEditOptions): Promise<ImageResponse>;
-}

package/ts/classes.conversation.ts

@@ -1,176 +0,0 @@
-import type { SmartAi } from "./classes.smartai.js";
-import { OpenAiProvider } from "./provider.openai.js";
-
-type TProcessFunction = (input: string) => Promise<string>;
-
-export interface IConversationOptions {
-  processFunction: TProcessFunction;
-}
-
-/**
- * a conversation
- */
-export class Conversation {
-  // STATIC
-  public static async createWithOpenAi(smartaiRefArg: SmartAi) {
-    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;
-  }
-
-  public static async createWithAnthropic(smartaiRefArg: SmartAi) {
-    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;
-  }
-
-  public static async createWithPerplexity(smartaiRefArg: SmartAi) {
-    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;
-  }
-
-  public static async createWithExo(smartaiRefArg: SmartAi) {
-    if (!smartaiRefArg.exoProvider) {
-      throw new Error('Exo provider not available');
-    }
-    const conversation = new Conversation(smartaiRefArg, {
-      processFunction: async (input) => {
-        return '' // TODO implement proper streaming
-      }
-    });
-    return conversation;
-  }
-
-  public static async createWithOllama(smartaiRefArg: SmartAi) {
-    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;
-  }
-
-  public static async createWithGroq(smartaiRefArg: SmartAi) {
-    if (!smartaiRefArg.groqProvider) {
-      throw new Error('Groq provider not available');
-    }
-    const conversation = new Conversation(smartaiRefArg, {
-      processFunction: async (input) => {
-        return '' // TODO implement proper streaming
-      }
-    });
-    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');
-    }
-    const conversation = new Conversation(smartaiRefArg, {
-      processFunction: async (input) => {
-        return '' // TODO implement proper streaming
-      }
-    });
-    return conversation;
-  }
-
-  public static async createWithElevenlabs(smartaiRefArg: SmartAi) {
-    if (!smartaiRefArg.elevenlabsProvider) {
-      throw new Error('ElevenLabs provider not available');
-    }
-    const conversation = new Conversation(smartaiRefArg, {
-      processFunction: async (input) => {
-        return '' // TODO implement proper streaming
-      }
-    });
-    return conversation;
-  }
-
-  // INSTANCE
-  smartaiRef: SmartAi
-  private systemMessage: string;
-  private processFunction: TProcessFunction;
-  private inputStreamWriter: WritableStreamDefaultWriter<string> | null = null;
-  private outputStreamController: ReadableStreamDefaultController<string> | null = null;
-
-  constructor(smartairefArg: SmartAi, options: IConversationOptions) {
-    this.processFunction = options.processFunction;
-  }
-
-  public async setSystemMessage(systemMessageArg: string) {
-    this.systemMessage = systemMessageArg;
-  }
-
-  private setupOutputStream(): ReadableStream<string> {
-    return new ReadableStream<string>({
-      start: (controller) => {
-        this.outputStreamController = controller;
-      }
-    });
-  }
-
-  private setupInputStream(): WritableStream<string> {
-    const writableStream = new WritableStream<string>({
-      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;
-  }
-
-  public getInputStreamWriter(): WritableStreamDefaultWriter<string> {
-    if (!this.inputStreamWriter) {
-      const inputStream = this.setupInputStream();
-      this.inputStreamWriter = inputStream.getWriter();
-    }
-    return this.inputStreamWriter;
-  }
-
-  public getOutputStream(): ReadableStream<string> {
-    return this.setupOutputStream();
-  }
-}

package/ts/classes.smartai.ts

@@ -1,187 +0,0 @@
-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, type IOllamaModelOptions } from './provider.ollama.js';
-import { OpenAiProvider } from './provider.openai.js';
-import { PerplexityProvider } from './provider.perplexity.js';
-import { ExoProvider } from './provider.exo.js';
-import { GroqProvider } from './provider.groq.js';
-import { XAIProvider } from './provider.xai.js';
-
-
-export interface ISmartAiOptions {
-  openaiToken?: string;
-  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;
-    visionModel?: string;
-    defaultOptions?: IOllamaModelOptions;
-    defaultTimeout?: number;
-  };
-  elevenlabs?: {
-    defaultVoiceId?: string;
-    defaultModelId?: string;
-  };
-}
-
-export type TProvider = 'openai' | 'anthropic' | 'perplexity' | 'ollama' | 'exo' | 'groq' | 'mistral' | 'xai' | 'elevenlabs';
-
-export class SmartAi {
-  public options: ISmartAiOptions;
-
-  public openaiProvider: OpenAiProvider;
-  public anthropicProvider: AnthropicProvider;
-  public perplexityProvider: PerplexityProvider;
-  public ollamaProvider: OllamaProvider;
-  public exoProvider: ExoProvider;
-  public groqProvider: GroqProvider;
-  public mistralProvider: MistralProvider;
-  public xaiProvider: XAIProvider;
-  public elevenlabsProvider: ElevenLabsProvider;
-
-  constructor(optionsArg: ISmartAiOptions) {
-    this.options = optionsArg;
-  }
-
-  public 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,
-      });
-      await this.anthropicProvider.start();
-    }
-    if (this.options.perplexityToken) {
-      this.perplexityProvider = new PerplexityProvider({
-        perplexityToken: this.options.perplexityToken,
-      });
-      await this.perplexityProvider.start();
-    }
-    if (this.options.groqToken) {
-      this.groqProvider = new GroqProvider({
-        groqToken: this.options.groqToken,
-      });
-      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,
-      });
-      await this.xaiProvider.start();
-    }
-    if (this.options.elevenlabsToken) {
-      this.elevenlabsProvider = new ElevenLabsProvider({
-        elevenlabsToken: this.options.elevenlabsToken,
-        defaultVoiceId: this.options.elevenlabs?.defaultVoiceId,
-        defaultModelId: this.options.elevenlabs?.defaultModelId,
-      });
-      await this.elevenlabsProvider.start();
-    }
-    if (this.options.ollama) {
-      this.ollamaProvider = new OllamaProvider({
-        baseUrl: this.options.ollama.baseUrl,
-        model: this.options.ollama.model,
-        visionModel: this.options.ollama.visionModel,
-        defaultOptions: this.options.ollama.defaultOptions,
-        defaultTimeout: this.options.ollama.defaultTimeout,
-      });
-      await this.ollamaProvider.start();
-    }
-    if (this.options.exo) {
-      this.exoProvider = new ExoProvider({
-        exoBaseUrl: this.options.exo.baseUrl,
-        apiKey: this.options.exo.apiKey,
-      });
-      await this.exoProvider.start();
-    }
-  }
-
-  public async stop() {
-    if (this.openaiProvider) {
-      await this.openaiProvider.stop();
-    }
-    if (this.anthropicProvider) {
-      await this.anthropicProvider.stop();
-    }
-    if (this.perplexityProvider) {
-      await this.perplexityProvider.stop();
-    }
-    if (this.groqProvider) {
-      await this.groqProvider.stop();
-    }
-    if (this.mistralProvider) {
-      await this.mistralProvider.stop();
-    }
-    if (this.xaiProvider) {
-      await this.xaiProvider.stop();
-    }
-    if (this.elevenlabsProvider) {
-      await this.elevenlabsProvider.stop();
-    }
-    if (this.ollamaProvider) {
-      await this.ollamaProvider.stop();
-    }
-    if (this.exoProvider) {
-      await this.exoProvider.stop();
-    }
-  }
-  
-  /**
-   * create a new conversation
-   */
-  createConversation(provider: TProvider) {
-    switch (provider) {
-      case 'exo':
-        return Conversation.createWithExo(this);
-      case 'openai':
-        return Conversation.createWithOpenAi(this);
-      case 'anthropic':
-        return Conversation.createWithAnthropic(this);
-      case 'perplexity':
-        return Conversation.createWithPerplexity(this);
-      case 'ollama':
-        return Conversation.createWithOllama(this);
-      case 'groq':
-        return Conversation.createWithGroq(this);
-      case 'mistral':
-        return Conversation.createWithMistral(this);
-      case 'xai':
-        return Conversation.createWithXai(this);
-      case 'elevenlabs':
-        return Conversation.createWithElevenlabs(this);
-      default:
-        throw new Error('Provider not available');
-    }
-  }
-}

package/ts/classes.tts.ts

@@ -1,15 +0,0 @@
-import type { SmartAi } from './classes.smartai.js';
-import * as plugins from './plugins.js';
-
-export class TTS {
-  public static async createWithOpenAi(smartaiRef: SmartAi): Promise<TTS> {
-    return new TTS(smartaiRef);
-  }
-
-  // INSTANCE
-  smartaiRef: SmartAi;
-
-  constructor(smartairefArg: SmartAi) {
-    this.smartaiRef = smartairefArg;
-  }
-}

package/ts/paths.ts

@@ -1,4 +0,0 @@
-import * as plugins from './plugins.js';
-
-export const packageDir = plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), '../');
-export const nogitDir = plugins.path.join(packageDir, './.nogit');