@push.rocks/smartai 0.13.3 → 2.0.0

package/ts_document/index.ts

@@ -0,0 +1,61 @@
+import * as plugins from './plugins.js';
+import type { LanguageModelV3 } from '@ai-sdk/provider';
+import type { ModelMessage } from 'ai';
+
+let smartpdfInstance: InstanceType<typeof plugins.smartpdf.SmartPdf> | null = null;
+
+async function ensureSmartpdf(): Promise<InstanceType<typeof plugins.smartpdf.SmartPdf>> {
+  if (!smartpdfInstance) {
+    smartpdfInstance = new plugins.smartpdf.SmartPdf();
+    await smartpdfInstance.start();
+  }
+  return smartpdfInstance;
+}
+
+export interface IDocumentOptions {
+  model: LanguageModelV3;
+  systemMessage?: string;
+  userMessage: string;
+  pdfDocuments: Uint8Array[];
+  messageHistory?: ModelMessage[];
+}
+
+export async function analyzeDocuments(options: IDocumentOptions): Promise<string> {
+  const pdf = await ensureSmartpdf();
+
+  const imagePages: Uint8Array[] = [];
+  for (const doc of options.pdfDocuments) {
+    const pages = await pdf.convertPDFToPngBytes(doc);
+    imagePages.push(...pages);
+  }
+
+  // Filter out empty buffers
+  const validPages = imagePages.filter(page => page && page.length > 0);
+
+  const result = await plugins.generateText({
+    model: options.model,
+    system: options.systemMessage,
+    messages: [
+      ...(options.messageHistory ?? []),
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: options.userMessage },
+          ...validPages.map(page => ({
+            type: 'image' as const,
+            image: page,
+            mimeType: 'image/png' as const,
+          })),
+        ],
+      },
+    ],
+  });
+  return result.text;
+}
+
+export async function stopSmartpdf(): Promise<void> {
+  if (smartpdfInstance) {
+    await smartpdfInstance.stop();
+    smartpdfInstance = null;
+  }
+}

package/ts_document/plugins.ts

@@ -0,0 +1,3 @@
+import { generateText } from 'ai';
+import * as smartpdf from '@push.rocks/smartpdf';
+export { generateText, smartpdf };

package/ts_image/index.ts

@@ -0,0 +1,147 @@
+import * as plugins from './plugins.js';
+
+export interface IImageGenerateOptions {
+  apiKey: string;
+  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;
+  moderation?: 'low' | 'auto';
+  n?: number;
+  stream?: boolean;
+  partialImages?: number;
+}
+
+export interface IImageEditOptions {
+  apiKey: string;
+  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;
+}
+
+export interface IImageResponse {
+  images: Array<{
+    b64_json?: string;
+    url?: string;
+    revisedPrompt?: string;
+  }>;
+  metadata?: {
+    model: string;
+    quality?: string;
+    size?: string;
+    outputFormat?: string;
+    tokensUsed?: number;
+  };
+}
+
+export async function generateImage(options: IImageGenerateOptions): Promise<IImageResponse> {
+  const client = new plugins.OpenAI({ apiKey: options.apiKey });
+  const model = options.model || 'gpt-image-1';
+
+  const requestParams: Record<string, unknown> = {
+    model,
+    prompt: options.prompt,
+    n: options.n || 1,
+  };
+
+  if (model === 'gpt-image-1') {
+    if (options.quality) requestParams.quality = options.quality;
+    if (options.size) requestParams.size = options.size;
+    if (options.background) requestParams.background = options.background;
+    if (options.outputFormat) requestParams.output_format = options.outputFormat;
+    if (options.outputCompression !== undefined) requestParams.output_compression = options.outputCompression;
+    if (options.moderation) requestParams.moderation = options.moderation;
+    if (options.stream !== undefined) requestParams.stream = options.stream;
+    if (options.partialImages !== undefined) requestParams.partial_images = options.partialImages;
+  } else if (model === 'dall-e-3') {
+    if (options.quality) requestParams.quality = options.quality;
+    if (options.size) requestParams.size = options.size;
+    if (options.style) requestParams.style = options.style;
+    requestParams.response_format = 'b64_json';
+  } else if (model === 'dall-e-2') {
+    if (options.size) requestParams.size = options.size;
+    requestParams.response_format = 'b64_json';
+  }
+
+  const result: any = await client.images.generate(requestParams as any);
+
+  const images = (result.data || []).map((img: any) => ({
+    b64_json: img.b64_json,
+    url: img.url,
+    revisedPrompt: img.revised_prompt,
+  }));
+
+  return {
+    images,
+    metadata: {
+      model,
+      quality: result.quality,
+      size: result.size,
+      outputFormat: result.output_format,
+      tokensUsed: result.usage?.total_tokens,
+    },
+  };
+}
+
+export async function editImage(options: IImageEditOptions): Promise<IImageResponse> {
+  const client = new plugins.OpenAI({ apiKey: options.apiKey });
+  const model = options.model || 'gpt-image-1';
+
+  const imageFile = await plugins.toFile(options.image, 'image.png', { type: 'image/png' });
+
+  const requestParams: Record<string, unknown> = {
+    model,
+    image: imageFile,
+    prompt: options.prompt,
+    n: options.n || 1,
+  };
+
+  if (options.mask) {
+    requestParams.mask = await plugins.toFile(options.mask, 'mask.png', { type: 'image/png' });
+  }
+
+  if (model === 'gpt-image-1') {
+    if (options.quality) requestParams.quality = options.quality;
+    if (options.size) requestParams.size = options.size;
+    if (options.background) requestParams.background = options.background;
+    if (options.outputFormat) requestParams.output_format = options.outputFormat;
+    if (options.outputCompression !== undefined) requestParams.output_compression = options.outputCompression;
+    if (options.stream !== undefined) requestParams.stream = options.stream;
+    if (options.partialImages !== undefined) requestParams.partial_images = options.partialImages;
+  } else if (model === 'dall-e-2') {
+    if (options.size) requestParams.size = options.size;
+    requestParams.response_format = 'b64_json';
+  }
+
+  const result: any = await client.images.edit(requestParams as any);
+
+  const images = (result.data || []).map((img: any) => ({
+    b64_json: img.b64_json,
+    url: img.url,
+    revisedPrompt: img.revised_prompt,
+  }));
+
+  return {
+    images,
+    metadata: {
+      model,
+      quality: result.quality,
+      size: result.size,
+      outputFormat: result.output_format,
+      tokensUsed: result.usage?.total_tokens,
+    },
+  };
+}

package/ts_image/plugins.ts

@@ -0,0 +1,3 @@
+import OpenAI from 'openai';
+import { toFile } from 'openai';
+export { OpenAI, toFile };

package/ts_research/index.ts

@@ -0,0 +1,120 @@
+import * as plugins from './plugins.js';
+
+export interface IResearchOptions {
+  apiKey: string;
+  query: string;
+  searchDepth?: 'basic' | 'advanced' | 'deep';
+  maxSources?: number;
+  allowedDomains?: string[];
+  blockedDomains?: string[];
+}
+
+export interface IResearchResponse {
+  answer: string;
+  sources: Array<{ url: string; title: string; snippet: string }>;
+  searchQueries?: string[];
+  metadata?: Record<string, unknown>;
+}
+
+export async function research(options: IResearchOptions): Promise<IResearchResponse> {
+  const client = new plugins.Anthropic({ apiKey: options.apiKey });
+
+  const systemMessage = `You are a research assistant with web search capabilities.
+Provide comprehensive, well-researched answers with citations and sources.
+When searching the web, be thorough and cite your sources accurately.`;
+
+  // Build web search tool config
+  const webSearchTool: any = {
+    type: 'web_search_20250305',
+    name: 'web_search',
+  };
+
+  if (options.maxSources) {
+    webSearchTool.max_uses = options.maxSources;
+  }
+  if (options.allowedDomains?.length) {
+    webSearchTool.allowed_domains = options.allowedDomains;
+  } else if (options.blockedDomains?.length) {
+    webSearchTool.blocked_domains = options.blockedDomains;
+  }
+
+  const result = await client.messages.create({
+    model: 'claude-sonnet-4-5-20250929',
+    system: systemMessage,
+    messages: [
+      { role: 'user' as const, content: options.query },
+    ],
+    max_tokens: 20000,
+    temperature: 0.7,
+    tools: [webSearchTool],
+  });
+
+  // Extract answer, sources, and search queries
+  let answer = '';
+  const sources: Array<{ url: string; title: string; snippet: string }> = [];
+  const searchQueries: string[] = [];
+
+  for (const block of result.content) {
+    const b: any = block;
+    if ('text' in b) {
+      answer += b.text;
+
+      // Extract citations if present
+      if (b.citations && Array.isArray(b.citations)) {
+        for (const citation of b.citations) {
+          if (citation.type === 'web_search_result_location') {
+            sources.push({
+              title: citation.title || '',
+              url: citation.url || '',
+              snippet: citation.cited_text || '',
+            });
+          }
+        }
+      }
+    } else if (b.type === 'server_tool_use') {
+      if (b.name === 'web_search' && b.input?.query) {
+        searchQueries.push(b.input.query);
+      }
+    } else if (b.type === 'web_search_tool_result') {
+      if (Array.isArray(b.content)) {
+        for (const item of b.content) {
+          if (item.type === 'web_search_result') {
+            if (!sources.some(s => s.url === item.url)) {
+              sources.push({
+                title: item.title || '',
+                url: item.url || '',
+                snippet: '',
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Fallback: parse markdown links if no citations found
+  if (sources.length === 0) {
+    const urlRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+    let match: RegExpExecArray | null;
+    while ((match = urlRegex.exec(answer)) !== null) {
+      sources.push({
+        title: match[1],
+        url: match[2],
+        snippet: '',
+      });
+    }
+  }
+
+  const usage: any = result.usage;
+  return {
+    answer,
+    sources,
+    searchQueries: searchQueries.length > 0 ? searchQueries : undefined,
+    metadata: {
+      model: 'claude-sonnet-4-5-20250929',
+      searchDepth: options.searchDepth || 'basic',
+      tokensUsed: usage?.output_tokens,
+      webSearchesPerformed: usage?.server_tool_use?.web_search_requests ?? 0,
+    },
+  };
+}

package/ts_research/plugins.ts

@@ -0,0 +1,2 @@
+import Anthropic from '@anthropic-ai/sdk';
+export { Anthropic };

package/ts_vision/index.ts

@@ -0,0 +1,29 @@
+import * as plugins from './plugins.js';
+import type { LanguageModelV3 } from '@ai-sdk/provider';
+
+export interface IVisionOptions {
+  model: LanguageModelV3;
+  image: Buffer | Uint8Array;
+  prompt: string;
+  mediaType?: 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif';
+}
+
+export async function analyzeImage(options: IVisionOptions): Promise<string> {
+  const result = await plugins.generateText({
+    model: options.model,
+    messages: [
+      {
+        role: 'user',
+        content: [
+          { type: 'text', text: options.prompt },
+          {
+            type: 'image',
+            image: options.image,
+            mediaType: options.mediaType ?? 'image/jpeg',
+          },
+        ],
+      },
+    ],
+  });
+  return result.text;
+}

package/ts_vision/plugins.ts

@@ -0,0 +1,2 @@
+import { generateText } from 'ai';
+export { generateText };

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

@@ -1,212 +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;
-    moderation?: 'low' | 'auto';
-    n?: number;
-    stream?: boolean;
-    partialImages?: number;
-}
-/**
- * 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 declare 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;
-    /**
-     * Ensures SmartPdf instance is initialized and ready
-     * Call this before using smartpdfInstance in document processing methods
-     */
-    protected ensureSmartpdfReady(): Promise<void>;
-    /**
-     * Initializes the model and any necessary resources
-     * Should be called before using any other methods
-     */
-    start(): Promise<void>;
-    /**
-     * Cleans up any resources used by the model
-     * Should be called when the model is no longer needed
-     */
-    stop(): Promise<void>;
-    /**
-     * 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
-     */
-    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
-     */
-    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
-     */
-    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
-     */
-    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
-     */
-    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
-     */
-    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
-     */
-    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
-     */
-    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
-     */
-    abstract imageEdit(optionsArg: ImageEditOptions): Promise<ImageResponse>;
-}

package/dist_ts/abstract.classes.multimodal.js

@@ -1,43 +0,0 @@
-import * as plugins from './plugins.js';
-/**
- * Abstract base class for multi-modal AI models.
- * Provides a common interface for different AI providers (OpenAI, Anthropic, Perplexity, Ollama)
- */
-export class MultiModalModel {
-    constructor() {
-        /**
-         * SmartPdf instance for document processing
-         * Lazy-loaded only when PDF processing is needed to avoid starting browser unnecessarily
-         */
-        this.smartpdfInstance = null;
-    }
-    /**
-     * Ensures SmartPdf instance is initialized and ready
-     * Call this before using smartpdfInstance in document processing methods
-     */
-    async ensureSmartpdfReady() {
-        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
-     */
-    async start() {
-        // 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
-     */
-    async stop() {
-        if (this.smartpdfInstance) {
-            await this.smartpdfInstance.stop();
-            this.smartpdfInstance = null;
-        }
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QuY2xhc3Nlcy5tdWx0aW1vZGFsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvYWJzdHJhY3QuY2xhc3Nlcy5tdWx0aW1vZGFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBMEh4Qzs7O0dBR0c7QUFDSCxNQUFNLE9BQWdCLGVBQWU7SUFBckM7UUFDRTs7O1dBR0c7UUFDTyxxQkFBZ0IsR0FBcUMsSUFBSSxDQUFDO0lBNEd0RSxDQUFDO0lBMUdDOzs7T0FHRztJQUNPLEtBQUssQ0FBQyxtQkFBbUI7UUFDakMsSUFBSSxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO1lBQzNCLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxJQUFJLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDeEQsTUFBTSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDdEMsQ0FBQztJQUNILENBQUM7SUFFRDs7O09BR0c7SUFDSSxLQUFLLENBQUMsS0FBSztRQUNoQixrRUFBa0U7UUFDbEUsMkVBQTJFO0lBQzdFLENBQUM7SUFFRDs7O09BR0c7SUFDSSxLQUFLLENBQUMsSUFBSTtRQUNmLElBQUksSUFBSSxDQUFDLGdCQUFnQixFQUFFLENBQUM7WUFDMUIsTUFBTSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDbkMsSUFBSSxDQUFDLGdCQUFnQixHQUFHLElBQUksQ0FBQztRQUMvQixDQUFDO0lBQ0gsQ0FBQztDQTZFRiJ9

package/dist_ts/classes.conversation.d.ts

@@ -1,31 +0,0 @@
-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 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;
-    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 {};