smartai/ts/classes.smartai.ts

import { Conversation } from './classes.conversation.js';
import * as plugins from './plugins.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 class SmartAi {
  public options: ISmartAiOptions;

  public openaiProvider: OpenAiProvider;
  public anthropicProvider: AnthropicProvider;
  public perplexityProvider: PerplexityProvider;
  public ollamaProvider: OllamaProvider;

  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,
      });
    }
  }

  public async stop() {}
  
  /**
   * create a new conversation
   */
  createConversation(provider: TProvider) {
    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');
    }
  }
}