nova-terminal-assistant 0.1.0

package/src/core/model/ModelClient.ts

@@ -0,0 +1,217 @@
+// ============================================================================
+// ModelClient - Unified LLM client abstraction
+// ============================================================================
+
+import type {
+  Message,
+  ContentBlock,
+  ToolUseContent,
+  TextContent,
+  ToolCallId,
+  SessionId,
+} from '../types/session.js';
+import type { ToolDefinition } from '../types/tools.js';
+import { ModelError, RateLimitError, NovaError } from '../types/errors.js';
+import { AnthropicProvider } from './providers/AnthropicProvider.js';
+import { OpenAIProvider } from './providers/OpenAIProvider.js';
+import { OllamaProvider } from './providers/OllamaProvider.js';
+import { OllamaCloudProvider } from './providers/OllamaCloudProvider.js';
+import { CodingPlanProvider, type CodingPlanPlatform } from './providers/CodingPlanProvider.js';
+import type { ModelProvider, ModelRequestOptions, ModelResponse, StreamEvent } from './types.js';
+
+export interface CreateModelClientOptions {
+  provider: 'anthropic' | 'openai' | 'azure' | 'ollama' | 'ollama-cloud' | 'coding-plan' | 'custom';
+  apiKey?: string;
+  baseUrl?: string;
+  model: string;
+  maxTokens?: number;
+  temperature?: number;
+  organizationId?: string;
+  apiVersion?: string;
+  /** Coding Plan platform (required when provider is 'coding-plan') */
+  codingPlanPlatform?: CodingPlanPlatform;
+}
+
+export class ModelClient {
+  private provider: ModelProvider;
+  private model: string;
+  private maxTokens: number;
+  private temperature: number;
+
+  constructor(options: CreateModelClientOptions) {
+    this.model = options.model;
+    this.maxTokens = options.maxTokens ?? 4096;
+    this.temperature = options.temperature ?? 0.7;
+
+    switch (options.provider) {
+      case 'anthropic':
+        if (!options.apiKey) {
+          throw new NovaError('API key is required for Anthropic provider', 'AUTH_ERROR');
+        }
+        this.provider = new AnthropicProvider({
+          apiKey: options.apiKey,
+          baseUrl: options.baseUrl,
+          model: options.model,
+          apiVersion: options.apiVersion,
+        });
+        break;
+
+      case 'openai':
+        if (!options.apiKey) {
+          throw new NovaError('API key is required for OpenAI provider', 'AUTH_ERROR');
+        }
+        this.provider = new OpenAIProvider({
+          apiKey: options.apiKey,
+          baseUrl: options.baseUrl,
+          organizationId: options.organizationId,
+          model: options.model,
+        });
+        break;
+
+      case 'azure':
+        if (!options.apiKey) {
+          throw new NovaError('API key is required for Azure OpenAI provider', 'AUTH_ERROR');
+        }
+        // Azure uses OpenAI-compatible SDK with custom baseUrl and apiVersion
+        this.provider = new OpenAIProvider({
+          apiKey: options.apiKey,
+          baseUrl: options.baseUrl,
+          organizationId: options.organizationId,
+          model: options.model,
+        });
+        break;
+
+      case 'ollama':
+        // Ollama doesn't require an API key; uses localhost by default
+        this.provider = new OllamaProvider({
+          baseUrl: options.baseUrl || 'http://localhost:11434',
+          model: options.model,
+        });
+        break;
+
+      case 'ollama-cloud':
+        // Ollama Cloud: hosted models via ollama.com with API key
+        if (!options.apiKey) {
+          throw new NovaError('API key is required for Ollama Cloud provider. Run: nova auth set ollama-cloud', 'AUTH_ERROR');
+        }
+        this.provider = new OllamaCloudProvider({
+          apiKey: options.apiKey,
+          baseUrl: options.baseUrl || 'https://ollama.com',
+          model: options.model,
+        });
+        break;
+
+      case 'coding-plan':
+        // Coding Plan: Chinese AI coding platforms (Alibaba, Tencent, Volcengine, etc.)
+        if (!options.apiKey) {
+          throw new NovaError('API key is required for Coding Plan provider. Get your key from the platform console.', 'AUTH_ERROR');
+        }
+        if (!options.codingPlanPlatform) {
+          throw new NovaError('codingPlanPlatform is required for Coding Plan provider. Options: alibaba, tencent, volcengine, baidu, kimi, zhipu, minimax', 'AUTH_ERROR');
+        }
+        this.provider = new CodingPlanProvider({
+          platform: options.codingPlanPlatform,
+          apiKey: options.apiKey,
+          model: options.model,
+          customBaseUrl: options.baseUrl,
+        });
+        break;
+
+      case 'custom':
+        // Custom provider: uses OpenAI-compatible SDK with user-provided baseUrl + apiKey
+        // This covers DeepSeek, Google Gemini (OpenAI compat), Together AI, Groq, etc.
+        this.provider = new OpenAIProvider({
+          apiKey: options.apiKey || 'no-key-required',
+          baseUrl: options.baseUrl,
+          model: options.model,
+        });
+        break;
+
+      default:
+        throw new NovaError(`Provider "${options.provider}" is not supported`, 'NOT_IMPLEMENTED');
+    }
+  }
+
+  /** Send a non-streaming completion request */
+  async complete(
+    messages: Message[],
+    tools: ToolDefinition[],
+    sessionId: SessionId,
+    options?: Partial<ModelRequestOptions>
+  ): Promise<ModelResponse> {
+    try {
+      const requestOpts: ModelRequestOptions = {
+        model: this.model,
+        maxTokens: options?.maxTokens ?? this.maxTokens,
+        temperature: options?.temperature ?? this.temperature,
+        tools,
+        sessionId,
+        stopSequences: options?.stopSequences,
+        systemPrompt: options?.systemPrompt,
+      };
+
+      return await this.provider.complete(messages, requestOpts);
+    } catch (err) {
+      if (err instanceof NovaError) throw err;
+      throw new ModelError(
+        `Model request failed: ${(err as Error).message}`,
+        undefined,
+        this.provider.name,
+        { originalError: err }
+      );
+    }
+  }
+
+  /** Send a streaming completion request */
+  async *stream(
+    messages: Message[],
+    tools: ToolDefinition[],
+    sessionId: SessionId,
+    options?: Partial<ModelRequestOptions>
+  ): AsyncGenerator<StreamEvent> {
+    try {
+      const requestOpts: ModelRequestOptions = {
+        model: this.model,
+        maxTokens: options?.maxTokens ?? this.maxTokens,
+        temperature: options?.temperature ?? this.temperature,
+        tools,
+        sessionId,
+        stopSequences: options?.stopSequences,
+        systemPrompt: options?.systemPrompt,
+      };
+
+      yield* this.provider.stream(messages, requestOpts);
+    } catch (err) {
+      if (err instanceof NovaError) throw err;
+      const error = new ModelError(
+        `Model stream failed: ${(err as Error).message}`,
+        undefined,
+        this.provider.name,
+        { originalError: err }
+      );
+      yield { type: 'error', error };
+    }
+  }
+
+  /** Count tokens for a message array (approximate) */
+  async countTokens(messages: Message[]): Promise<number> {
+    return this.provider.countTokens(messages);
+  }
+
+  /** Get the current model name */
+  getModel(): string {
+    return this.model;
+  }
+
+  /** Get the provider name */
+  getProviderName(): string {
+    return this.provider.name;
+  }
+
+  /** Update model parameters */
+  updateOptions(options: { maxTokens?: number; temperature?: number; model?: string }): void {
+    if (options.maxTokens !== undefined) this.maxTokens = options.maxTokens;
+    if (options.temperature !== undefined) this.temperature = options.temperature;
+    if (options.model !== undefined) this.model = options.model;
+  }
+}

package/src/core/model/ModelConnectionTester.ts

@@ -0,0 +1,363 @@
+// ============================================================================
+// ModelConnectionTester - Test model provider connectivity
+// ============================================================================
+
+import type { AuthManager } from '../auth/AuthManager.js';
+import type { ConfigManager } from '../config/ConfigManager.js';
+import { OllamaManager } from './providers/OllamaManager.js';
+
+export interface ModelConnectionStatus {
+  provider: string;
+  model: string;
+  status: 'configured' | 'unconfigured' | 'available' | 'unavailable' | 'error';
+  message?: string;
+  latency?: number;
+}
+
+export interface ProviderConnectionStatus {
+  provider: string;
+  type: string;
+  status: 'configured' | 'unconfigured' | 'partial' | 'unavailable' | 'error';
+  hasCredentials: boolean;
+  models: ModelConnectionStatus[];
+  message?: string;
+  latency?: number;
+}
+
+/**
+ * Test connectivity for model providers
+ */
+export class ModelConnectionTester {
+  private authManager: AuthManager;
+  private configManager: ConfigManager;
+  private cache: Map<string, ProviderConnectionStatus> = new Map();
+  private cacheTimeout = 60000; // 1 minute cache
+  private lastTestTime = 0;
+
+  constructor(authManager: AuthManager, configManager: ConfigManager) {
+    this.authManager = authManager;
+    this.configManager = configManager;
+  }
+
+  /**
+   * Test all providers and return their status
+   */
+  async testAllProviders(): Promise<ProviderConnectionStatus[]> {
+    const config = this.configManager.getConfig();
+    const results: ProviderConnectionStatus[] = [];
+
+    for (const [providerName, providerConfig] of Object.entries(config.models.providers)) {
+      const status = await this.testProvider(providerName, providerConfig.type);
+      results.push(status);
+    }
+
+    this.lastTestTime = Date.now();
+    return results;
+  }
+
+  /**
+   * Test a single provider
+   */
+  async testProvider(providerName: string, providerType: string): Promise<ProviderConnectionStatus> {
+    // Check cache
+    const cached = this.cache.get(providerName);
+    if (cached && Date.now() - this.lastTestTime < this.cacheTimeout) {
+      return cached;
+    }
+
+    const config = this.configManager.getConfig();
+    const providerConfig = config.models.providers[providerName];
+    
+    if (!providerConfig) {
+      return {
+        provider: providerName,
+        type: providerType,
+        status: 'unconfigured',
+        hasCredentials: false,
+        models: [],
+        message: 'Provider not found in configuration',
+      };
+    }
+
+    const hasCredentials = this.checkCredentials(providerName, providerType);
+    const models: ModelConnectionStatus[] = [];
+    let providerStatus: ProviderConnectionStatus['status'] = 'unconfigured';
+    let message: string | undefined;
+    let latency: number | undefined;
+
+    // For Ollama, test actual connectivity
+    if (providerType === 'ollama') {
+      const startTime = Date.now();
+      try {
+        const ollamaCreds = this.authManager.getCredentials('ollama');
+        const baseUrl = ollamaCreds?.baseUrl || process.env.OLLAMA_HOST || 'http://localhost:11434';
+        const manager = new OllamaManager(baseUrl);
+        const isRunning = await manager.ping();
+        latency = Date.now() - startTime;
+
+        if (isRunning) {
+          providerStatus = 'configured';
+          message = `Running at ${baseUrl}`;
+          
+          // List available models
+          const ollamaModels = await manager.listModels();
+          for (const model of ollamaModels) {
+            models.push({
+              provider: providerName,
+              model: model.name,
+              status: 'available',
+              latency,
+            });
+          }
+        } else {
+          providerStatus = 'unavailable';
+          message = `Ollama not running at ${baseUrl}`;
+        }
+      } catch (err) {
+        providerStatus = 'error';
+        message = `Failed to connect: ${(err as Error).message}`;
+      }
+    }
+    // For ollama-cloud, check credentials
+    else if (providerType === 'ollama-cloud') {
+      if (hasCredentials) {
+        providerStatus = 'configured';
+        message = 'API key configured';
+        
+        // Add models from config
+        for (const [modelId, modelConfig] of Object.entries(providerConfig.models)) {
+          models.push({
+            provider: providerName,
+            model: modelId,
+            status: 'configured',
+          });
+        }
+      } else {
+        providerStatus = 'unconfigured';
+        message = 'No API key configured';
+      }
+    }
+    // For other providers (anthropic, openai, etc.)
+    else {
+      if (hasCredentials) {
+        // Try to actually test the connection
+        const startTime = Date.now();
+        const connectionTest = await this.testApiConnection(providerName, providerConfig);
+        latency = Date.now() - startTime;
+
+        if (connectionTest.success) {
+          providerStatus = 'available';
+          message = connectionTest.message || `Connected (${latency}ms)`;
+        } else {
+          providerStatus = 'error';
+          message = connectionTest.message || 'Connection failed';
+        }
+        
+        // Add models from config with individual status
+        for (const [modelId, modelConfig] of Object.entries(providerConfig.models)) {
+          models.push({
+            provider: providerName,
+            model: modelId,
+            status: connectionTest.success ? 'available' : 'error',
+            message: connectionTest.success ? undefined : connectionTest.message,
+            latency: connectionTest.success ? latency : undefined,
+          });
+        }
+      } else {
+        providerStatus = 'unconfigured';
+        message = 'No API key configured';
+        
+        // Still list models but mark as unconfigured
+        for (const [modelId, modelConfig] of Object.entries(providerConfig.models)) {
+          models.push({
+            provider: providerName,
+            model: modelId,
+            status: 'unconfigured',
+          });
+        }
+      }
+    }
+
+    const result: ProviderConnectionStatus = {
+      provider: providerName,
+      type: providerType,
+      status: providerStatus,
+      hasCredentials,
+      models,
+      message,
+      latency,
+    };
+
+    this.cache.set(providerName, result);
+    return result;
+  }
+
+  /**
+   * Quick check if a provider has credentials
+   */
+  checkCredentials(providerName: string, providerType: string): boolean {
+    // Ollama local doesn't need credentials
+    if (providerType === 'ollama') {
+      return true;
+    }
+    
+    // Check auth manager
+    if (this.authManager.hasCredentials(providerName)) {
+      return true;
+    }
+
+    // Check for common env vars
+    const envKeyMap: Record<string, string> = {
+      anthropic: 'ANTHROPIC_API_KEY',
+      openai: 'OPENAI_API_KEY',
+      google: 'GOOGLE_API_KEY',
+      deepseek: 'DEEPSEEK_API_KEY',
+      qwen: 'DASHSCOPE_API_KEY',
+      glm: 'ZHIPU_API_KEY',
+      moonshot: 'MOONSHOT_API_KEY',
+      baichuan: 'BAICHUAN_API_KEY',
+      yi: 'YI_API_KEY',
+      minimax: 'MINIMAX_API_KEY',
+      groq: 'GROQ_API_KEY',
+      mistral: 'MISTRAL_API_KEY',
+      together: 'TOGETHER_API_KEY',
+      perplexity: 'PERPLEXITY_API_KEY',
+      siliconflow: 'SILICONFLOW_API_KEY',
+      'ollama-cloud': 'OLLAMA_CLOUD_API_KEY',
+    };
+
+    const envKey = envKeyMap[providerName] || envKeyMap[providerType] || `${providerName.toUpperCase()}_API_KEY`;
+    return !!process.env[envKey];
+  }
+
+  /**
+   * Get cached status without testing
+   */
+  getCachedStatus(providerName: string): ProviderConnectionStatus | undefined {
+    return this.cache.get(providerName);
+  }
+
+  /**
+   * Clear cache
+   */
+  clearCache(): void {
+    this.cache.clear();
+    this.lastTestTime = 0;
+  }
+
+  /**
+   * Test a specific model's connectivity (for providers that support it)
+   */
+  async testModel(providerName: string, modelId: string): Promise<ModelConnectionStatus> {
+    const config = this.configManager.getConfig();
+    const providerConfig = config.models.providers[providerName];
+    
+    if (!providerConfig) {
+      return {
+        provider: providerName,
+        model: modelId,
+        status: 'unconfigured',
+        message: 'Provider not found',
+      };
+    }
+
+    const hasCredentials = this.checkCredentials(providerName, providerConfig.type);
+    
+    if (!hasCredentials && providerConfig.type !== 'ollama') {
+      return {
+        provider: providerName,
+        model: modelId,
+        status: 'unconfigured',
+        message: 'No API key configured',
+      };
+    }
+
+    // For Ollama, check if model is installed
+    if (providerConfig.type === 'ollama') {
+      try {
+        const ollamaCreds = this.authManager.getCredentials('ollama');
+        const baseUrl = ollamaCreds?.baseUrl || process.env.OLLAMA_HOST || 'http://localhost:11434';
+        const manager = new OllamaManager(baseUrl);
+        
+        const isRunning = await manager.ping();
+        if (!isRunning) {
+          return {
+            provider: providerName,
+            model: modelId,
+            status: 'unavailable',
+            message: 'Ollama not running',
+          };
+        }
+
+        const modelInfo = await manager.showModel(modelId);
+        return {
+          provider: providerName,
+          model: modelId,
+          status: 'available',
+          message: modelInfo.details?.parameter_size || 'Available',
+        };
+      } catch (err) {
+        return {
+          provider: providerName,
+          model: modelId,
+          status: 'unavailable',
+          message: `Model not found: ${(err as Error).message}`,
+        };
+      }
+    }
+
+    // For other providers, we just check credentials
+    return {
+      provider: providerName,
+      model: modelId,
+      status: hasCredentials ? 'configured' : 'unconfigured',
+    };
+  }
+
+  /**
+   * Test actual API connection for a provider
+   */
+  private async testApiConnection(
+    providerName: string, 
+    providerConfig: any
+  ): Promise<{ success: boolean; message?: string }> {
+    try {
+      const creds = this.authManager.getCredentials(providerName);
+      const apiKey = creds?.apiKey || process.env[`${providerName.toUpperCase()}_API_KEY`];
+      const baseUrl = creds?.baseUrl || providerConfig.baseUrl;
+
+      if (!apiKey) {
+        return { success: false, message: 'No API key available' };
+      }
+
+      // For OpenAI-compatible providers, try to list models
+      if (providerConfig.type === 'custom' || providerConfig.type === 'openai' || 
+          providerConfig.baseUrl?.includes('openai') || providerConfig.baseUrl) {
+        try {
+          const { OpenAICompatibleProvider } = await import('./providers/OpenAICompatibleProvider.js');
+          const tester = new (class extends OpenAICompatibleProvider {
+            constructor() {
+              super({ apiKey, baseUrl, model: 'probe' });
+            }
+            get name() { return providerName; }
+          })();
+          
+          const models = await tester.listModels();
+          if (models.length > 0) {
+            return { success: true, message: `${models.length} models available` };
+          }
+          return { success: true, message: 'Connected' };
+        } catch (err) {
+          // If listModels fails, try a simple completion as fallback
+          return { success: false, message: `API error: ${(err as Error).message}` };
+        }
+      }
+
+      // For other providers (Anthropic, etc.), just check credentials for now
+      // They could be tested with specific provider SDK calls
+      return { success: true, message: 'API key configured' };
+    } catch (err) {
+      return { success: false, message: `Connection failed: ${(err as Error).message}` };
+    }
+  }
+}