@push.rocks/smartai 0.5.11 → 0.7.0

package/ts/provider.openai.ts

@@ -9,13 +9,22 @@ export type TChatCompletionRequestMessage = {
 };
 
 import { MultiModalModel } from './abstract.classes.multimodal.js';
+import type {
+  ResearchOptions,
+  ResearchResponse,
+  ImageGenerateOptions,
+  ImageEditOptions,
+  ImageResponse
+} from './abstract.classes.multimodal.js';
 
 export interface IOpenaiProviderOptions {
   openaiToken: string;
   chatModel?: string;
   audioModel?: string;
   visionModel?: string;
-  // Optionally add more model options (e.g., documentModel) if needed.
+  researchModel?: string;
+  imageModel?: string;
+  enableWebSearch?: boolean;
 }
 
 export class OpenAiProvider extends MultiModalModel {
@@ -229,4 +238,218 @@ export class OpenAiProvider extends MultiModalModel {
     const result = await this.openAiApiClient.chat.completions.create(requestParams);
     return result.choices[0].message.content || '';
   }
+
+  public async research(optionsArg: ResearchOptions): Promise<ResearchResponse> {
+    // Determine which model to use - Deep Research API requires specific models
+    let model: string;
+    if (optionsArg.searchDepth === 'deep') {
+      model = this.options.researchModel || 'o4-mini-deep-research-2025-06-26';
+    } else {
+      // For basic/advanced, still use deep research models if web search is needed
+      if (optionsArg.includeWebSearch) {
+        model = this.options.researchModel || 'o4-mini-deep-research-2025-06-26';
+      } else {
+        model = this.options.chatModel || 'gpt-5-mini';
+      }
+    }
+
+    const systemMessage = 'You are a research assistant. Provide comprehensive answers with citations and sources when available.';
+
+    // Prepare request parameters using Deep Research API format
+    const requestParams: any = {
+      model,
+      instructions: systemMessage,
+      input: optionsArg.query
+    };
+
+    // Add web search tool if requested
+    if (optionsArg.includeWebSearch || optionsArg.searchDepth === 'deep') {
+      requestParams.tools = [
+        {
+          type: 'web_search_preview',
+          search_context_size: optionsArg.searchDepth === 'deep' ? 'high' :
+                              optionsArg.searchDepth === 'advanced' ? 'medium' : 'low'
+        }
+      ];
+    }
+
+    // Add background flag for deep research
+    if (optionsArg.background && optionsArg.searchDepth === 'deep') {
+      requestParams.background = true;
+    }
+
+    try {
+      // Execute the research request using Deep Research API
+      const result = await this.openAiApiClient.responses.create(requestParams);
+
+      // Extract the answer from output items
+      let answer = '';
+      const sources: Array<{ url: string; title: string; snippet: string }> = [];
+      const searchQueries: string[] = [];
+
+      // Process output items
+      for (const item of result.output || []) {
+        // Extract message content
+        if (item.type === 'message' && 'content' in item) {
+          const messageItem = item as any;
+          for (const contentItem of messageItem.content || []) {
+            if (contentItem.type === 'output_text' && 'text' in contentItem) {
+              answer += contentItem.text;
+            }
+          }
+        }
+
+        // Extract web search queries
+        if (item.type === 'web_search_call' && 'action' in item) {
+          const searchItem = item as any;
+          if (searchItem.action && searchItem.action.type === 'search' && 'query' in searchItem.action) {
+            searchQueries.push(searchItem.action.query);
+          }
+        }
+      }
+
+      // Parse sources from markdown links in the answer
+      const urlRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+      let match: RegExpExecArray | null;
+
+      while ((match = urlRegex.exec(answer)) !== null) {
+        sources.push({
+          title: match[1],
+          url: match[2],
+          snippet: ''
+        });
+      }
+
+      return {
+        answer,
+        sources,
+        searchQueries: searchQueries.length > 0 ? searchQueries : undefined,
+        metadata: {
+          model,
+          searchDepth: optionsArg.searchDepth || 'basic',
+          tokensUsed: result.usage?.total_tokens
+        }
+      };
+    } catch (error) {
+      console.error('Research API error:', error);
+      throw new Error(`Failed to perform research: ${error.message}`);
+    }
+  }
+
+  /**
+   * Image generation using OpenAI's gpt-image-1 or DALL-E models
+   */
+  public async imageGenerate(optionsArg: ImageGenerateOptions): Promise<ImageResponse> {
+    const model = optionsArg.model || this.options.imageModel || 'gpt-image-1';
+
+    try {
+      const requestParams: any = {
+        model,
+        prompt: optionsArg.prompt,
+        n: optionsArg.n || 1,
+      };
+
+      // Add gpt-image-1 specific parameters
+      if (model === 'gpt-image-1') {
+        if (optionsArg.quality) requestParams.quality = optionsArg.quality;
+        if (optionsArg.size) requestParams.size = optionsArg.size;
+        if (optionsArg.background) requestParams.background = optionsArg.background;
+        if (optionsArg.outputFormat) requestParams.output_format = optionsArg.outputFormat;
+        if (optionsArg.outputCompression !== undefined) requestParams.output_compression = optionsArg.outputCompression;
+        if (optionsArg.moderation) requestParams.moderation = optionsArg.moderation;
+        if (optionsArg.stream !== undefined) requestParams.stream = optionsArg.stream;
+        if (optionsArg.partialImages !== undefined) requestParams.partial_images = optionsArg.partialImages;
+      } else if (model === 'dall-e-3') {
+        // DALL-E 3 specific parameters
+        if (optionsArg.quality) requestParams.quality = optionsArg.quality;
+        if (optionsArg.size) requestParams.size = optionsArg.size;
+        if (optionsArg.style) requestParams.style = optionsArg.style;
+        requestParams.response_format = 'b64_json'; // Always use base64 for consistency
+      } else if (model === 'dall-e-2') {
+        // DALL-E 2 specific parameters
+        if (optionsArg.size) requestParams.size = optionsArg.size;
+        requestParams.response_format = 'b64_json';
+      }
+
+      const result = await this.openAiApiClient.images.generate(requestParams);
+
+      const images = (result.data || []).map(img => ({
+        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
+        }
+      };
+    } catch (error) {
+      console.error('Image generation error:', error);
+      throw new Error(`Failed to generate image: ${error.message}`);
+    }
+  }
+
+  /**
+   * Image editing using OpenAI's gpt-image-1 or DALL-E 2 models
+   */
+  public async imageEdit(optionsArg: ImageEditOptions): Promise<ImageResponse> {
+    const model = optionsArg.model || this.options.imageModel || 'gpt-image-1';
+
+    try {
+      const requestParams: any = {
+        model,
+        image: optionsArg.image,
+        prompt: optionsArg.prompt,
+        n: optionsArg.n || 1,
+      };
+
+      // Add mask if provided
+      if (optionsArg.mask) {
+        requestParams.mask = optionsArg.mask;
+      }
+
+      // Add gpt-image-1 specific parameters
+      if (model === 'gpt-image-1') {
+        if (optionsArg.quality) requestParams.quality = optionsArg.quality;
+        if (optionsArg.size) requestParams.size = optionsArg.size;
+        if (optionsArg.background) requestParams.background = optionsArg.background;
+        if (optionsArg.outputFormat) requestParams.output_format = optionsArg.outputFormat;
+        if (optionsArg.outputCompression !== undefined) requestParams.output_compression = optionsArg.outputCompression;
+        if (optionsArg.stream !== undefined) requestParams.stream = optionsArg.stream;
+        if (optionsArg.partialImages !== undefined) requestParams.partial_images = optionsArg.partialImages;
+      } else if (model === 'dall-e-2') {
+        // DALL-E 2 specific parameters
+        if (optionsArg.size) requestParams.size = optionsArg.size;
+        requestParams.response_format = 'b64_json';
+      }
+
+      const result = await this.openAiApiClient.images.edit(requestParams);
+
+      const images = (result.data || []).map(img => ({
+        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
+        }
+      };
+    } catch (error) {
+      console.error('Image edit error:', error);
+      throw new Error(`Failed to edit image: ${error.message}`);
+    }
+  }
 }

package/ts/provider.perplexity.ts

@@ -1,7 +1,16 @@
 import * as plugins from './plugins.js';
 import * as paths from './paths.js';
 import { MultiModalModel } from './abstract.classes.multimodal.js';
-import type { ChatOptions, ChatResponse, ChatMessage } from './abstract.classes.multimodal.js';
+import type {
+  ChatOptions,
+  ChatResponse,
+  ChatMessage,
+  ResearchOptions,
+  ResearchResponse,
+  ImageGenerateOptions,
+  ImageEditOptions,
+  ImageResponse
+} from './abstract.classes.multimodal.js';
 
 export interface IPerplexityProviderOptions {
   perplexityToken: string;
@@ -168,4 +177,83 @@ export class PerplexityProvider extends MultiModalModel {
   }): Promise<{ message: any }> {
     throw new Error('Document processing is not supported by Perplexity.');
   }
+
+  public async research(optionsArg: ResearchOptions): Promise<ResearchResponse> {
+    // Perplexity has Sonar models that are optimized for search
+    // sonar models: sonar, sonar-pro
+    const model = optionsArg.searchDepth === 'deep' ? 'sonar-pro' : 'sonar';
+
+    try {
+      const response = await fetch('https://api.perplexity.ai/chat/completions', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.options.perplexityToken}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model,
+          messages: [
+            {
+              role: 'system',
+              content: 'You are a helpful research assistant. Provide accurate information with sources.'
+            },
+            {
+              role: 'user',
+              content: optionsArg.query
+            }
+          ],
+          temperature: 0.7,
+          max_tokens: 4000
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Perplexity API error: ${response.statusText}`);
+      }
+
+      const result = await response.json();
+      const answer = result.choices[0].message.content;
+
+      // Parse citations from the response
+      const sources: Array<{ url: string; title: string; snippet: string }> = [];
+
+      // Perplexity includes citations in the format [1], [2], etc. with sources listed
+      // This is a simplified parser - could be enhanced based on actual Perplexity response format
+      if (result.citations) {
+        for (const citation of result.citations) {
+          sources.push({
+            url: citation.url || '',
+            title: citation.title || '',
+            snippet: citation.snippet || ''
+          });
+        }
+      }
+
+      return {
+        answer,
+        sources,
+        metadata: {
+          model,
+          searchDepth: optionsArg.searchDepth || 'basic'
+        }
+      };
+    } catch (error) {
+      console.error('Perplexity research error:', error);
+      throw new Error(`Failed to perform research: ${error.message}`);
+    }
+  }
+
+  /**
+   * Image generation is not supported by Perplexity
+   */
+  public async imageGenerate(optionsArg: ImageGenerateOptions): Promise<ImageResponse> {
+    throw new Error('Image generation is not supported by Perplexity. Please use OpenAI provider for image generation.');
+  }
+
+  /**
+   * Image editing is not supported by Perplexity
+   */
+  public async imageEdit(optionsArg: ImageEditOptions): Promise<ImageResponse> {
+    throw new Error('Image editing is not supported by Perplexity. Please use OpenAI provider for image editing.');
+  }
 }

package/ts/provider.xai.ts

@@ -1,7 +1,16 @@
 import * as plugins from './plugins.js';
 import * as paths from './paths.js';
 import { MultiModalModel } from './abstract.classes.multimodal.js';
-import type { ChatOptions, ChatResponse, ChatMessage } from './abstract.classes.multimodal.js';
+import type {
+  ChatOptions,
+  ChatResponse,
+  ChatMessage,
+  ResearchOptions,
+  ResearchResponse,
+  ImageGenerateOptions,
+  ImageEditOptions,
+  ImageResponse
+} from './abstract.classes.multimodal.js';
 import type { ChatCompletionMessageParam } from 'openai/resources/chat/completions';
 
 export interface IXAIProviderOptions {
@@ -181,4 +190,22 @@ export class XAIProvider extends MultiModalModel {
       message: completion.choices[0]?.message?.content || ''
     };
   }
+
+  public async research(optionsArg: ResearchOptions): Promise<ResearchResponse> {
+    throw new Error('Research capabilities are not yet supported by xAI provider.');
+  }
+
+  /**
+   * Image generation is not supported by xAI
+   */
+  public async imageGenerate(optionsArg: ImageGenerateOptions): Promise<ImageResponse> {
+    throw new Error('Image generation is not supported by xAI. Please use OpenAI provider for image generation.');
+  }
+
+  /**
+   * Image editing is not supported by xAI
+   */
+  public async imageEdit(optionsArg: ImageEditOptions): Promise<ImageResponse> {
+    throw new Error('Image editing is not supported by xAI. Please use OpenAI provider for image editing.');
+  }
 }