apteva 0.2.3 → 0.2.5

package/src/mcp-client.ts

@@ -0,0 +1,599 @@
+// MCP Client for communicating with MCP servers
+// Supports both stdio (subprocess) and HTTP transports
+// Includes HTTP proxy to expose stdio servers over HTTP for agents
+
+import { spawn, serve, type Subprocess, type Server } from "bun";
+
+export interface McpTool {
+  name: string;
+  description?: string;
+  inputSchema: Record<string, unknown>;
+}
+
+export interface McpToolCallResult {
+  content: McpContentBlock[];
+  isError?: boolean;
+}
+
+export interface McpContentBlock {
+  type: "text" | "image" | "resource";
+  text?: string;
+  data?: string; // base64 for images
+  mimeType?: string;
+}
+
+interface JsonRpcRequest {
+  jsonrpc: "2.0";
+  id: number;
+  method: string;
+  params?: unknown;
+}
+
+interface JsonRpcResponse {
+  jsonrpc: "2.0";
+  id: number;
+  result?: unknown;
+  error?: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+interface InitializeResult {
+  protocolVersion: string;
+  capabilities: {
+    tools?: { listChanged?: boolean };
+    resources?: { subscribe?: boolean; listChanged?: boolean };
+    prompts?: { listChanged?: boolean };
+  };
+  serverInfo: {
+    name: string;
+    version: string;
+  };
+  instructions?: string;
+}
+
+interface ToolsListResult {
+  tools: McpTool[];
+  nextCursor?: string;
+}
+
+const MCP_PROTOCOL_VERSION = "2024-11-05";
+
+// ============ Stdio MCP Client ============
+
+interface McpProcess {
+  proc: Subprocess;
+  initialized: boolean;
+  serverInfo: { name: string; version: string } | null;
+  requestId: number;
+  buffer: string;
+  httpServer?: Server;  // HTTP proxy server
+  httpPort?: number;    // Port the HTTP proxy is running on
+}
+
+// Store running MCP processes
+const mcpProcesses = new Map<string, McpProcess>();
+
+// Mutex for serializing stdio requests (one at a time per process)
+const requestLocks = new Map<string, Promise<void>>();
+
+async function withLock<T>(serverId: string, fn: () => Promise<T>): Promise<T> {
+  // Wait for any pending request to complete
+  while (requestLocks.has(serverId)) {
+    await requestLocks.get(serverId);
+  }
+
+  let resolve: () => void;
+  const lockPromise = new Promise<void>(r => { resolve = r; });
+  requestLocks.set(serverId, lockPromise);
+
+  try {
+    return await fn();
+  } finally {
+    requestLocks.delete(serverId);
+    resolve!();
+  }
+}
+
+export function getMcpProcess(serverId: string): McpProcess | undefined {
+  return mcpProcesses.get(serverId);
+}
+
+export async function startMcpProcess(
+  serverId: string,
+  command: string[],
+  env: Record<string, string> = {},
+  httpPort?: number
+): Promise<{ success: boolean; error?: string; port?: number }> {
+  // Stop existing process if any
+  stopMcpProcess(serverId);
+
+  try {
+    const proc = spawn({
+      cmd: command,
+      env: { ...process.env as Record<string, string>, ...env },
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const entry: McpProcess = {
+      proc,
+      initialized: false,
+      serverInfo: null,
+      requestId: 0,
+      buffer: "",
+    };
+
+    mcpProcesses.set(serverId, entry);
+
+    // Give it a moment to start
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    // Check if process is still running
+    if (proc.exitCode !== null) {
+      const stderr = await new Response(proc.stderr).text();
+      mcpProcesses.delete(serverId);
+      return { success: false, error: `Process exited: ${stderr || "unknown error"}` };
+    }
+
+    // Start HTTP proxy server if port specified
+    if (httpPort) {
+      try {
+        const httpServer = startHttpProxy(serverId, httpPort);
+        entry.httpServer = httpServer;
+        entry.httpPort = httpPort;
+        console.log(`[MCP] HTTP proxy for ${serverId} started on port ${httpPort}`);
+      } catch (err) {
+        // HTTP proxy failed, but stdio process is running - still usable
+        console.error(`[MCP] Failed to start HTTP proxy for ${serverId}:`, err);
+      }
+    }
+
+    return { success: true, port: httpPort };
+  } catch (err) {
+    return { success: false, error: String(err) };
+  }
+}
+
+// Start HTTP proxy server that forwards requests to stdio process
+function startHttpProxy(serverId: string, port: number): Server {
+  return serve({
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+
+      // CORS headers
+      const corsHeaders = {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Mcp-Session-Id",
+      };
+
+      // Handle CORS preflight
+      if (req.method === "OPTIONS") {
+        return new Response(null, { headers: corsHeaders });
+      }
+
+      // Only accept POST to /mcp
+      if (req.method !== "POST" || (url.pathname !== "/mcp" && url.pathname !== "/")) {
+        return new Response(JSON.stringify({ error: "Not found" }), {
+          status: 404,
+          headers: { ...corsHeaders, "Content-Type": "application/json" },
+        });
+      }
+
+      try {
+        const body = await req.json() as JsonRpcRequest;
+
+        // Forward to stdio process with lock to serialize requests
+        const result = await withLock(serverId, async () => {
+          return await sendRequestRaw(serverId, body.method, body.params, body.id);
+        });
+
+        return new Response(JSON.stringify(result), {
+          headers: { ...corsHeaders, "Content-Type": "application/json" },
+        });
+      } catch (err) {
+        const errorResponse: JsonRpcResponse = {
+          jsonrpc: "2.0",
+          id: 0,
+          error: {
+            code: -32603,
+            message: err instanceof Error ? err.message : String(err),
+          },
+        };
+        return new Response(JSON.stringify(errorResponse), {
+          status: 500,
+          headers: { ...corsHeaders, "Content-Type": "application/json" },
+        });
+      }
+    },
+  });
+}
+
+// Raw request that returns full JSON-RPC response (for proxy use)
+async function sendRequestRaw(
+  serverId: string,
+  method: string,
+  params?: unknown,
+  requestId?: number
+): Promise<JsonRpcResponse> {
+  const entry = mcpProcesses.get(serverId);
+  if (!entry) {
+    throw new Error("MCP process not running");
+  }
+
+  const id = requestId ?? ++entry.requestId;
+  const request: JsonRpcRequest = {
+    jsonrpc: "2.0",
+    id,
+    method,
+    params,
+  };
+
+  const requestLine = JSON.stringify(request) + "\n";
+
+  // Write to stdin
+  entry.proc.stdin.write(requestLine);
+  entry.proc.stdin.flush();
+
+  // Read response from stdout with timeout
+  return await readJsonRpcResponse(entry, id, 30000);
+}
+
+export function stopMcpProcess(serverId: string): void {
+  const entry = mcpProcesses.get(serverId);
+  if (entry) {
+    // Stop HTTP proxy server first
+    if (entry.httpServer) {
+      try {
+        entry.httpServer.stop();
+        console.log(`[MCP] HTTP proxy for ${serverId} stopped`);
+      } catch {
+        // Ignore stop errors
+      }
+    }
+    // Kill the stdio process
+    try {
+      entry.proc.kill();
+    } catch {
+      // Ignore kill errors
+    }
+    mcpProcesses.delete(serverId);
+  }
+}
+
+// Get the HTTP proxy URL for an MCP server
+export function getMcpProxyUrl(serverId: string): string | null {
+  const entry = mcpProcesses.get(serverId);
+  if (entry?.httpPort) {
+    return `http://localhost:${entry.httpPort}/mcp`;
+  }
+  return null;
+}
+
+async function sendRequest(serverId: string, method: string, params?: unknown): Promise<unknown> {
+  const entry = mcpProcesses.get(serverId);
+  if (!entry) {
+    throw new Error("MCP process not running");
+  }
+
+  const id = ++entry.requestId;
+  const request: JsonRpcRequest = {
+    jsonrpc: "2.0",
+    id,
+    method,
+    params,
+  };
+
+  const requestLine = JSON.stringify(request) + "\n";
+
+  // Write to stdin (Bun's FileSink has write() directly)
+  entry.proc.stdin.write(requestLine);
+  entry.proc.stdin.flush();
+
+  // Read response from stdout with timeout
+  const response = await readJsonRpcResponse(entry, id, 30000);
+
+  if (response.error) {
+    throw new Error(`MCP Error ${response.error.code}: ${response.error.message}`);
+  }
+
+  return response.result;
+}
+
+async function readJsonRpcResponse(
+  entry: McpProcess,
+  expectedId: number,
+  timeoutMs: number
+): Promise<JsonRpcResponse> {
+  const decoder = new TextDecoder();
+  const startTime = Date.now();
+
+  // Initialize buffer if not exists
+  if (!entry.buffer) {
+    entry.buffer = "";
+  }
+
+  while (Date.now() - startTime < timeoutMs) {
+    // Check buffer first for complete lines
+    const lines = entry.buffer.split("\n");
+    entry.buffer = lines.pop() || ""; // Keep incomplete line in buffer
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      try {
+        const response = JSON.parse(line) as JsonRpcResponse;
+        if (response.id === expectedId) {
+          return response;
+        }
+        // Ignore responses with different IDs (could be notifications)
+      } catch {
+        // Not valid JSON, continue
+      }
+    }
+
+    // Read more data from stdout
+    const reader = entry.proc.stdout.getReader();
+    try {
+      const { value, done } = await Promise.race([
+        reader.read(),
+        new Promise<{ value: undefined; done: true }>((resolve) =>
+          setTimeout(() => resolve({ value: undefined, done: true }), Math.min(1000, timeoutMs - (Date.now() - startTime)))
+        ),
+      ]);
+
+      if (value) {
+        entry.buffer += decoder.decode(value, { stream: true });
+      }
+
+      if (done && !value) {
+        // Process might have exited
+        await new Promise(r => setTimeout(r, 100));
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  throw new Error("Timeout waiting for MCP response");
+}
+
+async function sendNotification(serverId: string, method: string, params?: unknown): Promise<void> {
+  const entry = mcpProcesses.get(serverId);
+  if (!entry) return;
+
+  const notification = {
+    jsonrpc: "2.0",
+    method,
+    params,
+  };
+
+  const notificationLine = JSON.stringify(notification) + "\n";
+
+  try {
+    entry.proc.stdin.write(notificationLine);
+    entry.proc.stdin.flush();
+  } catch {
+    // Ignore notification errors
+  }
+}
+
+export async function initializeMcpServer(serverId: string): Promise<{ name: string; version: string }> {
+  const entry = mcpProcesses.get(serverId);
+  if (!entry) {
+    throw new Error("MCP process not running");
+  }
+
+  if (entry.initialized && entry.serverInfo) {
+    return entry.serverInfo;
+  }
+
+  const result = await sendRequest(serverId, "initialize", {
+    protocolVersion: MCP_PROTOCOL_VERSION,
+    capabilities: {
+      roots: { listChanged: true },
+    },
+    clientInfo: {
+      name: "apteva",
+      version: "1.0.0",
+    },
+  }) as InitializeResult;
+
+  entry.serverInfo = result.serverInfo;
+  entry.initialized = true;
+
+  // Send initialized notification
+  await sendNotification(serverId, "notifications/initialized");
+
+  return entry.serverInfo;
+}
+
+export async function listMcpTools(serverId: string): Promise<McpTool[]> {
+  const entry = mcpProcesses.get(serverId);
+  if (!entry) {
+    throw new Error("MCP process not running");
+  }
+
+  if (!entry.initialized) {
+    await initializeMcpServer(serverId);
+  }
+
+  const result = await sendRequest(serverId, "tools/list") as ToolsListResult;
+  return result.tools || [];
+}
+
+export async function callMcpTool(
+  serverId: string,
+  toolName: string,
+  args: Record<string, unknown> = {}
+): Promise<McpToolCallResult> {
+  const entry = mcpProcesses.get(serverId);
+  if (!entry) {
+    throw new Error("MCP process not running");
+  }
+
+  if (!entry.initialized) {
+    await initializeMcpServer(serverId);
+  }
+
+  const result = await sendRequest(serverId, "tools/call", {
+    name: toolName,
+    arguments: args,
+  }) as McpToolCallResult;
+
+  return result;
+}
+
+// ============ HTTP MCP Client (for remote servers) ============
+
+export class HttpMcpClient {
+  private url: string;
+  private headers: Record<string, string>;
+  private sessionId: string | null = null;
+  private initialized = false;
+  private requestId = 0;
+  private serverInfo: { name: string; version: string } | null = null;
+
+  constructor(url: string, headers: Record<string, string> = {}) {
+    this.url = url;
+    this.headers = headers;
+  }
+
+  private nextId(): number {
+    return ++this.requestId;
+  }
+
+  private async doRequest(method: string, params?: unknown): Promise<unknown> {
+    const request: JsonRpcRequest = {
+      jsonrpc: "2.0",
+      id: this.nextId(),
+      method,
+      params,
+    };
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      "Accept": "application/json, text/event-stream",
+      ...this.headers,
+    };
+
+    if (this.sessionId) {
+      headers["Mcp-Session-Id"] = this.sessionId;
+    }
+
+    const response = await fetch(this.url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request),
+      signal: AbortSignal.timeout(30000),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const newSessionId = response.headers.get("Mcp-Session-Id");
+    if (newSessionId) {
+      this.sessionId = newSessionId;
+    }
+
+    const contentType = response.headers.get("Content-Type") || "";
+
+    if (contentType.includes("text/event-stream")) {
+      return this.handleSSEResponse(response);
+    }
+
+    const data = await response.json() as JsonRpcResponse;
+
+    if (data.error) {
+      throw new Error(`MCP Error ${data.error.code}: ${data.error.message}`);
+    }
+
+    return data.result;
+  }
+
+  private async handleSSEResponse(response: Response): Promise<unknown> {
+    const text = await response.text();
+    const lines = text.split("\n");
+
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        const data = JSON.parse(line.slice(6)) as JsonRpcResponse;
+        if (data.error) {
+          throw new Error(`MCP Error ${data.error.code}: ${data.error.message}`);
+        }
+        return data.result;
+      }
+    }
+
+    throw new Error("No data in SSE response");
+  }
+
+  async initialize(): Promise<{ name: string; version: string }> {
+    if (this.initialized && this.serverInfo) {
+      return this.serverInfo;
+    }
+
+    const result = await this.doRequest("initialize", {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      capabilities: {
+        roots: { listChanged: true },
+      },
+      clientInfo: {
+        name: "apteva",
+        version: "1.0.0",
+      },
+    }) as InitializeResult;
+
+    this.serverInfo = result.serverInfo;
+    this.initialized = true;
+
+    return this.serverInfo;
+  }
+
+  async listTools(): Promise<McpTool[]> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const result = await this.doRequest("tools/list") as ToolsListResult;
+    return result.tools || [];
+  }
+
+  async callTool(name: string, args: Record<string, unknown> = {}): Promise<McpToolCallResult> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const result = await this.doRequest("tools/call", {
+      name,
+      arguments: args,
+    }) as McpToolCallResult;
+
+    return result;
+  }
+}
+
+// Cache for HTTP MCP clients
+const httpClientCache = new Map<string, HttpMcpClient>();
+
+export function getHttpMcpClient(url: string, headers: Record<string, string> = {}): HttpMcpClient {
+  const cacheKey = `${url}:${JSON.stringify(headers)}`;
+
+  let client = httpClientCache.get(cacheKey);
+  if (!client) {
+    client = new HttpMcpClient(url, headers);
+    httpClientCache.set(cacheKey, client);
+  }
+
+  return client;
+}
+
+export function clearHttpMcpClientCache(): void {
+  httpClientCache.clear();
+}

package/src/providers.ts

@@ -7,6 +7,7 @@ export const PROVIDERS = {
     id: "anthropic",
     name: "Anthropic",
     displayName: "Anthropic",
+    type: "llm" as const,
     envVar: "ANTHROPIC_API_KEY",
     docsUrl: "https://console.anthropic.com/settings/keys",
     testEndpoint: "https://api.anthropic.com/v1/messages",
@@ -19,6 +20,7 @@ export const PROVIDERS = {
     id: "openai",
     name: "OpenAI",
     displayName: "OpenAI",
+    type: "llm" as const,
     envVar: "OPENAI_API_KEY",
     docsUrl: "https://platform.openai.com/api-keys",
     testEndpoint: "https://api.openai.com/v1/models",
@@ -31,6 +33,7 @@ export const PROVIDERS = {
     id: "groq",
     name: "Groq",
     displayName: "Groq",
+    type: "llm" as const,
     envVar: "GROQ_API_KEY",
     docsUrl: "https://console.groq.com/keys",
     testEndpoint: "https://api.groq.com/openai/v1/models",
@@ -43,6 +46,7 @@ export const PROVIDERS = {
     id: "gemini",
     name: "Google",
     displayName: "Google Gemini",
+    type: "llm" as const,
     envVar: "GEMINI_API_KEY",
     docsUrl: "https://aistudio.google.com/app/apikey",
     testEndpoint: "https://generativelanguage.googleapis.com/v1/models",
@@ -55,6 +59,7 @@ export const PROVIDERS = {
     id: "xai",
     name: "xAI",
     displayName: "xAI Grok",
+    type: "llm" as const,
     envVar: "XAI_API_KEY",
     docsUrl: "https://console.x.ai/",
     testEndpoint: "https://api.x.ai/v1/models",
@@ -67,6 +72,7 @@ export const PROVIDERS = {
     id: "together",
     name: "Together",
     displayName: "Together AI",
+    type: "llm" as const,
     envVar: "TOGETHER_API_KEY",
     docsUrl: "https://api.together.xyz/settings/api-keys",
     testEndpoint: "https://api.together.xyz/v1/models",
@@ -79,6 +85,7 @@ export const PROVIDERS = {
     id: "fireworks",
     name: "Fireworks",
     displayName: "Fireworks AI",
+    type: "llm" as const,
     envVar: "FIREWORKS_API_KEY",
     docsUrl: "https://fireworks.ai/api-keys",
     testEndpoint: "https://api.fireworks.ai/inference/v1/models",
@@ -91,6 +98,7 @@ export const PROVIDERS = {
     id: "moonshot",
     name: "Moonshot",
     displayName: "Moonshot AI",
+    type: "llm" as const,
     envVar: "MOONSHOT_API_KEY",
     docsUrl: "https://platform.moonshot.cn/console/api-keys",
     testEndpoint: "https://api.moonshot.cn/v1/models",
@@ -99,6 +107,27 @@ export const PROVIDERS = {
       { value: "moonshot-v1-32k", label: "Kimi 32K (Fast)" },
     ],
   },
+  // MCP Integrations
+  composio: {
+    id: "composio",
+    name: "Composio",
+    displayName: "Composio",
+    type: "integration" as const,
+    envVar: "COMPOSIO_API_KEY",
+    docsUrl: "https://app.composio.dev/settings",
+    description: "500+ app integrations via MCP gateway",
+    models: [],
+  },
+  smithery: {
+    id: "smithery",
+    name: "Smithery",
+    displayName: "Smithery",
+    type: "integration" as const,
+    envVar: "SMITHERY_API_KEY",
+    docsUrl: "https://smithery.ai/settings",
+    description: "MCP server registry and hosting",
+    models: [],
+  },
 } as const;
 
 export type ProviderId = keyof typeof PROVIDERS;
@@ -228,7 +257,9 @@ export function getProvidersWithStatus() {
   return Object.values(PROVIDERS).map(provider => ({
     id: provider.id,
     name: provider.displayName,
+    type: provider.type,
     docsUrl: provider.docsUrl,
+    description: "description" in provider ? provider.description : undefined,
     models: provider.models,
     hasKey: configuredProviders.has(provider.id),
     keyHint: keyStatuses.get(provider.id)?.key_hint || null,