banana-code 1.2.0

package/lib/mcpClient.js

@@ -0,0 +1,288 @@
+/**
+ * MCP Client for Banana Code
+ * Calls an MCP server via HTTP.
+ * Used both for curated tools and the call_mcp escape hatch.
+ */
+
+const DEFAULT_MCP_URL = '';
+
+/**
+ * Parse SSE text into individual data payloads.
+ * Handles multi-event streams, finds the JSON-RPC result (has `id` + `result`),
+ * ignoring notifications (have `method` but no matching `id`).
+ */
+function parseSSE(sseText, requestId) {
+  const events = [];
+  for (const line of sseText.split('\n')) {
+    if (line.startsWith('data: ')) {
+      const payload = line.slice(6).trim();
+      if (payload) events.push(payload);
+    }
+  }
+
+  // Find the JSON-RPC result event (has id + result or id + error)
+  for (const evt of events) {
+    try {
+      const parsed = JSON.parse(evt);
+      // Match by id if provided, otherwise look for any result/error response
+      if (requestId && parsed.id === requestId) return evt;
+      if (parsed.result !== undefined || parsed.error !== undefined) return evt;
+    } catch { /* skip malformed events */ }
+  }
+
+  // Fallback: return last event (original behavior)
+  return events.length > 0 ? events[events.length - 1] : sseText;
+}
+
+class McpClient {
+  constructor(options = {}) {
+    this.url = options.url || process.env.MCP_SERVER_URL || DEFAULT_MCP_URL;
+    this.sessionId = null;
+    this.initialized = false;
+    this.timeout = options.timeout || 30000;
+    this.toolTimeout = options.toolTimeout || 60000;
+    this.serverInfo = null; // Populated on initialize
+  }
+
+  /**
+   * Update the server URL (e.g., from config)
+   */
+  setUrl(url) {
+    if (url && url !== this.url) {
+      this.url = url;
+      this.sessionId = null;
+      this.initialized = false;
+      this.serverInfo = null;
+    }
+  }
+
+  /**
+   * Initialize MCP session (get sessionId)
+   */
+  async initialize() {
+    if (this.initialized) return true;
+
+    try {
+      const res = await fetch(this.url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json, text/event-stream'
+        },
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          id: 1,
+          method: 'initialize',
+          params: {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'banana', version: '1.2.0' }
+          }
+        }),
+        signal: AbortSignal.timeout(this.timeout)
+      });
+
+      if (!res.ok) return false;
+
+      const sessionId = res.headers.get('mcp-session-id') || res.headers.get('x-session-id');
+      if (sessionId) this.sessionId = sessionId;
+
+      // Parse server info from initialize response
+      const contentType = res.headers.get('content-type') || '';
+      let text = await res.text();
+      if (contentType.includes('text/event-stream')) {
+        text = parseSSE(text, 1);
+      }
+      try {
+        const data = JSON.parse(text);
+        if (data.result?.serverInfo) {
+          this.serverInfo = data.result.serverInfo;
+        }
+      } catch { /* ignore parse errors */ }
+
+      // MCP protocol requires sending notifications/initialized before any other requests.
+      // Without this, the server keeps the session in a pending state and rejects tool calls.
+      await this._sendInitializedNotification();
+
+      this.initialized = true;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Send the required notifications/initialized notification to complete the MCP handshake.
+   */
+  async _sendInitializedNotification() {
+    const headers = {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json, text/event-stream'
+    };
+    if (this.sessionId) headers['mcp-session-id'] = this.sessionId;
+
+    try {
+      await fetch(this.url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          method: 'notifications/initialized'
+        }),
+        signal: AbortSignal.timeout(this.timeout)
+      });
+    } catch {
+      // Best-effort; some servers don't require it
+    }
+  }
+
+  /**
+   * List available tools from the MCP server
+   */
+  async listTools(canRetry = true) {
+    if (!this.initialized) {
+      const ok = await this.initialize();
+      if (!ok) throw new Error('MCP server unreachable');
+    }
+
+    const headers = {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json, text/event-stream'
+    };
+    if (this.sessionId) headers['mcp-session-id'] = this.sessionId;
+
+    const requestId = Date.now();
+    const res = await fetch(this.url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: requestId,
+        method: 'tools/list',
+        params: {}
+      }),
+      signal: AbortSignal.timeout(this.toolTimeout)
+    });
+
+    // 404 = stale/expired session. Re-initialize and retry once.
+    if (res.status === 404 && canRetry) {
+      this.initialized = false;
+      this.sessionId = null;
+      this.serverInfo = null;
+      return this.listTools(false);
+    }
+
+    if (!res.ok) {
+      throw new Error(`MCP error ${res.status}: ${await res.text()}`);
+    }
+
+    const contentType = res.headers.get('content-type') || '';
+    let text = await res.text();
+    if (contentType.includes('text/event-stream')) {
+      text = parseSSE(text, requestId);
+    }
+
+    const data = JSON.parse(text);
+    if (data.error) throw new Error(data.error.message || 'Failed to list tools');
+    return data.result?.tools || [];
+  }
+
+  /**
+   * Call any MCP tool by name with args
+   */
+  async callTool(toolName, args = {}) {
+    return this._callToolWithRetry(toolName, args, true);
+  }
+
+  async _callToolWithRetry(toolName, args, canRetry) {
+    if (!this.initialized) {
+      const ok = await this.initialize();
+      if (!ok) throw new Error('MCP server unreachable');
+    }
+
+    const headers = {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json, text/event-stream'
+    };
+    if (this.sessionId) headers['mcp-session-id'] = this.sessionId;
+
+    const requestId = Date.now();
+    const body = JSON.stringify({
+      jsonrpc: '2.0',
+      id: requestId,
+      method: 'tools/call',
+      params: { name: toolName, arguments: args }
+    });
+
+    const res = await fetch(this.url, {
+      method: 'POST',
+      headers,
+      body,
+      signal: AbortSignal.timeout(this.toolTimeout)
+    });
+
+    // 404 = stale/expired session. Re-initialize and retry once.
+    if (res.status === 404 && canRetry) {
+      this.initialized = false;
+      this.sessionId = null;
+      this.serverInfo = null;
+      return this._callToolWithRetry(toolName, args, false);
+    }
+
+    if (!res.ok) {
+      throw new Error(`MCP error ${res.status}: ${await res.text()}`);
+    }
+
+    // Handle SSE or JSON response
+    const contentType = res.headers.get('content-type') || '';
+    let text = await res.text();
+
+    if (contentType.includes('text/event-stream')) {
+      text = parseSSE(text, requestId);
+    }
+
+    try {
+      const data = JSON.parse(text);
+      if (data.error) throw new Error(data.error.message || 'MCP tool error');
+      const result = data.result;
+      // Extract text content from MCP content array
+      if (result?.content) {
+        return result.content
+          .filter(c => c.type === 'text')
+          .map(c => c.text)
+          .join('\n');
+      }
+      return JSON.stringify(result);
+    } catch (e) {
+      if (e.message.includes('MCP')) throw e;
+      return text;
+    }
+  }
+
+  /**
+   * Health check - try initialize, which validates the full MCP handshake
+   */
+  async isConnected() {
+    try {
+      if (this.initialized) return true;
+      return await this.initialize();
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get connection status info
+   */
+  getStatus() {
+    return {
+      url: this.url,
+      connected: this.initialized,
+      sessionId: this.sessionId,
+      serverName: this.serverInfo?.name || null,
+      serverVersion: this.serverInfo?.version || null
+    };
+  }
+}
+
+module.exports = McpClient;

package/lib/modelRegistry.js

@@ -0,0 +1,350 @@
+/**
+ * Model Registry for Banana Code v4
+ * Handles local models from models.json + connected remote provider models.
+ */
+
+const fs = require('fs');
+
+class ModelRegistry {
+  constructor(registryPath, lmStudio, providerStore = null) {
+    this.registryPath = registryPath;
+    this.lmStudio = lmStudio;
+    this.providerStore = providerStore;
+    this.localRegistry = { default: 'silverback', models: {} };
+    this.registry = { default: 'silverback', models: {} };
+    this.currentModel = null;
+    this.load();
+  }
+
+  load() {
+    try {
+      if (fs.existsSync(this.registryPath)) {
+        const parsed = JSON.parse(fs.readFileSync(this.registryPath, 'utf-8'));
+        this.localRegistry = {
+          default: parsed.default || 'silverback',
+          models: parsed.models || {}
+        };
+      }
+    } catch {
+      this.localRegistry = { default: 'silverback', models: {} };
+    }
+
+    this._normalizeLocalModels();
+    this.refreshRemoteModels();
+  }
+
+  save() {
+    fs.writeFileSync(this.registryPath, JSON.stringify(this.localRegistry, null, 2));
+  }
+
+  _normalizeLocalModels() {
+    for (const model of Object.values(this.localRegistry.models)) {
+      if (!model.provider) model.provider = 'local';
+    }
+  }
+
+  refreshRemoteModels() {
+    const mergedModels = {};
+
+    for (const [key, model] of Object.entries(this.localRegistry.models)) {
+      mergedModels[key] = { ...model, provider: model.provider || 'local' };
+    }
+
+    if (this.providerStore) {
+      for (const remoteModel of this.providerStore.getConnectedRemoteModels()) {
+        const key = remoteModel.key;
+        mergedModels[key] = {
+          name: remoteModel.name,
+          id: remoteModel.id,
+          providerModelId: remoteModel.id,
+          provider: remoteModel.provider,
+          reasoningEffort: remoteModel.reasoningEffort,
+          contextLimit: remoteModel.contextLimit || 128000,
+          supportsThinking: remoteModel.supportsThinking !== false,
+          prompt: remoteModel.prompt || 'code-agent',
+          inferenceSettings: {
+            temperature: 0.5,
+            topP: 0.9
+          },
+          tags: remoteModel.tags || ['remote', remoteModel.provider],
+          tier: 'remote',
+          description: `${remoteModel.name} via ${remoteModel.provider}`,
+          remote: true
+        };
+      }
+    }
+
+    this.registry = {
+      default: this.localRegistry.default,
+      models: mergedModels
+    };
+
+    if (this.currentModel && !this.registry.models[this.currentModel]) {
+      this.currentModel = this.registry.default;
+    }
+  }
+
+  /**
+   * Get all models
+   */
+  list() {
+    return Object.entries(this.registry.models).map(([key, model]) => ({
+      key,
+      ...model,
+      active: key === this.currentModel
+    }));
+  }
+
+  /**
+   * Get a model by key
+   */
+  get(name) {
+    return this.registry.models[name] || null;
+  }
+
+  /**
+   * Get current active model key
+   */
+  getCurrent() {
+    if (this.currentModel && this.registry.models[this.currentModel]) {
+      return this.currentModel;
+    }
+    return this.registry.default || Object.keys(this.registry.models)[0] || null;
+  }
+
+  /**
+   * Get active provider key for current model
+   */
+  getCurrentProvider() {
+    const model = this.getCurrentModel();
+    return model?.provider || 'local';
+  }
+
+  /**
+   * Get current model identifier
+   */
+  getCurrentId() {
+    const model = this.getCurrentModel();
+    if (!model) return undefined;
+    return model.providerModelId || model.id;
+  }
+
+  /**
+   * Get current model metadata
+   */
+  getCurrentModel() {
+    const name = this.getCurrent();
+    if (!name) return null;
+    return { key: name, ...this.registry.models[name] };
+  }
+
+  /**
+   * Set active model
+   */
+  setCurrent(name) {
+    if (!this.registry.models[name]) {
+      throw new Error(`Unknown model: "${name}". Use /model to see available models.`);
+    }
+    this.currentModel = name;
+  }
+
+  /**
+   * Check if a model has a specific tag
+   */
+  hasTag(name, tag) {
+    const model = this.registry.models[name];
+    return model?.tags?.includes(tag) || false;
+  }
+
+  /**
+   * Check if current model supports vision
+   */
+  currentSupportsVision() {
+    const name = this.getCurrent();
+    return name ? this.hasTag(name, 'vision') : false;
+  }
+
+  /**
+   * Check if current model supports thinking mode
+   */
+  currentSupportsThinking() {
+    const name = this.getCurrent();
+    if (!name) return false;
+    return this.registry.models[name]?.supportsThinking === true;
+  }
+
+  /**
+   * Get context limit for current model
+   */
+  getContextLimit() {
+    const name = this.getCurrent();
+    if (!name) return 32768;
+    return this.registry.models[name]?.contextLimit || 32768;
+  }
+
+  /**
+   * Get preferred prompt name for current model
+   */
+  getPrompt() {
+    const name = this.getCurrent();
+    if (!name) return 'code-agent';
+    return this.registry.models[name]?.prompt || 'code-agent';
+  }
+
+  /**
+   * Get inference settings for current model
+   */
+  getInferenceSettings() {
+    const name = this.getCurrent();
+    if (!name) return { temperature: 0.6, topP: undefined, repeatPenalty: undefined };
+    const settings = this.registry.models[name]?.inferenceSettings;
+    return {
+      temperature: settings?.temperature ?? 0.6,
+      topP: settings?.topP ?? undefined,
+      repeatPenalty: settings?.repeatPenalty ?? undefined
+    };
+  }
+
+  /**
+   * Check if current model requires reasoning preservation
+   */
+  requiresReasoningPreservation() {
+    const name = this.getCurrent();
+    if (!name) return false;
+    return this.registry.models[name]?.preserveReasoning === true;
+  }
+
+  /**
+   * Auto-discover local model IDs from LM Studio and update local registry
+   */
+  async discover() {
+    if (!this.lmStudio) return { matched: 0, total: 0 };
+
+    const lmModels = await this.lmStudio.listModels();
+    if (lmModels.length === 0) return { matched: 0, total: 0 };
+
+    let matched = 0;
+    const usedLmIds = new Set();
+    for (const [key, model] of Object.entries(this.localRegistry.models)) {
+      if ((model.provider || 'local') !== 'local') continue;
+
+      // Do not overwrite explicit model IDs from models.json.
+      const existingId = String(model.id || '').trim();
+      if (existingId) continue;
+
+      const keywords = this._getMatchKeywords(key, model.name);
+      for (const lmModel of lmModels) {
+        const lmId = (lmModel.id || '').toLowerCase();
+        if (!lmId || usedLmIds.has(lmId)) continue;
+        if (keywords.some(kw => lmId.includes(kw))) {
+          model.id = lmModel.id;
+          usedLmIds.add(lmId);
+          matched++;
+          break;
+        }
+      }
+    }
+
+    if (matched > 0) {
+      this.save();
+      this.refreshRemoteModels();
+    }
+
+    return { matched, total: lmModels.length };
+  }
+
+  /**
+   * Generate match keywords from local model key and name
+   */
+  _getMatchKeywords(key, name) {
+    const keywords = [];
+    const keyMap = {
+      'silverback': ['silverback', 'gpt_oss'],
+      'qwen35': ['qwen3.5-35b', 'qwen3.5-35'],
+      'nemotron': ['nemotron'],
+      'coder': ['qwen3-coder-30b', 'qwen3-coder-30'],
+      'glm': ['glm-4.7', 'glm-4-flash', 'glm4'],
+      'max': ['qwen3-coder-next', 'coder-next'],
+      'mistral': ['mistral-small']
+    };
+    if (keyMap[key]) keywords.push(...keyMap[key]);
+
+    if (typeof name === 'string' && name.trim()) {
+      const parts = name.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+      keywords.push(...parts.slice(0, 3));
+    }
+
+    return [...new Set(keywords)];
+  }
+
+  /**
+   * Get default model key
+   */
+  getDefault() {
+    if (this.registry.models[this.registry.default]) {
+      return this.registry.default;
+    }
+    return Object.keys(this.registry.models)[0] || null;
+  }
+
+  /**
+   * Resolve a "provider:alias" model key string to full model metadata.
+   *
+   * Supported formats:
+   *   - "anthropic:claude-sonnet-4.6" -> looks up by key in merged registry
+   *   - "local:current" -> resolves to the currently active local model
+   *   - "nemotron" -> plain key lookup (no colon)
+   *
+   * @param {string} key - Model key to resolve
+   * @returns {Object|null} - Full model metadata with key, provider, providerModelId, etc.
+   */
+  resolveModelKey(key) {
+    if (!key || typeof key !== 'string') return null;
+    const trimmed = key.trim();
+
+    // Handle "local:current" special case
+    if (trimmed.toLowerCase() === 'local:current') {
+      return this.getCurrentModel();
+    }
+
+    // Check if it's a "provider:alias" format
+    const colonIdx = trimmed.indexOf(':');
+    if (colonIdx > 0) {
+      const provider = trimmed.slice(0, colonIdx).toLowerCase();
+      const alias = trimmed.slice(colonIdx + 1);
+
+      // Direct key lookup first (the merged key is "provider:alias")
+      if (this.registry.models[trimmed]) {
+        return { key: trimmed, ...this.registry.models[trimmed] };
+      }
+
+      // Try matching by provider + partial alias
+      for (const [k, model] of Object.entries(this.registry.models)) {
+        if ((model.provider || 'local') === provider) {
+          if (k === trimmed || k === alias || k.includes(alias) ||
+              (model.name && model.name.toLowerCase().includes(alias.toLowerCase()))) {
+            return { key: k, ...model };
+          }
+        }
+      }
+
+      return null;
+    }
+
+    // Plain key lookup (no colon)
+    if (this.registry.models[trimmed]) {
+      return { key: trimmed, ...this.registry.models[trimmed] };
+    }
+
+    // Fuzzy match by name or partial key
+    for (const [k, model] of Object.entries(this.registry.models)) {
+      if (k.includes(trimmed) || (model.name && model.name.toLowerCase().includes(trimmed.toLowerCase()))) {
+        return { key: k, ...model };
+      }
+    }
+
+    return null;
+  }
+}
+
+module.exports = ModelRegistry;