@contextstream/mcp-server 0.3.70 → 0.3.72

package/dist/index.js

@@ -7556,7 +7556,7 @@ var CONTEXTSTREAM_RULES_MINIMAL = `
 
 ### Tool Catalog
 
-By default, the MCP server exposes the **standard** toolset (~50 tools). To expose fewer tools, set \`CONTEXTSTREAM_TOOLSET=light\`. To expose everything (~86 tools), set \`CONTEXTSTREAM_TOOLSET=complete\` in your MCP config:
+By default, the MCP server exposes the **standard** toolset (~58 tools). To expose fewer tools, set \`CONTEXTSTREAM_TOOLSET=light\`. To expose everything (~86 tools), set \`CONTEXTSTREAM_TOOLSET=complete\` in your MCP config:
 
 \`\`\`json
 {
@@ -8083,10 +8083,11 @@ var LIGHT_TOOLSET = /* @__PURE__ */ new Set([
   "mcp_server_version"
 ]);
 var STANDARD_TOOLSET = /* @__PURE__ */ new Set([
-  // Core session tools (13)
+  // Core session tools (14)
   "session_init",
   "session_tools",
   "context_smart",
+  "context_feedback",
   "session_summary",
   "session_capture",
   "session_capture_lesson",
@@ -8127,9 +8128,15 @@ var STANDARD_TOOLSET = /* @__PURE__ */ new Set([
   "memory_delete_event",
   "memory_timeline",
   "memory_summary",
-  // Memory nodes (2)
+  // Memory nodes (6) - full CRUD for memory hygiene
   "memory_create_node",
   "memory_list_nodes",
+  "memory_get_node",
+  "memory_update_node",
+  "memory_delete_node",
+  "memory_supersede_node",
+  // Memory distillation (1)
+  "memory_distill_event",
   // Knowledge graph analysis (8)
   "graph_related",
   "graph_decisions",
@@ -8155,6 +8162,275 @@ var STANDARD_TOOLSET = /* @__PURE__ */ new Set([
   "auth_me",
   "mcp_server_version"
 ]);
+var SLACK_TOOLS = /* @__PURE__ */ new Set([
+  "slack_stats",
+  "slack_channels",
+  "slack_search",
+  "slack_discussions",
+  "slack_activity",
+  "slack_contributors",
+  "slack_knowledge",
+  "slack_summary",
+  "slack_sync_users"
+]);
+var GITHUB_TOOLS = /* @__PURE__ */ new Set([
+  "github_stats",
+  "github_repos",
+  "github_search",
+  "github_issues",
+  "github_activity",
+  "github_contributors",
+  "github_knowledge",
+  "github_summary"
+]);
+var CROSS_INTEGRATION_TOOLS = /* @__PURE__ */ new Set([
+  "integrations_status",
+  "integrations_search",
+  "integrations_summary",
+  "integrations_knowledge"
+]);
+var ALL_INTEGRATION_TOOLS = /* @__PURE__ */ new Set([
+  ...SLACK_TOOLS,
+  ...GITHUB_TOOLS,
+  ...CROSS_INTEGRATION_TOOLS
+]);
+var AUTO_HIDE_INTEGRATIONS = process.env.CONTEXTSTREAM_AUTO_HIDE_INTEGRATIONS !== "false";
+var TOKEN_SENSITIVE_CLIENTS = /* @__PURE__ */ new Set([
+  "claude",
+  "claude-code",
+  "claude code",
+  "claude desktop",
+  "anthropic"
+]);
+var AUTO_TOOLSET_ENABLED = process.env.CONTEXTSTREAM_AUTO_TOOLSET === "true";
+var SCHEMA_MODE = process.env.CONTEXTSTREAM_SCHEMA_MODE || "full";
+var COMPACT_SCHEMA_ENABLED = SCHEMA_MODE === "compact";
+function compactifyDescription(description) {
+  if (!description) return "";
+  let compact = description.replace(/```[\s\S]*?```/g, "");
+  compact = compact.replace(/\n*Example:[\s\S]*$/i, "");
+  compact = compact.replace(/\n*Access:.*$/gm, "");
+  const firstLine = compact.split("\n")[0].trim();
+  const firstSentence = firstLine.split(/\.(?:\s|$)/)[0];
+  let result = firstSentence.length >= 20 ? firstSentence : firstLine;
+  if (result.length > 120) {
+    result = result.substring(0, 117) + "...";
+  }
+  return result;
+}
+function compactifyParamDescription(description) {
+  if (!description) return void 0;
+  const firstClause = description.split(/[.,;]/)[0].trim();
+  if (firstClause.length > 40) {
+    return firstClause.substring(0, 37) + "...";
+  }
+  return firstClause;
+}
+function applyCompactParamDescriptions(schema) {
+  if (!(schema instanceof external_exports.ZodObject)) {
+    return schema;
+  }
+  const shape = schema.shape;
+  let changed = false;
+  const nextShape = {};
+  for (const [key, field] of Object.entries(shape)) {
+    let nextField = field;
+    const existingDescription = getDescription(field);
+    if (field instanceof external_exports.ZodObject) {
+      const nested = applyCompactParamDescriptions(field);
+      if (nested !== field) {
+        nextField = nested;
+        changed = true;
+      }
+    }
+    if (existingDescription) {
+      const compact = compactifyParamDescription(existingDescription);
+      if (compact && compact !== existingDescription) {
+        nextField = nextField.describe(compact);
+        changed = true;
+      }
+    }
+    nextShape[key] = nextField;
+  }
+  if (!changed) return schema;
+  let nextSchema = external_exports.object(nextShape);
+  const def = schema._def;
+  if (def?.catchall) nextSchema = nextSchema.catchall(def.catchall);
+  if (def?.unknownKeys === "passthrough") nextSchema = nextSchema.passthrough();
+  if (def?.unknownKeys === "strict") nextSchema = nextSchema.strict();
+  return nextSchema;
+}
+function detectClaudeCodeFromEnv() {
+  return process.env.CLAUDECODE === "1" || process.env.CLAUDE_CODE_ENTRYPOINT !== void 0 || process.env.CLAUDE_CODE === "1";
+}
+function isTokenSensitiveClient(clientName) {
+  if (!clientName) return false;
+  const normalized = clientName.toLowerCase().trim();
+  for (const pattern of TOKEN_SENSITIVE_CLIENTS) {
+    if (normalized.includes(pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getRecommendedToolset(clientName, fromEnv) {
+  if (!AUTO_TOOLSET_ENABLED) return null;
+  if (isTokenSensitiveClient(clientName) || fromEnv) {
+    return LIGHT_TOOLSET;
+  }
+  return null;
+}
+var detectedClientInfo = null;
+var clientDetectedFromEnv = false;
+var PROGRESSIVE_MODE = process.env.CONTEXTSTREAM_PROGRESSIVE_MODE === "true";
+var TOOL_BUNDLES = {
+  // Core bundle (~12 tools) - always enabled, essential for any session
+  core: /* @__PURE__ */ new Set([
+    "session_init",
+    "session_tools",
+    "context_smart",
+    "context_feedback",
+    "session_capture",
+    "session_capture_lesson",
+    "session_get_lessons",
+    "session_recall",
+    "session_remember",
+    "session_get_user_context",
+    "tools_enable_bundle",
+    // Meta-tool to enable other bundles
+    "auth_me",
+    "mcp_server_version"
+  ]),
+  // Session bundle (~6 tools) - extended session management
+  session: /* @__PURE__ */ new Set([
+    "session_summary",
+    "session_smart_search",
+    "session_compress",
+    "session_delta",
+    "decision_trace",
+    "generate_editor_rules"
+  ]),
+  // Memory bundle (~12 tools) - full memory CRUD operations
+  memory: /* @__PURE__ */ new Set([
+    "memory_create_event",
+    "memory_update_event",
+    "memory_delete_event",
+    "memory_list_events",
+    "memory_get_event",
+    "memory_search",
+    "memory_decisions",
+    "memory_timeline",
+    "memory_summary",
+    "memory_create_node",
+    "memory_update_node",
+    "memory_delete_node",
+    "memory_list_nodes",
+    "memory_get_node",
+    "memory_supersede_node",
+    "memory_distill_event"
+  ]),
+  // Search bundle (~4 tools) - search capabilities
+  search: /* @__PURE__ */ new Set([
+    "search_semantic",
+    "search_hybrid",
+    "search_keyword"
+  ]),
+  // Graph bundle (~9 tools) - code graph analysis
+  graph: /* @__PURE__ */ new Set([
+    "graph_related",
+    "graph_decisions",
+    "graph_path",
+    "graph_dependencies",
+    "graph_call_path",
+    "graph_impact",
+    "graph_circular_dependencies",
+    "graph_unused_code",
+    "graph_ingest"
+  ]),
+  // Workspace bundle (~4 tools) - workspace management
+  workspace: /* @__PURE__ */ new Set([
+    "workspaces_list",
+    "workspaces_get",
+    "workspace_associate",
+    "workspace_bootstrap"
+  ]),
+  // Project bundle (~10 tools) - project management and indexing
+  project: /* @__PURE__ */ new Set([
+    "projects_create",
+    "projects_update",
+    "projects_list",
+    "projects_get",
+    "projects_overview",
+    "projects_statistics",
+    "projects_index",
+    "projects_index_status",
+    "projects_files",
+    "projects_ingest_local"
+  ]),
+  // Reminders bundle (~6 tools) - reminder management
+  reminders: /* @__PURE__ */ new Set([
+    "reminders_list",
+    "reminders_active",
+    "reminders_create",
+    "reminders_snooze",
+    "reminders_complete",
+    "reminders_dismiss"
+  ]),
+  // Integrations bundle - Slack/GitHub tools (auto-hidden when not connected)
+  integrations: /* @__PURE__ */ new Set([
+    "slack_stats",
+    "slack_channels",
+    "slack_search",
+    "slack_discussions",
+    "slack_activity",
+    "slack_contributors",
+    "slack_knowledge",
+    "slack_summary",
+    "slack_sync_users",
+    "github_stats",
+    "github_repos",
+    "github_search",
+    "github_issues",
+    "github_activity",
+    "github_contributors",
+    "github_knowledge",
+    "github_summary",
+    "integrations_status",
+    "integrations_search",
+    "integrations_summary",
+    "integrations_knowledge"
+  ])
+};
+var enabledBundles = /* @__PURE__ */ new Set(["core"]);
+function isToolInEnabledBundles(toolName) {
+  for (const bundleName of enabledBundles) {
+    const bundle = TOOL_BUNDLES[bundleName];
+    if (bundle?.has(toolName)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getBundleInfo() {
+  const descriptions = {
+    core: "Essential session tools (always enabled)",
+    session: "Extended session management and utilities",
+    memory: "Full memory CRUD operations",
+    search: "Semantic, hybrid, and keyword search",
+    graph: "Code graph analysis and dependencies",
+    workspace: "Workspace management",
+    project: "Project management and indexing",
+    reminders: "Reminder management",
+    integrations: "Slack and GitHub integrations"
+  };
+  return Object.entries(TOOL_BUNDLES).map(([name, tools]) => ({
+    name,
+    size: tools.size,
+    enabled: enabledBundles.has(name),
+    description: descriptions[name] || `${name} tools`
+  }));
+}
+var deferredTools = /* @__PURE__ */ new Map();
 var TOOLSET_ALIASES = {
   // Light mode - minimal, fastest
   light: LIGHT_TOOLSET,
@@ -8167,6 +8443,8 @@ var TOOLSET_ALIASES = {
   complete: null,
   full: null,
   all: null
+  // Auto mode - handled separately in resolveToolFilter, but listed here for reference
+  // auto: STANDARD_TOOLSET (will be adjusted based on client detection)
 };
 function parseToolList(raw) {
   return new Set(
@@ -8179,24 +8457,41 @@ function resolveToolFilter() {
     const allowlist = parseToolList(allowlistRaw);
     if (allowlist.size === 0) {
       console.error("[ContextStream] CONTEXTSTREAM_TOOL_ALLOWLIST is empty; using standard toolset.");
-      return { allowlist: STANDARD_TOOLSET, source: "standard" };
+      return { allowlist: STANDARD_TOOLSET, source: "standard", autoDetected: false };
     }
-    return { allowlist, source: "allowlist" };
+    return { allowlist, source: "allowlist", autoDetected: false };
   }
   const toolsetRaw = process.env.CONTEXTSTREAM_TOOLSET;
   if (!toolsetRaw) {
-    return { allowlist: STANDARD_TOOLSET, source: "standard" };
+    clientDetectedFromEnv = detectClaudeCodeFromEnv();
+    if (clientDetectedFromEnv && AUTO_TOOLSET_ENABLED) {
+      const recommended = getRecommendedToolset(void 0, true);
+      if (recommended) {
+        console.error("[ContextStream] Detected Claude Code via environment. Using light toolset for optimal token usage.");
+        return { allowlist: recommended, source: "auto-claude", autoDetected: true };
+      }
+    }
+    return { allowlist: STANDARD_TOOLSET, source: "standard", autoDetected: false };
+  }
+  if (toolsetRaw.trim().toLowerCase() === "auto") {
+    clientDetectedFromEnv = detectClaudeCodeFromEnv();
+    if (clientDetectedFromEnv) {
+      console.error("[ContextStream] TOOLSET=auto: Detected Claude Code, using light toolset.");
+      return { allowlist: LIGHT_TOOLSET, source: "auto-claude", autoDetected: true };
+    }
+    console.error("[ContextStream] TOOLSET=auto: Will adjust toolset based on MCP client (currently standard).");
+    return { allowlist: STANDARD_TOOLSET, source: "auto-pending", autoDetected: true };
   }
   const key = toolsetRaw.trim().toLowerCase();
   if (key in TOOLSET_ALIASES) {
     const resolved = TOOLSET_ALIASES[key];
     if (resolved === null) {
-      return { allowlist: null, source: "complete" };
+      return { allowlist: null, source: "complete", autoDetected: false };
     }
-    return { allowlist: resolved, source: key };
+    return { allowlist: resolved, source: key, autoDetected: false };
   }
   console.error(`[ContextStream] Unknown CONTEXTSTREAM_TOOLSET "${toolsetRaw}". Using standard toolset.`);
-  return { allowlist: STANDARD_TOOLSET, source: "standard" };
+  return { allowlist: STANDARD_TOOLSET, source: "standard", autoDetected: false };
 }
 function formatContent(data) {
   return JSON.stringify(data, null, 2);
@@ -8265,17 +8560,79 @@ function isDuplicateLessonCapture(signature) {
   recentLessonCaptures.set(signature, now);
   return false;
 }
+function setupClientDetection(server) {
+  if (!AUTO_TOOLSET_ENABLED) {
+    console.error("[ContextStream] Auto-toolset: DISABLED (set CONTEXTSTREAM_AUTO_TOOLSET=true to enable)");
+    return;
+  }
+  if (clientDetectedFromEnv) {
+    console.error("[ContextStream] Client detection: Already detected Claude Code from environment");
+    return;
+  }
+  const lowLevelServer = server.server;
+  if (!lowLevelServer) {
+    console.error("[ContextStream] Warning: Could not access low-level MCP server for client detection");
+    return;
+  }
+  lowLevelServer.oninitialized = () => {
+    try {
+      const clientVersion = lowLevelServer.getClientVersion?.();
+      if (clientVersion) {
+        detectedClientInfo = clientVersion;
+        const clientName = clientVersion.name || "unknown";
+        const clientVer = clientVersion.version || "unknown";
+        console.error(`[ContextStream] MCP Client detected: ${clientName} v${clientVer}`);
+        if (isTokenSensitiveClient(clientName)) {
+          console.error("[ContextStream] Token-sensitive client detected. Consider using CONTEXTSTREAM_TOOLSET=light for optimal performance.");
+          try {
+            lowLevelServer.sendToolsListChanged?.();
+            console.error("[ContextStream] Emitted tools/list_changed notification");
+          } catch (error) {
+          }
+        }
+      }
+    } catch (error) {
+      console.error("[ContextStream] Error in client detection callback:", error);
+    }
+  };
+  console.error("[ContextStream] Client detection: Callback registered for MCP initialize");
+}
 function registerTools(server, client, sessionManager) {
   const upgradeUrl2 = process.env.CONTEXTSTREAM_UPGRADE_URL || "https://contextstream.io/pricing";
   const toolFilter = resolveToolFilter();
   const toolAllowlist = toolFilter.allowlist;
   if (toolAllowlist) {
     const source = toolFilter.source;
-    const hint = source === "light" ? " Set CONTEXTSTREAM_TOOLSET=standard or complete for more tools." : source === "standard" ? " Set CONTEXTSTREAM_TOOLSET=complete for all tools." : "";
-    console.error(`[ContextStream] Toolset: ${source} (${toolAllowlist.size} tools).${hint}`);
+    const autoNote = toolFilter.autoDetected ? " (auto-detected)" : "";
+    const hint = source === "light" || source === "auto-claude" ? " Set CONTEXTSTREAM_TOOLSET=standard or complete for more tools." : source === "standard" ? " Set CONTEXTSTREAM_TOOLSET=complete for all tools." : source === "auto-pending" ? " Toolset may be adjusted when MCP client is detected." : "";
+    console.error(`[ContextStream] Toolset: ${source} (${toolAllowlist.size} tools)${autoNote}.${hint}`);
   } else {
     console.error(`[ContextStream] Toolset: complete (all tools).`);
   }
+  if (AUTO_TOOLSET_ENABLED) {
+    if (clientDetectedFromEnv) {
+      console.error("[ContextStream] Auto-toolset: ACTIVE (Claude Code detected from environment)");
+    } else {
+      console.error("[ContextStream] Auto-toolset: ENABLED (will detect MCP client on initialize)");
+    }
+  }
+  if (AUTO_HIDE_INTEGRATIONS) {
+    console.error(`[ContextStream] Integration auto-hide: ENABLED (${ALL_INTEGRATION_TOOLS.size} tools hidden until integrations connected)`);
+    console.error("[ContextStream] Set CONTEXTSTREAM_AUTO_HIDE_INTEGRATIONS=false to disable.");
+  } else {
+    console.error("[ContextStream] Integration auto-hide: disabled");
+  }
+  if (COMPACT_SCHEMA_ENABLED) {
+    console.error("[ContextStream] Schema mode: COMPACT (shorter descriptions, minimal params)");
+  } else {
+    console.error("[ContextStream] Schema mode: full (set CONTEXTSTREAM_SCHEMA_MODE=compact to reduce token overhead)");
+  }
+  if (PROGRESSIVE_MODE) {
+    const coreBundle = TOOL_BUNDLES.core;
+    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.");
+  }
+  let serverRef = server;
   const defaultProTools = /* @__PURE__ */ new Set([
     // AI endpoints (typically paid/credit-metered)
     "ai_context",
@@ -8354,6 +8711,128 @@ function registerTools(server, client, sessionManager) {
       ].join("\n")
     );
   }
+  let integrationStatus = { checked: false, slack: false, github: false };
+  let toolsListChangedNotified = false;
+  async function checkIntegrationStatus(workspaceId) {
+    if (integrationStatus.checked && integrationStatus.workspaceId === workspaceId) {
+      return { slack: integrationStatus.slack, github: integrationStatus.github };
+    }
+    if (!workspaceId) {
+      return { slack: false, github: false };
+    }
+    try {
+      const status = await client.integrationsStatus({ workspace_id: workspaceId });
+      const slackConnected = status?.some(
+        (s) => s.provider === "slack" && s.status === "connected"
+      ) ?? false;
+      const githubConnected = status?.some(
+        (s) => s.provider === "github" && s.status === "connected"
+      ) ?? false;
+      integrationStatus = {
+        checked: true,
+        slack: slackConnected,
+        github: githubConnected,
+        workspaceId
+      };
+      console.error(`[ContextStream] Integration status: Slack=${slackConnected}, GitHub=${githubConnected}`);
+      return { slack: slackConnected, github: githubConnected };
+    } catch (error) {
+      console.error("[ContextStream] Failed to check integration status:", error);
+      return { slack: false, github: false };
+    }
+  }
+  function updateIntegrationStatus(status, workspaceId) {
+    const hadSlack = integrationStatus.slack;
+    const hadGithub = integrationStatus.github;
+    integrationStatus = {
+      checked: true,
+      slack: status.slack,
+      github: status.github,
+      workspaceId
+    };
+    if (AUTO_HIDE_INTEGRATIONS && !toolsListChangedNotified) {
+      const newlyConnected = !hadSlack && status.slack || !hadGithub && status.github;
+      if (newlyConnected) {
+        try {
+          server.server?.sendToolsListChanged?.();
+          toolsListChangedNotified = true;
+          console.error("[ContextStream] Emitted tools/list_changed notification (integrations detected)");
+        } catch (error) {
+          console.error("[ContextStream] Failed to emit tools/list_changed:", error);
+        }
+      }
+    }
+  }
+  async function gateIfIntegrationTool(toolName) {
+    if (!AUTO_HIDE_INTEGRATIONS) return null;
+    const requiresSlack = SLACK_TOOLS.has(toolName);
+    const requiresGithub = GITHUB_TOOLS.has(toolName);
+    const requiresCrossIntegration = CROSS_INTEGRATION_TOOLS.has(toolName);
+    if (!requiresSlack && !requiresGithub && !requiresCrossIntegration) {
+      return null;
+    }
+    const workspaceId = sessionManager?.getContext()?.workspace_id;
+    const status = await checkIntegrationStatus(workspaceId);
+    if (requiresSlack && !status.slack) {
+      return errorResult(
+        [
+          `Integration not connected: \`${toolName}\` requires Slack integration.`,
+          "",
+          "To use Slack tools:",
+          "1. Go to https://contextstream.io/settings/integrations",
+          "2. Connect your Slack workspace",
+          "3. Try this command again",
+          "",
+          "Note: Even without explicit Slack tools, context_smart and session_smart_search",
+          "will automatically include relevant Slack context when the integration is connected."
+        ].join("\n")
+      );
+    }
+    if (requiresGithub && !status.github) {
+      return errorResult(
+        [
+          `Integration not connected: \`${toolName}\` requires GitHub integration.`,
+          "",
+          "To use GitHub tools:",
+          "1. Go to https://contextstream.io/settings/integrations",
+          "2. Connect your GitHub repositories",
+          "3. Try this command again",
+          "",
+          "Note: Even without explicit GitHub tools, context_smart and session_smart_search",
+          "will automatically include relevant GitHub context when the integration is connected."
+        ].join("\n")
+      );
+    }
+    if (requiresCrossIntegration && !status.slack && !status.github) {
+      return errorResult(
+        [
+          `Integration not connected: \`${toolName}\` requires at least one integration (Slack or GitHub).`,
+          "",
+          "To use cross-integration tools:",
+          "1. Go to https://contextstream.io/settings/integrations",
+          "2. Connect Slack and/or GitHub",
+          "3. Try this command again"
+        ].join("\n")
+      );
+    }
+    return null;
+  }
+  function shouldRegisterIntegrationTool(toolName) {
+    if (!AUTO_HIDE_INTEGRATIONS) return true;
+    if (!integrationStatus.checked) {
+      return !ALL_INTEGRATION_TOOLS.has(toolName);
+    }
+    if (SLACK_TOOLS.has(toolName)) {
+      return integrationStatus.slack;
+    }
+    if (GITHUB_TOOLS.has(toolName)) {
+      return integrationStatus.github;
+    }
+    if (CROSS_INTEGRATION_TOOLS.has(toolName)) {
+      return integrationStatus.slack || integrationStatus.github;
+    }
+    return true;
+  }
   async function gateIfGraphTool(toolName, input) {
     const requiredTier = graphToolTiers.get(toolName);
     if (!requiredTier) return null;
@@ -8447,22 +8926,28 @@ function registerTools(server, client, sessionManager) {
       });
     };
   }
-  function registerTool(name, config, handler) {
-    if (toolAllowlist && !toolAllowlist.has(name)) {
-      return;
-    }
+  function actuallyRegisterTool(name, config, handler) {
     const accessLabel = getToolAccessLabel(name);
     const showUpgrade = accessLabel !== "Free";
+    let finalDescription;
+    let finalSchema;
+    if (COMPACT_SCHEMA_ENABLED) {
+      finalDescription = compactifyDescription(config.description);
+      finalSchema = config.inputSchema ? applyCompactParamDescriptions(config.inputSchema) : void 0;
+    } else {
+      finalDescription = `${config.description}
+
+Access: ${accessLabel}${showUpgrade ? ` (upgrade: ${upgradeUrl2})` : ""}`;
+      finalSchema = config.inputSchema ? applyParamDescriptions(config.inputSchema) : void 0;
+    }
     const labeledConfig = {
       ...config,
-      title: `${config.title} (${accessLabel})`,
-      description: `${config.description}
-
-Access: ${accessLabel}${showUpgrade ? ` (upgrade: ${upgradeUrl2})` : ""}`
+      title: COMPACT_SCHEMA_ENABLED ? config.title : `${config.title} (${accessLabel})`,
+      description: finalDescription
     };
     const annotatedConfig = {
       ...labeledConfig,
-      inputSchema: labeledConfig.inputSchema ? applyParamDescriptions(labeledConfig.inputSchema) : void 0,
+      inputSchema: finalSchema,
       annotations: {
         ...inferToolAnnotations(name),
         ...labeledConfig.annotations
@@ -8470,8 +8955,10 @@ Access: ${accessLabel}${showUpgrade ? ` (upgrade: ${upgradeUrl2})` : ""}`
     };
     const safeHandler = async (input, extra) => {
       try {
-        const gated = await gateIfProTool(name);
-        if (gated) return gated;
+        const proGated = await gateIfProTool(name);
+        if (proGated) return proGated;
+        const integrationGated = await gateIfIntegrationTool(name);
+        if (integrationGated) return integrationGated;
         return await handler(input, extra);
       } catch (error) {
         const errorMessage = error?.message || String(error);
@@ -8496,12 +8983,51 @@ Upgrade: ${upgradeUrl2}` : "";
         };
       }
     };
-    server.registerTool(
+    serverRef.registerTool(
       name,
       annotatedConfig,
       wrapWithAutoContext(name, safeHandler)
     );
   }
+  function enableBundle(bundleName) {
+    if (enabledBundles.has(bundleName)) {
+      return { success: true, message: `Bundle '${bundleName}' is already enabled.`, toolsEnabled: 0 };
+    }
+    const bundle = TOOL_BUNDLES[bundleName];
+    if (!bundle) {
+      return { success: false, message: `Unknown bundle '${bundleName}'. Available: ${Object.keys(TOOL_BUNDLES).join(", ")}`, toolsEnabled: 0 };
+    }
+    enabledBundles.add(bundleName);
+    let toolsEnabled = 0;
+    for (const toolName of bundle) {
+      const deferred = deferredTools.get(toolName);
+      if (deferred) {
+        actuallyRegisterTool(deferred.name, deferred.config, deferred.handler);
+        deferredTools.delete(toolName);
+        toolsEnabled++;
+      }
+    }
+    try {
+      const lowLevelServer = serverRef;
+      lowLevelServer.sendToolsListChanged?.();
+    } catch {
+    }
+    console.error(`[ContextStream] Bundle '${bundleName}' enabled with ${toolsEnabled} tools.`);
+    return { success: true, message: `Enabled bundle '${bundleName}' with ${toolsEnabled} tools.`, toolsEnabled };
+  }
+  function registerTool(name, config, handler) {
+    if (toolAllowlist && !toolAllowlist.has(name)) {
+      return;
+    }
+    if (!shouldRegisterIntegrationTool(name)) {
+      return;
+    }
+    if (PROGRESSIVE_MODE && !isToolInEnabledBundles(name)) {
+      deferredTools.set(name, { name, config, handler });
+      return;
+    }
+    actuallyRegisterTool(name, config, handler);
+  }
   function errorResult(text) {
     return {
       content: [{ type: "text", text }],
@@ -8571,6 +9097,56 @@ Upgrade: ${upgradeUrl2}` : "";
       return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
     }
   );
+  registerTool(
+    "tools_enable_bundle",
+    {
+      title: "Enable tool bundle",
+      description: `Enable a bundle of related tools dynamically. Only available when CONTEXTSTREAM_PROGRESSIVE_MODE=true.
+
+Available bundles:
+- session: Extended session management (~6 tools)
+- memory: Full memory CRUD operations (~16 tools)
+- search: Semantic, hybrid, and keyword search (~3 tools)
+- graph: Code graph analysis and dependencies (~9 tools)
+- workspace: Workspace management (~4 tools)
+- project: Project management and indexing (~10 tools)
+- reminders: Reminder management (~6 tools)
+- integrations: Slack and GitHub integrations (~21 tools)
+
+Example: Enable memory tools before using memory_create_event.`,
+      inputSchema: external_exports.object({
+        bundle: external_exports.enum(["session", "memory", "search", "graph", "workspace", "project", "reminders", "integrations"]).describe("Name of the bundle to enable"),
+        list_bundles: external_exports.boolean().optional().describe("If true, list all available bundles and their status")
+      })
+    },
+    async (input) => {
+      if (input.list_bundles) {
+        const bundles = getBundleInfo();
+        const result2 = {
+          progressive_mode: PROGRESSIVE_MODE,
+          bundles,
+          hint: PROGRESSIVE_MODE ? "Call tools_enable_bundle with a bundle name to enable additional tools." : "Progressive mode is disabled. All tools from your toolset are already available."
+        };
+        return { content: [{ type: "text", text: formatContent(result2) }], structuredContent: toStructured(result2) };
+      }
+      if (!PROGRESSIVE_MODE) {
+        const result2 = {
+          success: true,
+          message: `Progressive mode is disabled. All tools from your toolset are already available. Bundle '${input.bundle}' tools are accessible.`,
+          progressive_mode: false
+        };
+        return { content: [{ type: "text", text: formatContent(result2) }], structuredContent: toStructured(result2) };
+      }
+      const result = enableBundle(input.bundle);
+      const response = {
+        ...result,
+        progressive_mode: true,
+        enabled_bundles: Array.from(enabledBundles),
+        hint: result.success && result.toolsEnabled > 0 ? "New tools are now available. The client should refresh its tool list." : void 0
+      };
+      return { content: [{ type: "text", text: formatContent(response) }], structuredContent: toStructured(response) };
+    }
+  );
   registerTool(
     "workspaces_list",
     {
@@ -9679,6 +10255,21 @@ This does semantic search on the first message. You only need context_smart on s
       if (sessionManager) {
         sessionManager.markInitialized(result);
       }
+      const workspaceId = typeof result.workspace_id === "string" ? result.workspace_id : void 0;
+      if (workspaceId && AUTO_HIDE_INTEGRATIONS) {
+        try {
+          const intStatus = await checkIntegrationStatus(workspaceId);
+          updateIntegrationStatus(intStatus, workspaceId);
+          result.integrations = {
+            slack_connected: intStatus.slack,
+            github_connected: intStatus.github,
+            auto_hide_enabled: true,
+            hint: intStatus.slack || intStatus.github ? "Integration tools are now available in the tool list." : "Connect integrations at https://contextstream.io/settings/integrations to enable Slack/GitHub tools."
+          };
+        } catch (error) {
+          console.error("[ContextStream] Failed to check integration status in session_init:", error);
+        }
+      }
       const status = typeof result.status === "string" ? result.status : "";
       const workspaceWarning = typeof result.workspace_warning === "string" ? result.workspace_warning : "";
       let text = formatContent(result);
@@ -9757,9 +10348,26 @@ Memory: events(crud) nodes(knowledge) search(find) decisions(choices)`,
     async (input) => {
       const format = input.format || "grouped";
       const catalog = generateToolCatalog(format, input.category);
+      let bundleInfo = "";
+      if (PROGRESSIVE_MODE) {
+        const bundles = getBundleInfo();
+        const enabledList = bundles.filter((b) => b.enabled).map((b) => b.name).join(", ");
+        const availableList = bundles.filter((b) => !b.enabled).map((b) => `${b.name}(${b.size})`).join(", ");
+        bundleInfo = `
+
+[Progressive Mode]
+Enabled: ${enabledList}
+Available: ${availableList}
+Use tools_enable_bundle to unlock more tools.`;
+      }
       return {
-        content: [{ type: "text", text: catalog }],
-        structuredContent: { format, catalog }
+        content: [{ type: "text", text: catalog + bundleInfo }],
+        structuredContent: {
+          format,
+          catalog,
+          progressive_mode: PROGRESSIVE_MODE,
+          bundles: PROGRESSIVE_MODE ? getBundleInfo() : void 0
+        }
       };
     }
   );
@@ -11242,6 +11850,15 @@ Use this to verify integrations are healthy and syncing properly.`,
         return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
       }
       const result = await client.integrationsStatus({ workspace_id: workspaceId });
+      if (AUTO_HIDE_INTEGRATIONS) {
+        const slackConnected = result?.some(
+          (s) => s.provider === "slack" && s.status === "connected"
+        ) ?? false;
+        const githubConnected = result?.some(
+          (s) => s.provider === "github" && s.status === "connected"
+        ) ?? false;
+        updateIntegrationStatus({ slack: slackConnected, github: githubConnected }, workspaceId);
+      }
       if (result.length === 0) {
         return { content: [{ type: "text", text: "No integrations configured for this workspace." }] };
       }
@@ -13524,14 +14141,15 @@ Created API key: ${maskedNewKey}
     console.log(`
 Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
     console.log("\nMCP toolset (which tools to expose to the AI):");
-    console.log("  1) Light \u2014 core session, project, and basic memory/graph tools (~30 tools)");
-    console.log("     Best for: faster responses, simpler workflows, resource-constrained environments");
-    console.log("  2) Standard (recommended) \u2014 adds workspace, memory CRUD, graph analysis, search (~50 tools)");
+    console.log("  1) Light \u2014 core session, project, and basic memory/graph tools (~31 tools)");
+    console.log("     Best for: Claude Code, faster responses, token-constrained environments");
+    console.log("  2) Standard (recommended) \u2014 adds workspace, memory CRUD, graph analysis, search (~58 tools)");
     console.log("     Best for: most users, full development workflow with memory + code analysis");
     console.log("  3) Complete \u2014 all tools including full graph + AI, GitHub, Slack integrations (~86 tools)");
     console.log("     Best for: Elite users or power users needing full graph + integrations");
     console.log("");
-    console.log("  Tip: Elite users should choose Complete to unlock full graph tools (call path, path, circular, unused).");
+    console.log("  Note: Slack/GitHub tools are auto-hidden until you connect those integrations.");
+    console.log("  Tip: Elite users should choose Complete to unlock full graph tools.");
     console.log("  Tip: Change later by setting CONTEXTSTREAM_TOOLSET=light|standard|complete");
     const toolsetDefault = detectedGraphTier === "full" ? "3" : "2";
     const toolsetChoice = normalizeInput(await rl.question(`Choose [1/2/3] (default ${toolsetDefault}): `)) || toolsetDefault;
@@ -13846,8 +14464,9 @@ Applying to ${projects.length} project(s)...`);
       const skipped = writeActions.filter((a) => a.status === "skipped").length;
       const dry = writeActions.filter((a) => a.status === "dry-run").length;
       console.log(`Summary: ${created} created, ${updated} updated, ${appended} appended, ${skipped} skipped, ${dry} dry-run.`);
-      const toolsetDesc = toolset === "light" ? "~30 tools" : toolset === "complete" ? "~86 tools" : "~50 tools";
+      const toolsetDesc = toolset === "light" ? "~31 tools" : toolset === "complete" ? "~86 tools" : "~58 tools";
       console.log(`Toolset: ${toolset} (${toolsetDesc})`);
+      console.log(`Auto-hide: Slack/GitHub tools hidden until integrations connected.`);
     }
     console.log("\nNext steps:");
     console.log("- Restart your editor/CLI after changing MCP config or rules.");
@@ -13911,6 +14530,10 @@ Environment variables:
   CONTEXTSTREAM_PROJECT_ID    Optional default project ID
   CONTEXTSTREAM_TOOLSET       Tool mode: light|standard|complete (default: standard)
   CONTEXTSTREAM_TOOL_ALLOWLIST Optional comma-separated tool names to expose (overrides toolset)
+  CONTEXTSTREAM_AUTO_TOOLSET  Auto-detect client and adjust toolset (default: false)
+  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_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)
@@ -13960,6 +14583,7 @@ async function main() {
     name: "contextstream-mcp",
     version: VERSION
   });
+  setupClientDetection(server);
   const sessionManager = new SessionManager(server, client);
   registerTools(server, client, sessionManager);
   registerResources(server, client, config.apiUrl);

package/package.json

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