kojee-mcp 0.1.0 → 0.1.1

package/dist/{chunk-UDF4BJS5.js → chunk-TJNNT7XM.js}

@@ -517,137 +517,124 @@ function sleep(ms) {
 }
 
 // src/tool-registry.ts
-var KOJEE_PREFIX = "kojee_";
-var isBuiltinTool = (name) => name.startsWith(KOJEE_PREFIX);
+var BUILTIN_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "kojee_check_approval",
+  "kojee_revoke_request",
+  "kojee_send_feedback"
+]);
+function extractConnector(toolName) {
+  if (BUILTIN_TOOL_NAMES.has(toolName)) return null;
+  const idx = toolName.indexOf("_");
+  if (idx === -1) return null;
+  return toolName.substring(0, idx);
+}
 var ToolRegistry = class {
   constructor(gateway) {
     this.gateway = gateway;
   }
   gateway;
-  /** Map from agent-facing name (prefixed) to full tool definition */
-  tools = /* @__PURE__ */ new Map();
-  /** Map from agent-facing name to gateway name */
-  nameMap = /* @__PURE__ */ new Map();
+  /** Connector ID → connector info with tool list */
+  connectors = /* @__PURE__ */ new Map();
+  /** All tool names (flat) for validation */
+  allToolNames = /* @__PURE__ */ new Set();
   /**
-   * Discover tools from the gateway:
-   *  1. Call tools/list (lean) — returns names + descriptions for all tools.
-   *  2. Separate built-in kojee_* tools (already prefixed) from connector tools.
-   *  3. Call tools/get_schema for connector tool names to get full inputSchema.
-   *  4. Register everything with the kojee_ prefix mapping.
+   * Fetch the lean tool list from the gateway and group by connector.
    */
   async discoverTools() {
-    console.error("[tools] Fetching tool list from gateway...");
+    console.error("[tools] Fetching lean tool list from gateway...");
     const listResult = await this.gateway.sendRpc("tools/list", {});
     const toolList = listResult?.tools;
     if (!toolList || !Array.isArray(toolList)) {
       console.error("[tools] No tools returned from gateway");
       return;
     }
-    console.error(`[tools] Found ${toolList.length} tools`);
-    const builtinTools = [];
-    const connectorToolNames = [];
     for (const tool of toolList) {
-      if (isBuiltinTool(tool.name)) {
-        builtinTools.push(tool);
-      } else {
-        connectorToolNames.push(tool.name);
-      }
-    }
-    if (builtinTools.length > 0) {
-      const builtinSchemaResult = await this.gateway.sendRpc("tools/get_schema", {
-        names: builtinTools.map((t) => t.name)
-      });
-      const fullBuiltins = builtinSchemaResult?.tools;
-      if (fullBuiltins && Array.isArray(fullBuiltins)) {
-        for (const tool of fullBuiltins) {
-          this.registerTool(tool);
-        }
-      } else {
-        for (const tool of builtinTools) {
-          this.registerTool({
-            name: tool.name,
-            description: tool.description,
-            inputSchema: tool.inputSchema ?? { type: "object", properties: {} }
-          });
-        }
-      }
-    }
-    if (connectorToolNames.length > 0) {
-      console.error(`[tools] Fetching schemas for ${connectorToolNames.length} connector tools...`);
-      const schemaResult = await this.gateway.sendRpc("tools/get_schema", {
-        names: connectorToolNames
-      });
-      const fullTools = schemaResult?.tools;
-      const notFound = schemaResult?.not_found;
-      if (notFound && notFound.length > 0) {
-        console.error(`[tools] Warning: schemas not found for: ${notFound.join(", ")}`);
-      }
-      if (fullTools && Array.isArray(fullTools)) {
-        for (const tool of fullTools) {
-          this.registerTool(tool);
-        }
-      } else {
-        console.error("[tools] Schema fetch failed, using lean definitions");
-        for (const name of connectorToolNames) {
-          const lean = toolList.find((t) => t.name === name);
-          if (lean) {
-            this.registerTool({
-              name: lean.name,
-              description: lean.description,
-              inputSchema: { type: "object", properties: {} }
-            });
-          }
-        }
+      this.allToolNames.add(tool.name);
+      const connector = extractConnector(tool.name);
+      if (!connector) continue;
+      let info = this.connectors.get(connector);
+      if (!info) {
+        info = { id: connector, tools: [] };
+        this.connectors.set(connector, info);
       }
+      info.tools.push({ name: tool.name, description: tool.description });
     }
-    console.error(`[tools] Registered ${this.tools.size} tools`);
+    console.error(
+      `[tools] Discovered ${this.allToolNames.size} tools across ${this.connectors.size} connectors`
+    );
   }
   /**
-   * Register a single tool, applying the kojee_ prefix if needed.
+   * Get the list of connector meta-tools to register with the MCP server.
+   * Each connector becomes a tool like "kojee_gmail" whose description
+   * lists its available tools.
    */
-  registerTool(tool) {
-    const gatewayName = tool.name;
-    const agentName = gatewayName.startsWith(KOJEE_PREFIX) ? gatewayName : `${KOJEE_PREFIX}${gatewayName}`;
-    this.nameMap.set(agentName, gatewayName);
-    this.tools.set(agentName, {
-      ...tool,
-      name: agentName
-    });
+  getConnectorTools() {
+    const tools = [];
+    for (const [connectorId, info] of this.connectors) {
+      const toolNames = info.tools.map((t) => t.name).join(", ");
+      tools.push({
+        name: `kojee_${connectorId}`,
+        description: `${connectorId} tools available via Kojee (${info.tools.length} tools: ${toolNames}). Call this tool to see descriptions and details for each.`,
+        inputSchema: { type: "object", properties: {} }
+      });
+    }
+    return tools;
   }
   /**
-   * Get all registered tools as MCP tool definitions for the agent.
+   * Get the detailed tool list for a specific connector.
    */
-  getTools() {
-    return Array.from(this.tools.values());
+  getConnectorToolList(connectorId) {
+    const info = this.connectors.get(connectorId);
+    if (!info) {
+      return `No connector '${connectorId}' found. Available: ${Array.from(this.connectors.keys()).join(", ")}`;
+    }
+    const lines = info.tools.map((t) => `- **${t.name}**: ${t.description}`);
+    return `## ${connectorId} tools
+
+${lines.join("\n")}
+
+Use kojee_get_tool_schema to get the full input schema, then kojee_call_tool to execute.`;
   }
   /**
-   * Resolve an agent-facing tool name to its gateway name.
-   * Returns null if the tool is not registered.
+   * Get full schemas for specific tools via tools/get_schema.
    */
-  resolveGatewayName(agentName) {
-    return this.nameMap.get(agentName) ?? null;
+  async getToolSchemas(names) {
+    const result = await this.gateway.sendRpc("tools/get_schema", { names });
+    const response = result;
+    if (response.not_found && response.not_found.length > 0) {
+      console.error(`[tools] Schemas not found for: ${response.not_found.join(", ")}`);
+    }
+    return response.tools ?? [];
   }
   /**
-   * Call a tool through the gateway, handling name mapping.
+   * Call a tool through the gateway.
    */
-  async callTool(agentName, args) {
-    const gatewayName = this.resolveGatewayName(agentName);
-    if (!gatewayName) {
+  async callTool(name, args) {
+    if (!this.allToolNames.has(name)) {
+      const available = Array.from(this.connectors.keys()).map((c) => `kojee_${c}`).join(", ");
       return {
         content: [
           {
             type: "text",
-            text: `Tool '${agentName}' not found. It may have been removed or your token lacks access.`
+            text: `Tool '${name}' not found. Use one of the connector tools (${available}) to discover available tools.`
           }
         ],
         isError: true
       };
     }
     return this.gateway.sendRpc("tools/call", {
-      name: gatewayName,
+      name,
       arguments: args
     });
   }
+  /** List of connector IDs. */
+  get connectorIds() {
+    return Array.from(this.connectors.keys());
+  }
+  /** Total number of discovered tools. */
+  get toolCount() {
+    return this.allToolNames.size;
+  }
 };
 
 // src/server.ts
@@ -657,11 +644,80 @@ import {
   ListToolsRequestSchema,
   CallToolRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
+var CONNECTOR_TOOL_PREFIX = "kojee_";
+var UTILITY_TOOLS = [
+  {
+    name: "kojee_get_tool_schema",
+    description: "Get the full input schema for one or more Kojee tools. Call this before kojee_call_tool to know the exact parameters required.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        names: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Tool names to get schemas for (e.g. ["gmail_send_email", "github_list_repos"])'
+        }
+      },
+      required: ["names"]
+    }
+  },
+  {
+    name: "kojee_call_tool",
+    description: "Call a Kojee tool by name with the specified arguments. Use the connector tools (e.g. kojee_gmail) to discover tools, then kojee_get_tool_schema to get parameters, then this to execute.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: 'The tool name (e.g. "gmail_send_email")'
+        },
+        arguments: {
+          type: "object",
+          description: "The tool arguments matching the tool's input schema",
+          additionalProperties: true
+        }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "kojee_check_approval",
+    description: "Check the status of a pending approval request. Use this after a tool call returns 'require_approval' to poll whether the user has approved or denied.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        approval_id: {
+          type: "string",
+          description: "The approval ID returned when a tool call requires approval"
+        }
+      },
+      required: ["approval_id"]
+    }
+  },
+  {
+    name: "kojee_revoke_request",
+    description: "Revoke/cancel a pending approval request you no longer need.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        approval_id: {
+          type: "string",
+          description: "The approval ID to revoke"
+        },
+        reason: {
+          type: "string",
+          description: "Optional reason for revoking"
+        }
+      },
+      required: ["approval_id"]
+    }
+  }
+];
 function createMcpServer(registry) {
   const server = new Server(
     {
       name: "kojee-mcp",
-      version: "0.1.0"
+      version: "0.1.1"
     },
     {
       capabilities: {
@@ -670,21 +726,70 @@ function createMcpServer(registry) {
     }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const tools = registry.getTools().map((t) => ({
-      name: t.name,
-      description: t.description,
-      inputSchema: t.inputSchema
-    }));
-    return { tools };
+    const connectorTools = registry.getConnectorTools();
+    return { tools: [...connectorTools, ...UTILITY_TOOLS] };
   });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
-    const rawResult = await registry.callTool(name, args ?? {});
-    const result = translateToolCallResult(rawResult);
-    return {
-      content: result.content,
-      isError: result.isError
-    };
+    if (name.startsWith(CONNECTOR_TOOL_PREFIX) && !UTILITY_TOOLS.some((t) => t.name === name)) {
+      const connectorId = name.substring(CONNECTOR_TOOL_PREFIX.length);
+      const toolList = registry.getConnectorToolList(connectorId);
+      return {
+        content: [{ type: "text", text: toolList }],
+        isError: false
+      };
+    }
+    switch (name) {
+      case "kojee_get_tool_schema": {
+        const names = args?.names ?? [];
+        if (names.length === 0) {
+          return {
+            content: [{ type: "text", text: "Provide tool names in the 'names' array." }],
+            isError: true
+          };
+        }
+        const schemas = await registry.getToolSchemas(names);
+        return {
+          content: [{ type: "text", text: JSON.stringify(schemas, null, 2) }],
+          isError: false
+        };
+      }
+      case "kojee_call_tool": {
+        const toolName = args?.name;
+        if (!toolName) {
+          return {
+            content: [{ type: "text", text: "Provide the tool name in the 'name' field." }],
+            isError: true
+          };
+        }
+        const toolArgs = args?.arguments ?? {};
+        const rawResult = await registry.callTool(toolName, toolArgs);
+        const result = translateToolCallResult(rawResult);
+        return {
+          content: result.content,
+          isError: result.isError
+        };
+      }
+      case "kojee_check_approval":
+      case "kojee_revoke_request": {
+        const rawResult = await registry.callTool(name, args ?? {});
+        const result = translateToolCallResult(rawResult);
+        return {
+          content: result.content,
+          isError: result.isError
+        };
+      }
+      default:
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Unknown tool '${name}'. Use one of the connector tools or utility tools.`
+            }
+          ],
+          isError: true
+        };
+    }
   });
   return server;
 }
@@ -716,9 +821,8 @@ async function startProxy(config) {
   );
   const registry = new ToolRegistry(gateway);
   await registry.discoverTools();
-  const toolCount = registry.getTools().length;
   console.error(
-    `[kojee-mcp] Ready \u2014 ${toolCount} tools proxied from ${config.url}`
+    `[kojee-mcp] Ready \u2014 ${registry.toolCount} tools available from ${config.url}`
   );
   const server = createMcpServer(registry);
   await startMcpServer(server);

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   startProxy
-} from "./chunk-UDF4BJS5.js";
+} from "./chunk-TJNNT7XM.js";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   startProxy
-} from "./chunk-UDF4BJS5.js";
+} from "./chunk-TJNNT7XM.js";
 export {
   startProxy
 };

package/package.json

@@ -1,17 +1,27 @@
 {
   "name": "kojee-mcp",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Local MCP proxy for Kojee — handles DPoP auth, tool discovery, and governance transparently",
   "type": "module",
   "main": "dist/index.js",
-  "bin": { "kojee-mcp": "dist/cli.js" },
+  "bin": {
+    "kojee-mcp": "dist/cli.js"
+  },
   "scripts": {
     "build": "tsup src/cli.ts src/index.ts --format esm --dts --clean",
     "dev": "tsup src/cli.ts --format esm --watch",
     "typecheck": "tsc --noEmit"
   },
-  "files": ["dist"],
-  "keywords": ["mcp", "kojee", "ai-governance", "agent-tools", "dpop"],
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "mcp",
+    "kojee",
+    "ai-governance",
+    "agent-tools",
+    "dpop"
+  ],
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "latest",