@contextstream/mcp-server 0.3.72 → 0.3.73

package/dist/index.js

@@ -8431,6 +8431,86 @@ function getBundleInfo() {
   }));
 }
 var deferredTools = /* @__PURE__ */ new Map();
+var ROUTER_MODE = process.env.CONTEXTSTREAM_ROUTER_MODE === "true";
+var operationsRegistry = /* @__PURE__ */ new Map();
+function inferOperationCategory(name) {
+  if (name.startsWith("session_") || name.startsWith("context_")) return "Session";
+  if (name.startsWith("memory_")) return "Memory";
+  if (name.startsWith("search_")) return "Search";
+  if (name.startsWith("graph_")) return "Graph";
+  if (name.startsWith("workspace")) return "Workspace";
+  if (name.startsWith("project")) return "Project";
+  if (name.startsWith("reminder")) return "Reminders";
+  if (name.startsWith("slack_") || name.startsWith("github_") || name.startsWith("integration")) return "Integrations";
+  if (name.startsWith("ai_")) return "AI";
+  if (name === "auth_me" || name === "mcp_server_version" || name === "generate_editor_rules") return "Utility";
+  if (name === "tools_enable_bundle" || name === "contextstream" || name === "contextstream_help") return "Meta";
+  return "Other";
+}
+function getOperationCatalog(category) {
+  const ops = {};
+  for (const [name, config] of operationsRegistry) {
+    const cat = config.category;
+    if (category && cat.toLowerCase() !== category.toLowerCase()) continue;
+    if (!ops[cat]) ops[cat] = [];
+    ops[cat].push(name);
+  }
+  const lines = [];
+  for (const [cat, names] of Object.entries(ops).sort()) {
+    lines.push(`${cat}: ${names.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function getOperationSchema(name) {
+  const op = operationsRegistry.get(name);
+  if (!op) return null;
+  const zodSchema = op.inputSchema;
+  try {
+    const shape = zodSchema?._def?.shape?.() || zodSchema?.shape || {};
+    const properties = {};
+    const required = [];
+    for (const [key, field] of Object.entries(shape)) {
+      const f = field;
+      const isOptional = f?._def?.typeName === "ZodOptional" || f?.isOptional?.();
+      const innerType = isOptional ? f?._def?.innerType : f;
+      const typeName = innerType?._def?.typeName || "unknown";
+      const description = f?._def?.description || innerType?._def?.description;
+      let type = "string";
+      if (typeName === "ZodNumber") type = "number";
+      else if (typeName === "ZodBoolean") type = "boolean";
+      else if (typeName === "ZodArray") type = "array";
+      else if (typeName === "ZodObject") type = "object";
+      else if (typeName === "ZodEnum") type = "enum";
+      properties[key] = { type };
+      if (description) properties[key].description = description;
+      if (typeName === "ZodEnum") {
+        properties[key].enum = innerType?._def?.values;
+      }
+      if (!isOptional) required.push(key);
+    }
+    return {
+      name: op.name,
+      title: op.title,
+      description: op.description,
+      category: op.category,
+      schema: {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : void 0
+      }
+    };
+  } catch {
+    return {
+      name: op.name,
+      title: op.title,
+      description: op.description,
+      category: op.category,
+      schema: { type: "object" }
+    };
+  }
+}
+var OUTPUT_FORMAT = process.env.CONTEXTSTREAM_OUTPUT_FORMAT || "compact";
+var COMPACT_OUTPUT = OUTPUT_FORMAT === "compact";
 var TOOLSET_ALIASES = {
   // Light mode - minimal, fastest
   light: LIGHT_TOOLSET,
@@ -8493,8 +8573,9 @@ function resolveToolFilter() {
   console.error(`[ContextStream] Unknown CONTEXTSTREAM_TOOLSET "${toolsetRaw}". Using standard toolset.`);
   return { allowlist: STANDARD_TOOLSET, source: "standard", autoDetected: false };
 }
-function formatContent(data) {
-  return JSON.stringify(data, null, 2);
+function formatContent(data, forceFormat) {
+  const usePretty = forceFormat === "pretty" || !forceFormat && !COMPACT_OUTPUT;
+  return usePretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
 }
 function toStructured(data) {
   if (data && typeof data === "object" && !Array.isArray(data)) {
@@ -8632,6 +8713,15 @@ function registerTools(server, client, sessionManager) {
     console.error(`[ContextStream] Progressive mode: ENABLED (starting with ${coreBundle.size} core tools)`);
     console.error("[ContextStream] Use tools_enable_bundle to unlock additional tool bundles dynamically.");
   }
+  if (ROUTER_MODE) {
+    console.error("[ContextStream] Router mode: ENABLED (all operations accessed via contextstream/contextstream_help)");
+    console.error("[ContextStream] Only 2 tools registered. Use contextstream_help to see available operations.");
+  }
+  if (COMPACT_OUTPUT) {
+    console.error("[ContextStream] Output format: COMPACT (minified JSON, ~30% fewer tokens per response)");
+  } else {
+    console.error("[ContextStream] Output format: pretty (set CONTEXTSTREAM_OUTPUT_FORMAT=compact for fewer tokens)");
+  }
   let serverRef = server;
   const defaultProTools = /* @__PURE__ */ new Set([
     // AI endpoints (typically paid/credit-metered)
@@ -9015,13 +9105,35 @@ Upgrade: ${upgradeUrl2}` : "";
     console.error(`[ContextStream] Bundle '${bundleName}' enabled with ${toolsEnabled} tools.`);
     return { success: true, message: `Enabled bundle '${bundleName}' with ${toolsEnabled} tools.`, toolsEnabled };
   }
+  const ROUTER_DIRECT_TOOLS = /* @__PURE__ */ new Set(["contextstream", "contextstream_help"]);
   function registerTool(name, config, handler) {
     if (toolAllowlist && !toolAllowlist.has(name)) {
+      if (ROUTER_MODE && !ROUTER_DIRECT_TOOLS.has(name)) {
+        operationsRegistry.set(name, {
+          name,
+          title: config.title,
+          description: config.description,
+          inputSchema: config.inputSchema,
+          handler,
+          category: inferOperationCategory(name)
+        });
+      }
       return;
     }
     if (!shouldRegisterIntegrationTool(name)) {
       return;
     }
+    if (ROUTER_MODE && !ROUTER_DIRECT_TOOLS.has(name)) {
+      operationsRegistry.set(name, {
+        name,
+        title: config.title,
+        description: config.description,
+        inputSchema: config.inputSchema,
+        handler,
+        category: inferOperationCategory(name)
+      });
+      return;
+    }
     if (PROGRESSIVE_MODE && !isToolInEnabledBundles(name)) {
       deferredTools.set(name, { name, config, handler });
       return;
@@ -9147,6 +9259,137 @@ Example: Enable memory tools before using memory_create_event.`,
       return { content: [{ type: "text", text: formatContent(response) }], structuredContent: toStructured(response) };
     }
   );
+  if (ROUTER_MODE) {
+    serverRef.registerTool(
+      "contextstream",
+      {
+        title: "ContextStream Operation",
+        description: `Execute any ContextStream operation. Use contextstream_help to see available operations.
+
+Example: contextstream({ op: "session_init", args: { folder_path: "/path/to/project" } })
+
+This single tool replaces 50+ individual tools, dramatically reducing token overhead.
+All ContextStream functionality is accessible through this dispatcher.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            op: { type: "string", description: "Operation name (e.g., session_init, memory_create_event)" },
+            args: { type: "object", description: "Operation arguments (varies by operation)" }
+          },
+          required: ["op"]
+        },
+        annotations: {
+          readOnlyHint: false,
+          destructiveHint: false,
+          idempotentHint: false,
+          openWorldHint: false
+        }
+      },
+      async (input) => {
+        const opName = input.op;
+        const operation = operationsRegistry.get(opName);
+        if (!operation) {
+          const available = getOperationCatalog();
+          return {
+            content: [{
+              type: "text",
+              text: `Unknown operation: ${opName}
+
+Available operations:
+${available}
+
+Use contextstream_help({ op: "operation_name" }) for details.`
+            }],
+            isError: true
+          };
+        }
+        const args = input.args || {};
+        const parsed = operation.inputSchema.safeParse(args);
+        if (!parsed.success) {
+          const schema = getOperationSchema(opName);
+          return {
+            content: [{
+              type: "text",
+              text: `Invalid arguments for ${opName}: ${parsed.error.message}
+
+Expected schema:
+${JSON.stringify(schema?.schema || {}, null, 2)}`
+            }],
+            isError: true
+          };
+        }
+        try {
+          return await operation.handler(parsed.data);
+        } catch (error) {
+          return {
+            content: [{
+              type: "text",
+              text: `Error executing ${opName}: ${error?.message || String(error)}`
+            }],
+            isError: true
+          };
+        }
+      }
+    );
+    serverRef.registerTool(
+      "contextstream_help",
+      {
+        title: "ContextStream Help",
+        description: `Get help on available ContextStream operations or schema for a specific operation.
+
+Examples:
+- contextstream_help({}) - List all operations by category
+- contextstream_help({ op: "session_init" }) - Get schema for session_init
+- contextstream_help({ category: "Memory" }) - List memory operations only`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            op: { type: "string", description: "Operation name to get schema for" },
+            category: { type: "string", description: "Category to filter (Session, Memory, Search, Graph, etc.)" }
+          }
+        },
+        annotations: {
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false
+        }
+      },
+      async (input) => {
+        if (input.op) {
+          const schema = getOperationSchema(input.op);
+          if (!schema) {
+            return {
+              content: [{
+                type: "text",
+                text: `Unknown operation: ${input.op}
+
+Use contextstream_help({}) to see available operations.`
+              }],
+              isError: true
+            };
+          }
+          return {
+            content: [{ type: "text", text: JSON.stringify(schema, null, 2) }],
+            structuredContent: schema
+          };
+        }
+        const catalog = getOperationCatalog(input.category);
+        const result = {
+          router_mode: true,
+          total_operations: operationsRegistry.size,
+          categories: catalog,
+          usage: 'Call contextstream({ op: "operation_name", args: {...} }) to execute an operation.',
+          hint: 'Use contextstream_help({ op: "operation_name" }) to see the schema for a specific operation.'
+        };
+        return {
+          content: [{ type: "text", text: formatContent(result) }],
+          structuredContent: toStructured(result)
+        };
+      }
+    );
+    console.error(`[ContextStream] Router mode: Registered 2 meta-tools, ${operationsRegistry.size} operations available via dispatcher.`);
+  }
   registerTool(
     "workspaces_list",
     {
@@ -14534,6 +14777,8 @@ Environment variables:
   CONTEXTSTREAM_AUTO_HIDE_INTEGRATIONS  Auto-hide Slack/GitHub tools when not connected (default: true)
   CONTEXTSTREAM_SCHEMA_MODE   Schema verbosity: compact|full (default: full, compact reduces tokens)
   CONTEXTSTREAM_PROGRESSIVE_MODE  Progressive disclosure: true|false (default: false, starts with ~13 core tools)
+  CONTEXTSTREAM_ROUTER_MODE   Router pattern: true|false (default: false, exposes only 2 meta-tools)
+  CONTEXTSTREAM_OUTPUT_FORMAT Output verbosity: compact|pretty (default: compact, ~30% fewer tokens)
   CONTEXTSTREAM_PRO_TOOLS     Optional comma-separated PRO tool names (default: AI tools)
   CONTEXTSTREAM_UPGRADE_URL   Optional upgrade URL shown for PRO tools on Free plan
   CONTEXTSTREAM_ENABLE_PROMPTS Enable MCP prompts list (default: true)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextstream/mcp-server",
   "mcpName": "io.github.contextstreamio/mcp-server",
-  "version": "0.3.72",
+  "version": "0.3.73",
   "description": "MCP server exposing ContextStream public API - code context, memory, search, and AI tools for developers",
   "type": "module",
   "license": "MIT",