@contextstream/mcp-server 0.3.69 → 0.3.71

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,126 @@ 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 TOOLSET_ALIASES = {
   // Light mode - minimal, fastest
   light: LIGHT_TOOLSET,
@@ -8167,6 +8294,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 +8308,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 +8411,73 @@ 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)");
+  }
   const defaultProTools = /* @__PURE__ */ new Set([
     // AI endpoints (typically paid/credit-metered)
     "ai_context",
@@ -8354,6 +8556,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;
@@ -8451,18 +8775,30 @@ function registerTools(server, client, sessionManager) {
     if (toolAllowlist && !toolAllowlist.has(name)) {
       return;
     }
+    if (!shouldRegisterIntegrationTool(name)) {
+      return;
+    }
     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 +8806,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);
@@ -9679,6 +10017,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);
@@ -11242,6 +11595,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 +13886,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 +14209,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 +14275,9 @@ 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_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 +14327,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.69",
+  "version": "0.3.71",
   "description": "MCP server exposing ContextStream public API - code context, memory, search, and AI tools for developers",
   "type": "module",
   "license": "MIT",