@xagent-ai/cli 1.2.2 → 1.3.0

package/src/ai-client/factory.ts

@@ -0,0 +1,151 @@
+import type { AIProvider, AIConfig, RemoteAIProvider, Model } from './types.js';
+import { isOpenAIConfig, isAnthropicConfig, isRemoteConfig } from './types.js';
+import { createOpenAIProvider } from './providers/openai.js';
+import { createAnthropicProvider } from './providers/anthropic.js';
+import { createRemoteProvider, type RemoteProvider } from './providers/remote.js';
+import { getAllModels, listProviderTypes } from './registry.js';
+
+// ============================================================================
+// Provider Factory
+// ============================================================================
+
+/**
+ * AI Provider Factory
+ * Creates provider instances based on configuration
+ */
+export class ProviderFactory {
+  /**
+   * Create a provider instance from configuration
+   */
+  static create(config: AIConfig): AIProvider {
+    if (isOpenAIConfig(config)) {
+      return createOpenAIProvider(config);
+    }
+
+    if (isAnthropicConfig(config)) {
+      return createAnthropicProvider(config);
+    }
+
+    if (isRemoteConfig(config)) {
+      return createRemoteProvider(config);
+    }
+
+    throw new Error(`Unknown provider type: ${(config as any).type}`);
+  }
+
+  /**
+   * Create a remote provider instance (with task management)
+   */
+  static createRemote(config: AIConfig): RemoteAIProvider {
+    if (!isRemoteConfig(config)) {
+      throw new Error('createRemote requires a remote configuration');
+    }
+    return createRemoteProvider(config);
+  }
+
+  /**
+   * Get all available models
+   */
+  static getModels(): Model[] {
+    return getAllModels();
+  }
+
+  /**
+   * Get available provider types
+   */
+  static getProviderTypes(): string[] {
+    return listProviderTypes();
+  }
+
+  /**
+   * Check if provider type is supported
+   */
+  static isSupported(type: string): boolean {
+    const types = listProviderTypes();
+    return types.includes(type);
+  }
+
+  /**
+   * Get default configuration for a provider type
+   */
+  static getDefaultConfig(type: string, apiKey?: string, baseUrl?: string): AIConfig {
+    switch (type) {
+      case 'openai':
+        return {
+          type: 'openai',
+          apiKey,
+          baseUrl: baseUrl || 'https://api.openai.com/v1',
+        };
+
+      case 'anthropic':
+        return {
+          type: 'anthropic',
+          apiKey,
+          baseUrl: baseUrl || 'https://api.anthropic.com',
+        };
+
+      case 'remote':
+        return {
+          type: 'remote',
+          authToken: apiKey,
+          baseUrl: baseUrl || 'https://app.xagent.cn',
+        };
+
+      default:
+        throw new Error(`Unknown provider type: ${type}`);
+    }
+  }
+}
+
+// ============================================================================
+// Factory Helpers
+// ============================================================================
+
+/**
+ * Create OpenAI provider with configuration
+ */
+export function createOpenAI(apiKey?: string, baseUrl?: string, model?: string): AIProvider {
+  return ProviderFactory.create({
+    type: 'openai',
+    apiKey,
+    baseUrl,
+    model,
+  });
+}
+
+/**
+ * Create Anthropic provider with configuration
+ */
+export function createAnthropic(apiKey?: string, baseUrl?: string, model?: string): AIProvider {
+  return ProviderFactory.create({
+    type: 'anthropic',
+    apiKey,
+    baseUrl,
+    model,
+  });
+}
+
+/**
+ * Create Remote provider with configuration
+ */
+export function createRemote(authToken?: string, baseUrl?: string): AIProvider {
+  return ProviderFactory.create({
+    type: 'remote',
+    authToken,
+    baseUrl,
+  });
+}
+
+/**
+ * Get all available models
+ */
+export function getModels(): Model[] {
+  return ProviderFactory.getModels();
+}
+
+/**
+ * Get available provider types
+ */
+export function getProviderTypes(): string[] {
+  return ProviderFactory.getProviderTypes();
+}

package/src/ai-client/index.ts

@@ -0,0 +1,61 @@
+// ============================================================================
+// AI Module - Unified Entry Point
+// ============================================================================
+//
+// This module provides a unified interface for different AI providers.
+// Supports OpenAI, Anthropic (including MiniMax), and Remote (xAgent Web Service).
+//
+// Usage:
+//   import { createProvider, type AIProvider } from './ai-client/index.js';
+//
+//   const provider = createProvider({
+//     type: 'anthropic',
+//     apiKey: process.env.ANTHROPIC_API_KEY,
+//     baseUrl: 'https://api.minimax.chat/anthropic',  // MiniMax example
+//   });
+//
+//   const response = await provider.complete(messages, { model: 'MiniMax-M2' });
+//
+// ============================================================================
+
+// Types
+export * from './types.js';
+
+// Registry
+export * from './registry.js';
+
+// Factory
+export * from './factory.js';
+
+// Providers
+export { OpenAIProvider, createOpenAIProvider } from './providers/openai.js';
+export { AnthropicProvider, createAnthropicProvider } from './providers/anthropic.js';
+export { RemoteProvider, createRemoteProvider } from './providers/remote.js';
+
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+
+import type { AIProvider, AIConfig } from './types.js';
+import { ProviderFactory } from './factory.js';
+
+/**
+ * Create an AI provider from configuration
+ */
+export function createProvider(config: AIConfig): AIProvider {
+  return ProviderFactory.create(config);
+}
+
+/**
+ * Get all available models
+ */
+export function getAllModels() {
+  return ProviderFactory.getModels();
+}
+
+/**
+ * Get available provider types
+ */
+export function getProviderTypes() {
+  return ProviderFactory.getProviderTypes();
+}

package/src/ai-client/providers/anthropic.ts

@@ -0,0 +1,466 @@
+import axios, { AxiosInstance } from 'axios';
+import https from 'https';
+import type {
+  AIProvider,
+  AnthropicConfig,
+  Message,
+  ContentBlock,
+  CompletionOptions,
+  CompletionResponse,
+  StreamEvent,
+  Model,
+} from '../types';
+import { getLogger } from '../../logger.js';
+
+const logger = getLogger();
+
+// ============================================================================
+// Anthropic Provider
+// ============================================================================
+
+/**
+ * Anthropic Compatible Provider
+ * Supports Anthropic official API and MiniMax (which uses Anthropic format)
+ */
+export class AnthropicProvider implements AIProvider {
+  readonly type = 'anthropic';
+
+  private client: AxiosInstance;
+  private config: AnthropicConfig;
+  private abortController: AbortController | null = null;
+
+  constructor(config: AnthropicConfig) {
+    this.config = config;
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'anthropic-version': '2023-06-01',
+    };
+
+    if (config.apiKey) {
+      headers['x-api-key'] = config.apiKey;
+    }
+
+    // Add extra headers if provided (for MiniMax and other compatible APIs)
+    if (config.extraHeaders) {
+      Object.assign(headers, config.extraHeaders);
+    }
+
+    this.client = axios.create({
+      baseURL: config.baseUrl || 'https://api.anthropic.com',
+      headers,
+      timeout: 300000,
+      httpsAgent: new https.Agent({ rejectUnauthorized: false }),
+    });
+  }
+
+  /**
+   * Get available models
+   */
+  async getModels(): Promise<Model[]> {
+    return ANTHROPIC_MODELS;
+  }
+
+  /**
+   * Non-streaming completion
+   */
+  async complete(
+    messages: Message[],
+    options?: CompletionOptions
+  ): Promise<CompletionResponse> {
+    const model = options?.model || this.config.model || 'claude-sonnet-4-20250514';
+    const showDebug = this.config.showDebugInfo ?? false;
+
+    const { system, messages: anthropicMessages } = this.convertToAnthropicFormat(messages);
+
+    const requestBody: Record<string, unknown> = {
+      model,
+      messages: anthropicMessages,
+      temperature: options?.temperature ?? 1.0,
+      stream: false,
+      max_tokens: options?.maxTokens,
+    };
+
+    if (system) {
+      requestBody.system = system;
+    }
+
+    if (options?.tools && options.tools.length > 0) {
+      requestBody.tools = options.tools.map(tool => ({
+        name: tool.function.name,
+        description: tool.function.description,
+        input_schema: tool.function.parameters || { type: 'object', properties: {} },
+      }));
+
+      const toolChoice = options.toolChoice;
+      if (toolChoice === 'none') {
+        requestBody.tool_choice = { type: 'auto' };
+      } else if (toolChoice && typeof toolChoice === 'object' && 'function' in toolChoice) {
+        requestBody.tool_choice = { type: 'tool', tool: { name: toolChoice.function.name } };
+      } else {
+        requestBody.tool_choice = { type: 'auto' };
+      }
+    }
+
+    if (options?.thinkingTokens && options.thinkingTokens > 0) {
+      requestBody.thinking = { type: 'enabled', budget_tokens: options.thinkingTokens };
+    }
+
+    if (showDebug) {
+      this.debugRequest('Anthropic', model, anthropicMessages, system);
+    }
+
+    try {
+      const response = await this.client.post('/v1/messages', requestBody, {
+        signal: options?.signal,
+      });
+      return this.convertResponse(response.data, model);
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  /**
+   * Streaming completion
+   */
+  async *stream(
+    messages: Message[],
+    options?: CompletionOptions
+  ): AsyncIterable<StreamEvent> {
+    const model = options?.model || this.config.model || 'claude-sonnet-4-20250514';
+    const showDebug = this.config.showDebugInfo ?? false;
+
+    const { system, messages: anthropicMessages } = this.convertToAnthropicFormat(messages);
+
+    const requestBody: Record<string, unknown> = {
+      model,
+      messages: anthropicMessages,
+      temperature: options?.temperature ?? 1.0,
+      stream: true,
+      max_tokens: options?.maxTokens,
+    };
+
+    if (system) {
+      requestBody.system = system;
+    }
+
+    if (options?.tools && options.tools.length > 0) {
+      requestBody.tools = options.tools.map(tool => ({
+        name: tool.function.name,
+        description: tool.function.description,
+        input_schema: tool.function.parameters || { type: 'object', properties: {} },
+      }));
+      requestBody.tool_choice = { type: 'auto' };
+    }
+
+    if (options?.thinkingTokens && options.thinkingTokens > 0) {
+      requestBody.thinking = { type: 'enabled', budget_tokens: options.thinkingTokens };
+    }
+
+    if (showDebug) {
+      logger.debug(`[Anthropic] Starting stream with model: ${model}`);
+    }
+
+    this.abortController = new AbortController();
+
+    try {
+      const response = await this.client.post('/v1/messages', requestBody, {
+        responseType: 'stream',
+        signal: options?.signal || this.abortController.signal,
+      });
+
+      let buffer = '';
+
+      for await (const chunk of response.data) {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          const trimmedLine = line.trim();
+          if (!trimmedLine) continue;
+
+          if (trimmedLine.startsWith('data: ')) {
+            const data = trimmedLine.slice(6);
+            try {
+              const event = JSON.parse(data);
+
+              if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                yield { type: 'text_delta', delta: event.delta.text };
+              }
+
+              if (event.type === 'content_block_delta' && event.delta?.type === 'thinking_delta') {
+                yield { type: 'reasoning_delta', delta: event.delta.thinking };
+              }
+
+              if (event.type === 'content_block_delta' && event.delta?.type === 'tool_use_delta') {
+                const toolDelta = event.delta;
+                yield {
+                  type: 'toolcall_delta',
+                  delta: JSON.stringify({
+                    id: toolDelta.id,
+                    name: toolDelta.name,
+                    input: toolDelta.input,
+                  }),
+                };
+              }
+
+              if (event.type === 'message_stop') {
+                yield { type: 'done', reason: 'stop' };
+              }
+
+              if (event.type === 'message_delta' && event.delta?.stop_reason) {
+                yield { type: 'done', reason: this.convertStopReason(event.delta.stop_reason) };
+              }
+            } catch {
+              // Ignore parse errors
+            }
+          }
+        }
+      }
+    } catch (error) {
+      if (axios.isCancel(error)) {
+        yield { type: 'done', reason: 'stop' };
+      } else {
+        yield { type: 'error', error: error as Error };
+      }
+    }
+  }
+
+  /**
+   * Abort ongoing request
+   */
+  abort(): void {
+    this.abortController?.abort();
+    this.abortController = null;
+  }
+
+  /**
+   * Close provider
+   */
+  async close(): Promise<void> {
+    this.abort();
+  }
+
+  // --------------------------------------------------------------------------
+
+  /**
+   * Convert messages to Anthropic format
+   */
+  private convertToAnthropicFormat(
+    messages: Message[]
+  ): { system: string; messages: Array<{ role: string; content: ContentBlock[] }> } {
+    const systemMessages = messages.filter(m => m.role === 'system');
+    const otherMessages = messages.filter(m => m.role !== 'system');
+
+    const systemContent = systemMessages[0]?.content;
+    const system = typeof systemContent === 'string' ? systemContent : '';
+
+    const anthropicMessages: Array<{ role: string; content: ContentBlock[] }> = [];
+
+    for (const msg of otherMessages) {
+      const blocks: ContentBlock[] = [];
+
+      // Handle tool result messages
+      if (msg.role === 'tool' && msg.tool_call_id) {
+        blocks.push({
+          type: 'tool_result',
+          tool_use_id: msg.tool_call_id,
+          content: typeof msg.content === 'string'
+            ? msg.content
+            : JSON.stringify(msg.content),
+        });
+      } else if (typeof msg.content === 'string') {
+        blocks.push({ type: 'text', text: msg.content });
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === 'text' && 'text' in block) {
+            blocks.push({ type: 'text', text: (block as any).text });
+          } else if (block.type === 'tool_use') {
+            blocks.push({
+              type: 'tool_use',
+              id: (block as any).id,
+              name: (block as any).function?.name || (block as any).name,
+              input: (block as any).function?.arguments || (block as any).input,
+            });
+          } else if (block.type === 'tool_result') {
+            blocks.push({
+              type: 'tool_result',
+              tool_use_id: (block as any).tool_call_id || (block as any).tool_use_id,
+              content: typeof (block as any).content === 'string'
+                ? (block as any).content
+                : JSON.stringify((block as any).content),
+            });
+          } else if (block.type === 'thinking') {
+            blocks.push({ type: 'thinking', thinking: (block as any).thinking });
+          }
+        }
+      }
+
+      // Handle tool_calls from OpenAI format
+      if (msg.tool_calls) {
+        for (const tc of msg.tool_calls as any[]) {
+          blocks.push({
+            type: 'tool_use',
+            id: tc.id,
+            name: tc.function?.name || '',
+            input: typeof tc.function?.arguments === 'string'
+              ? JSON.parse(tc.function?.arguments)
+              : tc.function?.arguments || {},
+          });
+        }
+      }
+
+      if (blocks.length > 0) {
+        anthropicMessages.push({
+          role: msg.role === 'tool' ? 'user' : msg.role,
+          content: blocks,
+        });
+      }
+    }
+
+    return { system, messages: anthropicMessages };
+  }
+
+  /**
+   * Convert Anthropic response to unified format
+   */
+  private convertResponse(data: any, model: string): CompletionResponse {
+    const content = data.content || [];
+    let textContent = '';
+    let reasoningContent = '';
+    const toolCalls: any[] = [];
+
+    // Handle tool calls from content blocks
+    for (const block of content) {
+      if (block.type === 'text') {
+        textContent += block.text || '';
+      } else if (block.type === 'thinking') {
+        reasoningContent += block.thinking || '';
+      } else if (block.type === 'tool_use') {
+        toolCalls.push({
+          id: block.id,
+          type: 'function',
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input || {}),
+          },
+        });
+      }
+    }
+
+    // Handle tool calls from top-level field (some APIs return here too)
+    const topLevelToolCalls = data.tool_calls;
+    if (topLevelToolCalls && Array.isArray(topLevelToolCalls)) {
+      for (const tc of topLevelToolCalls) {
+        toolCalls.push({
+          id: tc.id,
+          type: tc.type || 'function',
+          function: {
+            name: tc.function?.name || '',
+            arguments: tc.function?.arguments || '',
+          },
+        });
+      }
+    }
+
+    return {
+      id: data.id || `anthropic-${Date.now()}`,
+      object: 'chat.completion',
+      created: Math.floor(Date.now() / 1000),
+      model: data.model || model,
+      choices: [{
+        index: 0,
+        message: {
+          role: 'assistant',
+          content: textContent,
+          reasoning_content: reasoningContent || undefined,
+          tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+        },
+        finish_reason: this.convertStopReason(data.stop_reason),
+      }],
+      usage: data.usage ? {
+        prompt_tokens: data.usage.input_tokens || 0,
+        completion_tokens: data.usage.output_tokens || 0,
+        total_tokens: (data.usage.input_tokens || 0) + (data.usage.output_tokens || 0),
+      } : undefined,
+    };
+  }
+
+  /**
+   * Convert Anthropic stop reason to unified format
+   */
+  private convertStopReason(reason: string | undefined): 'stop' | 'length' | 'tool_calls' | 'content_filter' {
+    switch (reason) {
+      case 'end_turn':
+      case 'stop':
+        return 'stop';
+      case 'max_tokens':
+        return 'length';
+      case 'tool_use':
+        return 'tool_calls';
+      default:
+        return 'stop';
+    }
+  }
+
+  /**
+   * Debug request output
+   */
+  private debugRequest(
+    provider: string,
+    model: string,
+    messages: Array<{ role: string; content: ContentBlock[] }>,
+    system?: string
+  ): void {
+    console.log(`\n╔══════════════════════════════════════════════════════════╗`);
+    console.log(`║              AI REQUEST DEBUG (${provider})                  ║`);
+    console.log(`╚══════════════════════════════════════════════════════════╝`);
+    console.log(`📦 Model: ${model}`);
+    console.log(`💬 Messages: ${messages.length}`);
+    if (system) console.log(`📝 System: ${system.slice(0, 100)}...`);
+    console.log('─'.repeat(60));
+    console.log('\n📤 Sending request...\n');
+  }
+
+  /**
+   * Handle errors
+   */
+  private handleError(error: any): Error {
+    if (error.response) {
+      return new Error(`Anthropic API Error: ${error.response.status} - ${JSON.stringify(error.response.data)}`);
+    }
+    if (error.request) {
+      return new Error('Anthropic API Error: Network error - No response received');
+    }
+    return new Error(`Anthropic API Error: ${error.message}`);
+  }
+}
+
+// ============================================================================
+// Anthropic Models
+// ============================================================================
+
+const ANTHROPIC_MODELS: Model[] = [
+  { id: 'claude-sonnet-4-20250514', name: 'Claude Sonnet 4', provider: 'anthropic', contextWindow: 200000, supportsTools: true, supportsThinking: true, supportsStreaming: true },
+  { id: 'claude-haiku-3-20250506', name: 'Claude Haiku 3', provider: 'anthropic', contextWindow: 200000, supportsTools: true, supportsStreaming: true },
+  { id: 'claude-opus-4-20250501', name: 'Claude Opus 4', provider: 'anthropic', contextWindow: 200000, supportsTools: true, supportsThinking: true, supportsStreaming: true },
+  { id: 'claude-sonnet-4', name: 'Claude Sonnet 4', provider: 'anthropic', contextWindow: 200000, supportsTools: true, supportsThinking: true, supportsStreaming: true },
+  { id: 'claude-haiku-3', name: 'Claude Haiku 3', provider: 'anthropic', contextWindow: 200000, supportsTools: true, supportsStreaming: true },
+  // MiniMax models (uses Anthropic format)
+  { id: 'MiniMax-M2', name: 'MiniMax-M2', provider: 'anthropic', contextWindow: 200000, supportsTools: true, supportsStreaming: true },
+  { id: 'MiniMax-M2-8k', name: 'MiniMax-M2-8K', provider: 'anthropic', contextWindow: 8000, supportsTools: true, supportsStreaming: true },
+  { id: 'MiniMax-M2-32k', name: 'MiniMax-M2-32K', provider: 'anthropic', contextWindow: 32000, supportsTools: true, supportsStreaming: true },
+  { id: 'MiniMax-M2-128k', name: 'MiniMax-M2-128K', provider: 'anthropic', contextWindow: 128000, supportsTools: true, supportsStreaming: true },
+];
+
+// ============================================================================
+// Factory Function
+// ============================================================================
+
+/**
+ * Create Anthropic provider instance
+ */
+export function createAnthropicProvider(config: AnthropicConfig): AIProvider {
+  return new AnthropicProvider(config);
+}