@kernel.chat/kbot 3.13.1 → 3.14.5

package/dist/packages/kbot/src/tools/mcp-client.js

@@ -0,0 +1,132 @@
+`` `typescript
+export class MCPClient {
+  private connectedServers: Map<string, string> = new Map();
+  
+  async discoverServers(): Promise<string[]> {
+    // Discover available MCP servers from known registries
+    const servers = [
+      "cablate/mcp-google-map",
+      "jackwener/opencli",
+      "vm0-ai/vm0",
+    ];
+    
+    return servers;
+  }
+  
+  async connect(serverId: string): Promise<boolean> {
+    // Connect to an MCP server via stdin/stdout protocol
+    if (!this.connectedServers.has(serverId)) {
+      this.connectedServers.set(serverId, serverId);
+      return true;
+    }
+    return false;
+  }
+  
+  async invokeTool(serverId: string, toolName: string, args: Record<string, unknown>): Promise<unknown> {
+    // MCP protocol: send tool call, receive response
+    const protocol: Record<string, unknown> = {
+      jsonrpc: "2.0",
+      id: Date.now(),
+      method: "tools/call",
+      params: {
+        name: toolName,
+        arguments: args,
+      },
+    };
+    
+    // Serialize and send over MCP channel
+    const message = JSON.stringify(protocol);
+    
+    // Receive response (simplified - real MCP uses bidirectional streams)
+    return this.handleMCPResponse(serverId, message, protocol.id);
+  }
+  
+  async handleMCPResponse(serverId: string, message: string, requestId: number): Promise<unknown> {
+    // In real implementation, this would parse MCP server responses
+    // For now, we simulate tool execution
+    const response: Record<string, unknown> = {
+      jsonrpc: "2.0",
+      id: requestId,
+      result: this.simulateToolExecution(message, serverId),
+    };
+    
+    return response;
+  }
+  
+  simulateToolExecution(message: string, serverId: string): unknown {
+    // Simulate tool execution based on server capabilities
+    // This would be replaced with actual MCP protocol implementation
+    
+    if (serverId.includes("google-map")) {
+      // Simulate Maps tool
+      return {
+        success: true,
+        data: {
+          location: "Unknown",
+          distance: "N/A",
+          duration: "N/A",
+          note: "Actual Google Maps API integration requires proper MCP server"
+        },
+      };
+    } else if (serverId.includes("opencli")) {
+      // Simulate CLI tool
+      return {
+        success: true,
+        data: {
+          output: "Tool executed successfully",
+          note: "Full CLI transformation requires proper MCP integration"
+        },
+      };
+    } else if (serverId.includes("vm0")) {
+      // Simulate workflow tool  
+      return {
+        success: true,
+        data: {
+          workflow: "executed",
+          result: {
+            status: "pending",
+            note: "Natural language workflow execution requires MCP workflow support"
+          },
+        },
+      };
+    }
+    
+    return {
+      success: false,
+      error: "Unknown MCP server or tool",
+      note: "Please implement proper MCP protocol handling",
+    };
+  }
+  
+  async listTools(serverId: string): Promise<string[]> {
+    // List available tools from an MCP server
+    const tools = this.getKnownTools(serverId);
+    return tools;
+  }
+  
+  private getKnownTools(serverId: string): string[] {
+    // Define available tools per server
+    const toolDefinitions: Record<string, string[]> = {
+      "cablate/mcp-google-map": ["maps.search", "maps.directions", "maps.route", "maps.distance"],
+      "jackwener/opencli": ["cli.execute", "cli.transform", "cli.interpret"],
+      "vm0-ai/vm0": ["workflow.run", "workflow.describe", "workflow.parse"],
+    };
+    
+    return toolDefinitions[serverId] || [];
+  }
+}
+
+// MCP Tool for agent discovery
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+// MCP Client provider for dependency injection
+export function createMCPClient(): MCPClient {
+  return new MCPClient();
+}
+` ``;
+export {};
+//# sourceMappingURL=mcp-client.js.map

package/dist/packages/kbot/src/tools/mcp-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client.js","sourceRoot":"","sources":["../../../../../src/packages/kbot/src/tools/mcp-client.ts"],"names":[],"mappings":"AAAA,EAAE,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiID,CAAA,EAAE,CAAA"}

package/dist/packages/kbot/src/tools/mcp-discovery.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mcp-discovery.d.ts.map

package/dist/packages/kbot/src/tools/mcp-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-discovery.d.ts","sourceRoot":"","sources":["../../../../../src/packages/kbot/src/tools/mcp-discovery.ts"],"names":[],"mappings":""}

package/dist/packages/kbot/src/tools/mcp-discovery.js

@@ -0,0 +1,433 @@
+`` `typescript
+import { z } from "zod";
+import type { Tool, ToolDefinition } from "@kernel.chat/types";
+import { Logger } from "../logger";
+
+/**
+ * MCP Server Discovery Tool
+ * 
+ * Scans available MCP servers and builds a unified tool registry
+ * that agents can route tool calls through dynamically
+ */
+export class McpDiscoveryTool implements ToolDefinition {
+  name = "mcp_discovery";
+  description = "Discover available MCP servers and their tools dynamically. Returns a catalog of all registered MCP servers with their capabilities, tools, and connection status.";
+  inputSchema = z.object({
+    scope: z
+      .enum(["all", "installed", "remote", "system"])
+      .default("all")
+      .describe(`;
+Filter;
+scope;
+for (discovery; ; )
+    : ;
+n - all;
+discover;
+all;
+registered;
+servers;
+n - installed;
+only;
+locally;
+installed;
+servers;
+n - remote;
+servers;
+discovered;
+via;
+network;
+propagation;
+n - system;
+only;
+system - integrated;
+servers `),
+    domain: z
+      .enum(["maps", "api", "web", "all"])
+      .default("all")
+      .describe(`;
+Filter;
+by;
+domain: ;
+n - maps;
+Google;
+Maps, routing, geolocation;
+servers;
+n - api;
+web - to - API;
+servers;
+like;
+apitap;
+n - web;
+general;
+web;
+interaction;
+servers;
+n - all;
+no;
+domain;
+filtering `),
+    includeMetadata: z
+      .boolean()
+      .default(true)
+      .describe("Include detailed metadata about each server (capabilities, versions, trust scores)"),
+  });
+
+  private logger = new Logger(this.name);
+
+  async execute(args: z.infer<typeof this.inputSchema>) {
+    this.logger.debug(`;
+Starting;
+MCP;
+discovery;
+with (scope = $) {
+    args.scope;
+}
+domain = $;
+{
+    args.domain;
+}
+`);
+
+    // Gather all MCP servers from registered managers
+    const allServers = await this.discoverServers(args.scope, args.domain, args.includeMetadata);
+    
+    // Build a unified tool registry with routing information
+    const toolRegistry = await this.buildRegistry(allServers);
+    
+    // Format response based on scope
+    const response = this.formatResponse(toolRegistry, args.scope);
+    
+    this.logger.info(`;
+Discovery;
+complete: $;
+{
+    response.totalServers;
+}
+servers, $;
+{
+    response.totalTools;
+}
+tools;
+available `);
+    
+    return {
+      status: "success",
+      timestamp: new ISODateString(),
+      data: response,
+    };
+  }
+
+  private async discoverServers(
+    scope: string,
+    domain: string,
+    includeMetadata: boolean
+  ): Promise<McpServer[]> {
+    const discovered: McpServer[] = [];
+    
+    // Registry of MCP server managers
+    const mcpManagers = this.getMcpManagers();
+    
+    for (const manager of mcpManagers) {
+      if (scope !== "all" && !manager.matchesScope(scope)) {
+        continue;
+      }
+      
+      // Register the manager's servers
+      const registered = await manager.discover();
+      for (const server of registered) {
+        // Filter by domain if requested
+        if (domain !== "all" && !server.matchesDomain(domain)) {
+          continue;
+        }
+        
+        const serverData = includeMetadata 
+          ? { ...server, metadata: await this.enrichMetadata(server) }
+          : server;
+        
+        discovered.push(serverData);
+      }
+      
+      // Propagate discovery if remote scope
+      if (scope === "remote" && manager.propagates) {
+        await this.propagateDiscovery(manager, discovered);
+      }
+    }
+    
+    return discovered;
+  }
+
+  private getMcpManagers(): McpManager[] {
+    return [
+      new ApitapManager(),
+      new MapManager(),
+      new FileSystemMcpManager(),
+      new DatabaseMcpManager(),
+    ];
+  }
+
+  private async enrichMetadata(server: McpServer): Promise<ServerMetadata> {
+    const trustScore = await this.assessTrust(server);
+    return {
+      trustScore,
+      discoveryTimestamp: new ISODateString(),
+      knownTools: server.tools.length,
+      capabilities: server.capabilities,
+    };
+  }
+
+  private async assessTrust(server: McpServer): Promise<number> {
+    // Simple trust scoring based on available signals
+    let score = 50; // Base score
+    
+    // Server-specific signals
+    if (server.source === "official") score += 20;
+    if (server.version && semver.valid(server.version)) score += 10;
+    if (server.testedIn) score += 15;
+    
+    // Community signals (would query github, npm, etc. in production)
+    if (server.repository && server.repository.stars) {
+      score = Math.min(100, score + server.repository.stars / 100);
+    }
+    
+    // Cap trust score
+    return Math.max(0, Math.min(100, score));
+  }
+
+  private async propagateDiscovery(manager: McpManager, discovered: McpServer[]): Promise<void> {
+    if (!manager.propagates) return;
+    
+    // In production, this would propagate via MCP discovery protocol
+    // For now, simulate by checking for cross-server dependencies
+    for (const server of discovered) {
+      if (server.requiresServer && !discovered.find(s => s.name === server.requiresServer)) {
+        await this.discoverServers("all", "all", false); // Recursive discovery
+      }
+    }
+  }
+
+  private async buildRegistry(servers: McpServer[]): Promise<ToolRegistry> {
+    const registry: ToolRegistry = {
+      servers: new Map(),
+      tools: new Map(),
+    };
+    
+    for (const server of servers) {
+      registry.servers.set(server.name, {
+        ...server,
+        toolHandlers: new Map<string, McpToolHandler>(),
+      });
+      
+      for (const tool of server.tools) {
+        const handler = new McpToolHandler(server, tool);
+        registry.tools.set(`;
+$;
+{
+    server.name;
+}
+$;
+{
+    tool.name;
+}
+`, handler);
+        registry.servers.get(server.name)?.tools.push(tool);
+      }
+    }
+    
+    return registry;
+  }
+
+  private formatResponse(registry: ToolRegistry, scope: string): DiscoveryResult {
+    const filteredServers = [...registry.servers.values()].filter(
+      server => {
+        if (scope === "installed") return server.local;
+        if (scope === "remote") return !server.local;
+        if (scope === "system") return server.systemIntegrated;
+        return true;
+      }
+    );
+    
+    return {
+      totalServers: filteredServers.length,
+      totalTools: filteredServers.reduce((sum, s) => sum + s.tools.length, 0),
+      servers: filteredServers.map(s => ({
+        name: s.name,
+        description: s.description.substring(0, 200),
+        version: s.version,
+        tools: s.tools.map(t => ({
+          name: t.name,
+          description: t.description.substring(0, 300),
+          parameters: this.describeParameters(t.inputSchema),
+          trustScore: s.metadata?.trustScore ?? "unknown",
+        })),
+        capabilities: s.metadata?.capabilities ?? { tools: true, resources: false, prompts: false },
+      })),
+    };
+  }
+
+  private describeParameters(schema: z.ZodSchema): string {
+    const required = schema.shape
+      .filter(prop => prop.description?.includes("required") || prop.required)
+      .map(prop => prop.key)
+      .join(", ");
+    
+    const optional = [];
+    
+    return `;
+Required: $;
+{
+    required || "none";
+}
+;
+Optional: $;
+{
+    optional.length > 0 ? optional.join(", ") : "none";
+}
+`;
+  }
+}
+
+/**
+ * MCP Tool Handler - Routes tool calls to specific MCP servers
+ */
+export class McpToolHandler {
+  serverName: string;
+  toolName: string;
+  inputSchema: z.ZodSchema;
+  private logger = new Logger(`;
+mcp: $;
+{
+    this.serverName;
+}
+$;
+{
+    this.toolName;
+}
+`);
+
+  constructor(server: McpServer, tool: McpServer["tools"][number]) {
+    this.serverName = server.name;
+    this.toolName = tool.name;
+    this.inputSchema = tool.inputSchema;
+  }
+
+  async execute(args: z.infer<typeof this.inputSchema>): Promise<ToolResult> {
+    this.logger.debug(`;
+Executing;
+tool: $;
+{
+    this.toolName;
+}
+from;
+server;
+$;
+{
+    this.serverName;
+}
+`);
+    
+    // Validate arguments
+    const validated = this.inputSchema.safeParse(args);
+    if (!validated.success) {
+      return {
+        status: "error",
+        error: "Invalid arguments",
+        details: validated.error.errors.map(err => ({
+          field: err.path.join("."),
+          message: err.message,
+        })),
+      };
+    }
+    
+    // Route to the appropriate MCP server implementation
+    // In production, this would use the MCP protocol to send calls to the server process
+    const result = await this.delegateToServer(validated.data);
+    
+    return {
+      status: "success",
+      server: this.serverName,
+      tool: this.toolName,
+      result: result,
+      timestamp: new ISODateString(),
+    };
+  }
+
+  private async delegateToServer(args: z.infer<typeof this.inputSchema>): Promise<unknown> {
+    // Server-specific delegation logic
+    if (this.serverName === "apitap") {
+      return await this.apitapDelegate(args);
+    } else if (this.serverName === "google-maps") {
+      return await this.googleMapsDelegate(args);
+    } else {
+      // Default handler - would use MCP protocol
+      return await this.defaultDelegate(args);
+    }
+  }
+
+  private async apitapDelegate(args: any): Promise<any> {
+    // Integration with apitap MCP server
+    // Transform web queries into API calls
+    const url = this.extractUrl(args);
+    return { apiCall: url, response: "Simulated API response" };
+  }
+
+  private async googleMapsDelegate(args: any): Promise<any> {
+    // Integration with Google Maps MCP server
+    const { query, location } = args;
+    return { geocode: { query, location } };
+  }
+
+  private async defaultDelegate(args: any): Promise<any> {
+    // Generic MCP protocol handler
+    return {
+      protocol: "MCP",
+      server: this.serverName,
+      tool: this.toolName,
+      args,
+      result: "Processed by generic MCP handler",
+    };
+  }
+
+  private extractUrl(args: any): string {
+    // Extract URL from various possible argument formats
+    const urlFields = ["url", "web_url", "target", "destination"];
+    for (const field of urlFields) {
+      if (args[field]) {
+        return String(args[field]);
+      }
+    }
+    return "";
+  }
+}
+
+/**
+ * MCP Server Manager - Base class for discovering MCP servers
+ */
+class McpManager {
+  name: string;
+  local: boolean = true;
+  systemIntegrated: boolean = false;
+  propagates: boolean = false;
+  
+  abstract discover(): Promise<McpServer[]>;
+  abstract matchesScope(scope: string): boolean;
+  abstract matchesDomain(domain: string): boolean;
+}
+
+/**
+ * Apitap Manager - MCP server that turns websites into APIs
+ */
+class ApitapManager extends McpManager {
+  name = "apitap";
+  matchesScope(scope: string): boolean {
+    if (scope === "api") return true;
+    if (scope === "all") return true;
+    return false;
+  }
+  
+  matchesDomain(domain: string): boolean {
+    return domain === "api" || domain === "web" || domain === "all";
+  }
+  
+  async discover(): Promise<McpServer[]> {;
+export {};
+//# sourceMappingURL=mcp-discovery.js.map

package/dist/packages/kbot/src/tools/mcp-discovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-discovery.js","sourceRoot":"","sources":["../../../../../src/packages/kbot/src/tools/mcp-discovery.ts"],"names":[],"mappings":"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"}

package/dist/packages/kbot/src/tools/memory-harness.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=memory-harness.d.ts.map

package/dist/packages/kbot/src/tools/memory-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-harness.d.ts","sourceRoot":"","sources":["../../../../../src/packages/kbot/src/tools/memory-harness.ts"],"names":[],"mappings":""}