@xagent-ai/cli 1.2.2 → 1.3.0

package/src/ai-client/types.ts

@@ -0,0 +1,345 @@
+// ============================================================================
+// Core Types
+// ============================================================================
+
+/**
+ * AI Provider type identifier
+ */
+export type AIProviderType = 'openai' | 'anthropic' | 'remote';
+
+/**
+ * Tool call from OpenAI format
+ */
+export interface ToolCall {
+  id?: string;
+  type?: string;
+  function?: {
+    name?: string;
+    arguments?: string;
+  };
+}
+
+/**
+ * Unified message interface
+ */
+export interface Message {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string | Array<ContentBlock>;
+  reasoning_content?: string;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+}
+
+/**
+ * Content block for multi-modal messages
+ */
+export interface ContentBlock {
+  type: 'text' | 'tool_use' | 'tool_result' | 'thinking' | 'image' | 'image_url';
+  text?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  tool_use_id?: string;
+  content?: string;
+  thinking?: string;
+  image_url?: { url: string };
+}
+
+/**
+ * Tool definition
+ */
+export interface ToolDefinition {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters?: Record<string, unknown>;
+  };
+}
+
+/**
+ * Tool choice options
+ */
+export type ToolChoice = 'auto' | 'none' | { type: 'function'; function: { name: string } };
+
+/**
+ * Completion options
+ */
+export interface CompletionOptions {
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+  tools?: ToolDefinition[];
+  toolChoice?: ToolChoice;
+  thinkingTokens?: number;
+  signal?: AbortSignal;
+  // Remote-specific options
+  taskId?: string;
+  status?: 'begin' | 'continue' | 'end' | 'cancel' | 'timeout' | 'failure';
+  conversationId?: string;
+  context?: {
+    cwd?: string;
+    workspace?: string;
+    recentFiles?: string[];
+  };
+  toolResults?: Array<{
+    toolUseId: string;
+    content: string;
+    isError?: boolean;
+  }>;
+  llmModelName?: string;
+  vlmModelName?: string;
+}
+
+/**
+ * Token usage information
+ */
+export interface TokenUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+}
+
+/**
+ * Unified completion response
+ */
+export interface CompletionResponse {
+  id: string;
+  object: 'chat.completion';
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: Message;
+    finish_reason: StopReason;
+  }>;
+  usage?: TokenUsage;
+}
+
+/**
+ * Stop reason types
+ */
+export type StopReason = 'stop' | 'length' | 'tool_calls' | 'content_filter';
+
+/**
+ * Stream event types
+ */
+export interface StreamEvent {
+  type: 'text_delta' | 'reasoning_delta' | 'toolcall_delta' | 'done' | 'error';
+  delta?: string;
+  content?: string;
+  partial?: Message;
+  reason?: StopReason;
+  error?: Error;
+}
+
+// ============================================================================
+// Provider Configuration Types
+// ============================================================================
+
+/**
+ * Base provider configuration
+ */
+export interface BaseProviderConfig {
+  type: AIProviderType;
+  model?: string;
+  showDebugInfo?: boolean;
+}
+
+/**
+ * OpenAI compatible provider configuration
+ */
+export interface OpenAIConfig extends BaseProviderConfig {
+  type: 'openai';
+  apiKey?: string;
+  baseUrl?: string;
+  organization?: string;
+}
+
+/**
+ * Anthropic compatible provider configuration
+ */
+export interface AnthropicConfig extends BaseProviderConfig {
+  type: 'anthropic';
+  apiKey?: string;
+  baseUrl?: string;
+  /** Custom headers to add to each request */
+  extraHeaders?: Record<string, string>;
+}
+
+/**
+ * Remote provider configuration (xAgent Web Service)
+ */
+export interface RemoteConfig extends BaseProviderConfig {
+  type: 'remote';
+  authToken?: string;
+  baseUrl?: string;  // Optional, defaults to xAgent web service
+}
+
+/**
+ * Unified configuration union
+ */
+export type AIConfig = OpenAIConfig | AnthropicConfig | RemoteConfig;
+
+/**
+ * Check if config is OpenAI type
+ */
+export function isOpenAIConfig(config: AIConfig): config is OpenAIConfig {
+  return config.type === 'openai';
+}
+
+/**
+ * Check if config is Anthropic type
+ */
+export function isAnthropicConfig(config: AIConfig): config is AnthropicConfig {
+  return config.type === 'anthropic';
+}
+
+/**
+ * Check if config is Remote type
+ */
+export function isRemoteConfig(config: AIConfig): config is RemoteConfig {
+  return config.type === 'remote';
+}
+
+// ============================================================================
+// Provider Interface
+// ============================================================================
+
+/**
+ * AI Provider interface - all providers must implement this
+ */
+export interface AIProvider {
+  /** Provider type identifier */
+  readonly type: AIProviderType;
+
+  /** Get list of available models */
+  getModels(): Promise<Model[]>;
+
+  /** Non-streaming chat completion */
+  complete(messages: Message[], options?: CompletionOptions): Promise<CompletionResponse>;
+
+  /** Streaming chat completion */
+  stream(messages: Message[], options?: CompletionOptions): AsyncIterable<StreamEvent>;
+
+  /** Abort ongoing request */
+  abort(): void;
+
+  /** Close provider and release resources */
+  close(): Promise<void>;
+}
+
+/**
+ * Model information
+ */
+export interface Model {
+  id: string;
+  name: string;
+  provider: AIProviderType;
+  contextWindow?: number;
+  maxTokens?: number;
+  supportsStreaming?: boolean;
+  supportsTools?: boolean;
+  supportsThinking?: boolean;
+}
+
+/**
+ * Provider registration entry
+ */
+export interface ProviderRegistryEntry {
+  create: (config: AIConfig) => AIProvider;
+  models: Model[];
+}
+
+// ============================================================================
+// Utility Functions (moved from ai-client.ts)
+// ============================================================================
+
+/**
+ * Thinking mode levels
+ */
+export type ThinkingMode = 'none' | 'normal' | 'hard' | 'mega' | 'ultra';
+
+/**
+ * Detect thinking mode from user input
+ */
+export function detectThinkingKeywords(text: string): ThinkingMode {
+  const ultraKeywords = ['super think', 'extreme think', 'deep think', 'full think', 'ultra think', 'careful think',
+    'ultrathink', 'think really super hard', 'think intensely'];
+  const megaKeywords = ['strong think', 'powerful think', 'think hard', 'try hard to think', 'think well', 'think carefully',
+    'megathink', 'think really hard', 'think a lot'];
+  const hardKeywords = ['think again', 'think more', 'think clearly', 'think thoroughly', 'consider carefully',
+    'think about it', 'think more', 'think harder'];
+  const normalKeywords = ['think', 'think', 'consider', 'think'];
+
+  const lowerText = text.toLowerCase();
+
+  if (ultraKeywords.some(keyword => lowerText.includes(keyword.toLowerCase()))) {
+    return 'ultra';
+  } else if (megaKeywords.some(keyword => lowerText.includes(keyword.toLowerCase()))) {
+    return 'mega';
+  } else if (hardKeywords.some(keyword => lowerText.includes(keyword.toLowerCase()))) {
+    return 'hard';
+  } else if (normalKeywords.some(keyword => lowerText.includes(keyword.toLowerCase()))) {
+    return 'normal';
+  }
+
+  return 'none';
+}
+
+/**
+ * Get thinking token count for a mode
+ */
+export function getThinkingTokens(mode: ThinkingMode): number {
+  const tokensMap: Record<ThinkingMode, number> = {
+    none: 0,
+    normal: 2000,
+    hard: 4000,
+    mega: 10000,
+    ultra: 32000
+  };
+  return tokensMap[mode];
+}
+
+// ============================================================================
+// Remote-Specific Interface Extension
+// ============================================================================
+
+/**
+ * Remote models response format
+ */
+export interface RemoteModelsResponse {
+  llm: Model[];
+  vlm: Model[];
+}
+
+/**
+ * Extended interface for remote provider with task management methods
+ */
+export interface RemoteTaskManager {
+  completeTask(taskId: string): Promise<void>;
+  cancelTask(taskId: string): Promise<void>;
+  failTask(taskId: string, reason: 'timeout' | 'failure'): Promise<void>;
+  invokeVLM(messages: Message[], systemPrompt: string, options?: { taskId?: string; status?: 'begin' | 'continue'; signal?: AbortSignal }): Promise<string>;
+  /** Get models including both LLM and VLM for remote provider */
+  getRemoteModels(): Promise<RemoteModelsResponse>;
+}
+
+/**
+ * Combined interface for remote provider
+ */
+export interface RemoteAIProvider extends AIProvider, RemoteTaskManager {}
+
+// ============================================================================
+// Error Types
+// ============================================================================
+
+/**
+ * Token invalid error
+ */
+export class TokenInvalidError extends Error {
+  constructor(message: string = 'Authentication token is invalid or expired') {
+    super(message);
+    this.name = 'TokenInvalidError';
+  }
+}

package/src/ai-client-factory.ts

@@ -0,0 +1,204 @@
+/**
+ * AI Client Factory
+ * Creates mode-aware AI client (local or remote) based on authentication configuration.
+ *
+ * This module provides a unified interface for different AI providers.
+ * Supports OpenAI, Anthropic (including MiniMax), and Remote (xAgent Web Service).
+ *
+ * Usage:
+ *   import { createAIClient, type AIClientInterface } from './ai-client-factory.js';
+ *   const aiClient = createAIClient(authConfig);
+ *   const response = await aiClient.chatCompletion(messages, { model: 'gpt-4' });
+ */
+
+import type { Message, CompletionOptions, CompletionResponse, AIConfig, RemoteTaskManager, Model, RemoteModelsResponse } from './ai-client/types.js';
+import { AuthConfig, AuthType } from './types.js';
+import { ProviderFactory, createOpenAI, createAnthropic, createRemote, type AIProvider } from './ai-client/index.js';
+import type { RemoteAIProvider } from './ai-client/types.js';
+
+/**
+ * Unified AI client interface for both local and remote modes.
+ * Provides consistent API regardless of the underlying implementation.
+ * Includes optional methods for remote task management.
+ */
+export interface AIClientInterface {
+  getModels(): Promise<Model[]>;
+  chatCompletion(messages: Message[], options?: CompletionOptions): Promise<CompletionResponse>;
+  compress(messages: Message[], options?: { maxTokens?: number; temperature?: number }): Promise<CompletionResponse>;
+  // Optional remote task management methods (only available in remote mode)
+  completeTask?(taskId: string): Promise<void>;
+  cancelTask?(taskId: string): Promise<void>;
+  failTask?(taskId: string, reason: 'timeout' | 'failure'): Promise<void>;
+  // VLM invocation for image analysis (only available in remote mode)
+  invokeVLM?(messages: Message[], systemPrompt: string, options?: { taskId?: string; status?: 'begin' | 'continue'; signal?: AbortSignal }): Promise<string>;
+  // Get remote models including both LLM and VLM (only available in remote mode)
+  getRemoteModels?(): Promise<RemoteModelsResponse>;
+}
+
+/**
+ * Adapter to make AIProvider compatible with AIClientInterface
+ */
+class ProviderAdapter implements AIClientInterface {
+  private provider: AIProvider;
+
+  constructor(provider: AIProvider) {
+    this.provider = provider;
+  }
+
+  async getModels(): Promise<Model[]> {
+    return this.provider.getModels();
+  }
+
+  async chatCompletion(messages: Message[], options?: CompletionOptions): Promise<CompletionResponse> {
+    return this.provider.complete(messages, options);
+  }
+
+  async compress(messages: Message[], options?: { model?: string; maxTokens?: number; temperature?: number }): Promise<CompletionResponse> {
+    return this.provider.complete(messages, {
+      model: options?.model,
+      temperature: options?.temperature,
+      maxTokens: options?.maxTokens,
+    });
+  }
+
+  // Optional methods - not available in local mode
+  completeTask?(taskId: string): Promise<void> {
+    throw new Error('completeTask is only available in remote mode');
+  }
+
+  cancelTask?(taskId: string): Promise<void> {
+    throw new Error('cancelTask is only available in remote mode');
+  }
+
+  failTask?(taskId: string, reason: 'timeout' | 'failure'): Promise<void> {
+    throw new Error('failTask is only available in remote mode');
+  }
+
+  invokeVLM?(messages: Message[], systemPrompt: string, options?: { taskId?: string; status?: 'begin' | 'continue'; signal?: AbortSignal }): Promise<string> {
+    throw new Error('invokeVLM is only available in remote mode');
+  }
+
+  getRemoteModels?(): Promise<RemoteModelsResponse> {
+    throw new Error('getRemoteModels is only available in remote mode');
+  }
+}
+
+/**
+ * Adapter for remote provider with task management
+ */
+class RemoteProviderAdapter implements AIClientInterface, RemoteTaskManager {
+  private provider: RemoteAIProvider;
+
+  constructor(provider: RemoteAIProvider) {
+    this.provider = provider;
+  }
+
+  async getModels(): Promise<Model[]> {
+    return this.provider.getModels();
+  }
+
+  async chatCompletion(messages: Message[], options?: CompletionOptions): Promise<CompletionResponse> {
+    return this.provider.complete(messages, options);
+  }
+
+  async compress(messages: Message[], options?: { model?: string; maxTokens?: number; temperature?: number }): Promise<CompletionResponse> {
+    return this.provider.complete(messages, {
+      model: options?.model,
+      temperature: options?.temperature,
+      maxTokens: options?.maxTokens,
+    });
+  }
+
+  async completeTask(taskId: string): Promise<void> {
+    return this.provider.completeTask(taskId);
+  }
+
+  async cancelTask(taskId: string): Promise<void> {
+    return this.provider.cancelTask(taskId);
+  }
+
+  async failTask(taskId: string, reason: 'timeout' | 'failure'): Promise<void> {
+    return this.provider.failTask(taskId, reason);
+  }
+
+  async invokeVLM(messages: Message[], systemPrompt: string, options?: { taskId?: string; status?: 'begin' | 'continue'; signal?: AbortSignal }): Promise<string> {
+    return this.provider.invokeVLM(messages, systemPrompt, options);
+  }
+
+  async getRemoteModels(): Promise<RemoteModelsResponse> {
+    return this.provider.getRemoteModels();
+  }
+}
+
+/**
+ * Create AI client based on authentication configuration.
+ *
+ * @param authConfig - Authentication configuration from config manager
+ * @returns AIClientInterface - Unified AI client interface
+ *
+ * Behavior:
+ *   - OAUTH_XAGENT (remote mode): Creates Remote provider that forwards requests to web backend
+ *   - OPENAI_COMPATIBLE (local mode): Creates OpenAI or Anthropic provider for direct API calls
+ *   - API_KEY: Creates OpenAI provider with custom baseUrl
+ */
+export function createAIClient(authConfig: AuthConfig): AIClientInterface {
+  let config: AIConfig;
+
+  if (authConfig.type === AuthType.OAUTH_XAGENT) {
+    // Remote mode: use xAgent web service
+    config = {
+      type: 'remote',
+      authToken: authConfig.apiKey || '',
+      baseUrl: authConfig.xagentApiBaseUrl || 'https://app.xagent.cn',
+    };
+  } else if (authConfig.baseUrl?.includes('anthropic') || 
+             authConfig.baseUrl?.includes('minimax') ||
+             authConfig.baseUrl?.includes('minimaxi')) {
+    // Anthropic compatible mode (includes MiniMax)
+    config = {
+      type: 'anthropic',
+      apiKey: authConfig.apiKey || '',
+      baseUrl: authConfig.baseUrl || 'https://api.anthropic.com',
+      model: authConfig.modelName || 'claude-sonnet-4-20250514',
+    };
+  } else {
+    // Default to OpenAI compatible mode
+    config = {
+      type: 'openai',
+      apiKey: authConfig.apiKey || '',
+      baseUrl: authConfig.baseUrl || 'https://api.openai.com/v1',
+      model: authConfig.modelName || 'gpt-4o',
+    };
+  }
+
+  const provider = ProviderFactory.create(config);
+
+  // Use RemoteProviderAdapter for remote mode to support task management
+  if (config.type === 'remote') {
+    const remoteProvider = ProviderFactory.createRemote(config);
+    return new RemoteProviderAdapter(remoteProvider);
+  }
+
+  return new ProviderAdapter(provider);
+}
+
+/**
+ * Create AI provider directly from config (new API)
+ */
+export function createAIProvider(config: AIConfig): AIProvider {
+  return ProviderFactory.create(config);
+}
+
+/**
+ * Get all available models from all providers
+ */
+export function getAllModels() {
+  return ProviderFactory.getModels();
+}
+
+/**
+ * Get available provider types
+ */
+export function getProviderTypes(): string[] {
+  return ProviderFactory.getProviderTypes();
+}