@push.rocks/smartai 0.6.1 → 0.7.0

package/ts/provider.openai.ts

@@ -9,7 +9,13 @@ export type TChatCompletionRequestMessage = {
 };
 
 import { MultiModalModel } from './abstract.classes.multimodal.js';
-import type { ResearchOptions, ResearchResponse } from './abstract.classes.multimodal.js';
+import type {
+  ResearchOptions,
+  ResearchResponse,
+  ImageGenerateOptions,
+  ImageEditOptions,
+  ImageResponse
+} from './abstract.classes.multimodal.js';
 
 export interface IOpenaiProviderOptions {
   openaiToken: string;
@@ -17,6 +23,7 @@ export interface IOpenaiProviderOptions {
   audioModel?: string;
   visionModel?: string;
   researchModel?: string;
+  imageModel?: string;
   enableWebSearch?: boolean;
 }
 
@@ -233,52 +240,37 @@ export class OpenAiProvider extends MultiModalModel {
   }
 
   public async research(optionsArg: ResearchOptions): Promise<ResearchResponse> {
-    // Determine which model to use based on search depth
+    // 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 {
-      model = this.options.chatModel || 'gpt-5-mini';
+      // 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';
+      }
     }
 
-    // Prepare the request parameters
+    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,
-      messages: [
-        {
-          role: 'system',
-          content: 'You are a research assistant. Provide comprehensive answers with citations and sources when available.'
-        },
-        {
-          role: 'user',
-          content: optionsArg.query
-        }
-      ],
-      temperature: 0.7
+      instructions: systemMessage,
+      input: optionsArg.query
     };
 
-    // Add web search tools if requested
+    // Add web search tool if requested
     if (optionsArg.includeWebSearch || optionsArg.searchDepth === 'deep') {
       requestParams.tools = [
         {
-          type: 'function',
-          function: {
-            name: 'web_search',
-            description: 'Search the web for information',
-            parameters: {
-              type: 'object',
-              properties: {
-                query: {
-                  type: 'string',
-                  description: 'The search query'
-                }
-              },
-              required: ['query']
-            }
-          }
+          type: 'web_search_preview',
+          search_context_size: optionsArg.searchDepth === 'deep' ? 'high' :
+                              optionsArg.searchDepth === 'advanced' ? 'medium' : 'low'
         }
       ];
-      requestParams.tool_choice = 'auto';
     }
 
     // Add background flag for deep research
@@ -287,14 +279,36 @@ export class OpenAiProvider extends MultiModalModel {
     }
 
     try {
-      // Execute the research request
-      const result = await this.openAiApiClient.chat.completions.create(requestParams);
-
-      // Extract the answer
-      const answer = result.choices[0].message.content || '';
+      // Execute the research request using Deep Research API
+      const result = await this.openAiApiClient.responses.create(requestParams);
 
-      // Parse sources from the response (OpenAI often includes URLs in markdown format)
+      // 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;
 
@@ -302,27 +316,10 @@ export class OpenAiProvider extends MultiModalModel {
         sources.push({
           title: match[1],
           url: match[2],
-          snippet: '' // OpenAI doesn't provide snippets in standard responses
+          snippet: ''
         });
       }
 
-      // Extract search queries if tools were used
-      const searchQueries: string[] = [];
-      if (result.choices[0].message.tool_calls) {
-        for (const toolCall of result.choices[0].message.tool_calls) {
-          if ('function' in toolCall && toolCall.function.name === 'web_search') {
-            try {
-              const args = JSON.parse(toolCall.function.arguments);
-              if (args.query) {
-                searchQueries.push(args.query);
-              }
-            } catch (e) {
-              // Ignore parsing errors
-            }
-          }
-        }
-      }
-
       return {
         answer,
         sources,
@@ -338,4 +335,121 @@ export class OpenAiProvider extends MultiModalModel {
       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, ResearchOptions, ResearchResponse } 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;
@@ -233,4 +242,18 @@ export class PerplexityProvider extends MultiModalModel {
       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, ResearchOptions, ResearchResponse } 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 {
@@ -185,4 +194,18 @@ export class XAIProvider extends MultiModalModel {
   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.');
+  }
 }

package/readme.research.md

@@ -1,177 +0,0 @@
-# SmartAI Research API Implementation
-
-This document describes the new research capabilities added to the SmartAI library, enabling web search and deep research features for OpenAI and Anthropic providers.
-
-## Features Added
-
-### 1. Research Method Interface
-
-Added a new `research()` method to the `MultiModalModel` abstract class with the following interfaces:
-
-```typescript
-interface ResearchOptions {
-  query: string;
-  searchDepth?: 'basic' | 'advanced' | 'deep';
-  maxSources?: number;
-  includeWebSearch?: boolean;
-  background?: boolean;
-}
-
-interface ResearchResponse {
-  answer: string;
-  sources: Array<{
-    url: string;
-    title: string;
-    snippet: string;
-  }>;
-  searchQueries?: string[];
-  metadata?: any;
-}
-```
-
-### 2. OpenAI Provider Research Implementation
-
-The OpenAI provider now supports:
-- **Deep Research API** with models:
-  - `o3-deep-research-2025-06-26` (comprehensive analysis)
-  - `o4-mini-deep-research-2025-06-26` (lightweight, faster)
-- **Web Search** for standard models (gpt-5, o3, o3-pro, o4-mini)
-- **Background processing** for async deep research tasks
-
-### 3. Anthropic Provider Research Implementation
-
-The Anthropic provider now supports:
-- **Web Search API** with Claude models
-- **Domain filtering** (allow/block lists)
-- **Progressive searches** for comprehensive research
-- **Citation extraction** from responses
-
-### 4. Perplexity Provider Research Implementation
-
-The Perplexity provider implements research using:
-- **Sonar models** for standard searches
-- **Sonar Pro** for deep research
-- Built-in citation support
-
-### 5. Other Providers
-
-Added research method stubs to:
-- Groq Provider
-- Ollama Provider
-- xAI Provider
-- Exo Provider
-
-These providers throw a "not yet supported" error when research is called, maintaining interface compatibility.
-
-## Usage Examples
-
-### Basic Research with OpenAI
-
-```typescript
-import { OpenAiProvider } from '@push.rocks/smartai';
-
-const openai = new OpenAiProvider({
-  openaiToken: 'your-api-key',
-  researchModel: 'o4-mini-deep-research-2025-06-26'
-});
-
-await openai.start();
-
-const result = await openai.research({
-  query: 'What are the latest developments in quantum computing?',
-  searchDepth: 'basic',
-  includeWebSearch: true
-});
-
-console.log(result.answer);
-console.log('Sources:', result.sources);
-```
-
-### Deep Research with OpenAI
-
-```typescript
-const deepResult = await openai.research({
-  query: 'Comprehensive analysis of climate change mitigation strategies',
-  searchDepth: 'deep',
-  background: true
-});
-```
-
-### Research with Anthropic
-
-```typescript
-import { AnthropicProvider } from '@push.rocks/smartai';
-
-const anthropic = new AnthropicProvider({
-  anthropicToken: 'your-api-key',
-  enableWebSearch: true,
-  searchDomainAllowList: ['nature.com', 'science.org']
-});
-
-await anthropic.start();
-
-const result = await anthropic.research({
-  query: 'Latest breakthroughs in CRISPR gene editing',
-  searchDepth: 'advanced'
-});
-```
-
-### Research with Perplexity
-
-```typescript
-import { PerplexityProvider } from '@push.rocks/smartai';
-
-const perplexity = new PerplexityProvider({
-  perplexityToken: 'your-api-key'
-});
-
-const result = await perplexity.research({
-  query: 'Current state of autonomous vehicle technology',
-  searchDepth: 'deep' // Uses Sonar Pro model
-});
-```
-
-## Configuration Options
-
-### OpenAI Provider
-- `researchModel`: Specify deep research model (default: `o4-mini-deep-research-2025-06-26`)
-- `enableWebSearch`: Enable web search for standard models
-
-### Anthropic Provider
-- `enableWebSearch`: Enable web search capabilities
-- `searchDomainAllowList`: Array of allowed domains
-- `searchDomainBlockList`: Array of blocked domains
-
-## API Pricing
-
-- **OpenAI Deep Research**: $10 per 1,000 calls
-- **Anthropic Web Search**: $10 per 1,000 searches + standard token costs
-- **Perplexity Sonar**: $5 per 1,000 searches (Sonar Pro)
-
-## Testing
-
-Run the test suite:
-
-```bash
-pnpm test test/test.research.ts
-```
-
-All providers have been tested to ensure:
-- Research methods are properly exposed
-- Interfaces are correctly typed
-- Unsupported providers throw appropriate errors
-
-## Next Steps
-
-Future enhancements could include:
-1. Implementing Google Gemini Grounding API support
-2. Adding Brave Search API integration
-3. Implementing retry logic for rate limits
-4. Adding caching for repeated queries
-5. Supporting batch research operations
-
-## Notes
-
-- The implementation maintains backward compatibility
-- All existing methods continue to work unchanged
-- Research capabilities are optional and don't affect existing functionality