kojee-mcp 0.1.2 → 0.2.0

package/README.md

@@ -6,7 +6,7 @@ kojee-mcp is a local MCP proxy that lets any MCP-capable agent use Kojee-managed
 
 1. **Get a gateway token** from the [Kojee dashboard](https://kojee.ai).
 2. **Add to your MCP config** (see examples below).
-3. **Tools appear automatically** -- the proxy discovers and exposes all tools your token has access to.
+3. **Tools appear automatically** -- all Kojee tools your token has access to are exposed directly (e.g. `gmail_send_email`, `github_list_repos`, `calendar_create_event`). Agents call them like any native MCP tool — no discovery step, no wrapper, no indirection.
 
 ## MCP Config Examples
 

package/dist/{chunk-WIXI3EVR.js → chunk-O5UYOIQX.js}

@@ -517,106 +517,51 @@ function sleep(ms) {
 }
 
 // src/tool-registry.ts
-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;
-  /** Connector ID → connector info with tool list */
-  connectors = /* @__PURE__ */ new Map();
-  /** All tool names (flat) for validation */
-  allToolNames = /* @__PURE__ */ new Set();
+  /** Flat map: tool name → full tool definition */
+  tools = /* @__PURE__ */ new Map();
   /**
-   * Fetch the lean tool list from the gateway and group by connector.
+   * Fetch all tools with full schemas from the gateway in a single RPC call.
    */
   async discoverTools() {
-    console.error("[tools] Fetching lean tool list from gateway...");
-    const listResult = await this.gateway.sendRpc("tools/list", {});
-    const toolList = listResult?.tools;
+    console.error("[tools] Fetching tools with full schemas from gateway...");
+    const result = await this.gateway.sendRpc("tools/list", {
+      include_schema: true
+    });
+    const toolList = result?.tools;
     if (!toolList || !Array.isArray(toolList)) {
       console.error("[tools] No tools returned from gateway");
       return;
     }
     for (const tool of toolList) {
-      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);
+      if (this.tools.has(tool.name)) {
+        console.error(`[tools] Warning: duplicate tool name "${tool.name}" \u2014 overwriting`);
       }
-      info.tools.push({ name: tool.name, description: tool.description });
-    }
-    console.error(
-      `[tools] Discovered ${this.allToolNames.size} tools across ${this.connectors.size} connectors`
-    );
-  }
-  /**
-   * 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.
-   */
-  getConnectorTools() {
-    const tools = [];
-    for (const [connectorId, info] of this.connectors) {
-      const toolNames = info.tools.map((t) => t.name).join(", ");
-      tools.push({
-        name: 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 the detailed tool list for a specific connector.
-   */
-  getConnectorToolList(connectorId) {
-    const info = this.connectors.get(connectorId);
-    if (!info) {
-      return `No connector '${connectorId}' found. Available: ${Array.from(this.connectors.keys()).join(", ")}`;
+      this.tools.set(tool.name, tool);
     }
-    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.`;
+    console.error(`[tools] Registered ${this.tools.size} tools from gateway`);
   }
   /**
-   * Get full schemas for specific tools via tools/get_schema.
+   * Return all registered tools for the MCP ListTools response.
    */
-  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 ?? [];
+  getAllTools() {
+    return Array.from(this.tools.values());
   }
   /**
    * Call a tool through the gateway.
    */
   async callTool(name, args) {
-    if (!this.allToolNames.has(name)) {
-      const available = Array.from(this.connectors.keys()).map((c) => `kojee_${c}`).join(", ");
+    if (!this.tools.has(name)) {
+      const available = Array.from(this.tools.keys()).slice(0, 10).join(", ");
       return {
         content: [
           {
             type: "text",
-            text: `Tool '${name}' not found. Use one of the connector tools (${available}) to discover available tools.`
+            text: `Tool '${name}' not found. Some available tools: ${available}${this.tools.size > 10 ? ", ..." : ""}`
           }
         ],
         isError: true
@@ -627,13 +572,9 @@ Use kojee_get_tool_schema to get the full input schema, then kojee_call_tool to
       arguments: args
     });
   }
-  /** List of connector IDs. */
-  get connectorIds() {
-    return Array.from(this.connectors.keys());
-  }
-  /** Total number of discovered tools. */
+  /** Total number of registered tools. */
   get toolCount() {
-    return this.allToolNames.size;
+    return this.tools.size;
   }
 };
 
@@ -644,85 +585,11 @@ import {
   ListToolsRequestSchema,
   CallToolRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-var UTILITY_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "get_tool_schema",
-  "call_tool",
-  "check_approval",
-  "revoke_request"
-]);
-var UTILITY_TOOLS = [
-  {
-    name: "get_tool_schema",
-    description: "Get the full input schema for one or more Kojee tools. Call this before 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: "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 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: "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: "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.1"
+      version: "0.2.0"
     },
     {
       capabilities: {
@@ -731,69 +598,21 @@ function createMcpServer(registry) {
     }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
-    const connectorTools = registry.getConnectorTools();
-    return { tools: [...connectorTools, ...UTILITY_TOOLS] };
+    const tools = registry.getAllTools().map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema
+    }));
+    return { tools };
   });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
-    if (!UTILITY_TOOL_NAMES.has(name)) {
-      const toolList = registry.getConnectorToolList(name);
-      return {
-        content: [{ type: "text", text: toolList }],
-        isError: false
-      };
-    }
-    switch (name) {
-      case "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 "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 "check_approval":
-      case "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
-        };
-    }
+    const rawResult = await registry.callTool(name, args ?? {});
+    const result = translateToolCallResult(rawResult);
+    return {
+      content: result.content,
+      isError: result.isError
+    };
   });
   return server;
 }

package/dist/cli.js

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

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kojee-mcp",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Local MCP proxy for Kojee — handles DPoP auth, tool discovery, and governance transparently",
   "type": "module",
   "main": "dist/index.js",