@leo000001/claude-code-mcp 2.5.0 → 2.8.1

package/dist/index.js

@@ -231,12 +231,16 @@ var SessionManager = class _SessionManager {
       sandbox: params.sandbox,
       fallbackModel: params.fallbackModel,
       enableFileCheckpointing: params.enableFileCheckpointing,
+      toolConfig: params.toolConfig,
       includePartialMessages: params.includePartialMessages,
       promptSuggestions: params.promptSuggestions,
+      agentProgressSummaries: params.agentProgressSummaries,
       strictMcpConfig: params.strictMcpConfig,
+      settings: params.settings,
       settingSources: params.settingSources,
       debug: params.debug,
       debugFile: params.debugFile,
+      fastModeState: params.fastModeState,
       env: params.env,
       abortController: params.abortController,
       queryInterrupt: params.queryInterrupt
@@ -753,7 +757,8 @@ var SessionManager = class _SessionManager {
       cwd: info.cwd,
       systemPrompt: info.systemPrompt,
       agents: info.agents,
-      additionalDirectories: info.additionalDirectories
+      additionalDirectories: info.additionalDirectories,
+      toolConfig: info.toolConfig
     };
   }
   /** Serialize session info for listing/inspection (redacts sensitive fields) */
@@ -766,8 +771,10 @@ var SessionManager = class _SessionManager {
       agents: _agents,
       additionalDirectories: _additionalDirectories,
       pathToClaudeCodeExecutable: _pathToClaudeCodeExecutable,
+      toolConfig: _toolConfig,
       mcpServers: _mcpServers,
       sandbox: _sandbox,
+      settings: _settings,
       settingSources: _settingSources,
       debugFile: _debugFile,
       env: _env,
@@ -844,7 +851,7 @@ var SessionManager = class _SessionManager {
     const isNoisyProgressEvent = (event) => {
       if (event.type !== "progress") return false;
       const t = event.data?.type;
-      return t === "tool_progress" || t === "auth_status" || t === "task_progress" || t === "hook_progress";
+      return t === "tool_progress" || t === "auth_status" || t === "api_retry" || t === "task_progress" || t === "hook_progress";
     };
     let toDropForSoftLimit = remaining - buffer.maxSize;
     if (toDropForSoftLimit > 0) {
@@ -911,7 +918,6 @@ import { existsSync as existsSync2, statSync } from "fs";
 
 // src/types.ts
 var EFFORT_LEVELS = ["low", "medium", "high", "max"];
-var AGENT_MODELS = ["sonnet", "opus", "haiku", "inherit"];
 var SESSION_ACTIONS = ["list", "get", "cancel", "interrupt"];
 var DEFAULT_SETTING_SOURCES = ["user", "project", "local"];
 var CHECK_ACTIONS = ["poll", "respond_permission"];
@@ -1161,6 +1167,7 @@ function sdkResultToAgentResult(result) {
     sessionTotalTurns: typeof sessionTotalTurns === "number" ? sessionTotalTurns : void 0,
     sessionTotalCostUsd: typeof sessionTotalCostUsd === "number" ? sessionTotalCostUsd : void 0,
     stopReason: result.stop_reason,
+    fastModeState: result.fast_mode_state,
     usage: result.usage,
     modelUsage: result.modelUsage,
     permissionDenials: result.permission_denials
@@ -1204,9 +1211,28 @@ function messageToEvent(msg) {
       }
     };
   }
+  if (msg.type === "stream_event") {
+    return {
+      type: "output",
+      data: {
+        type: "stream_event",
+        event: msg.event,
+        parent_tool_use_id: msg.parent_tool_use_id
+      }
+    };
+  }
   if (msg.type === "tool_use_summary") {
     return { type: "progress", data: { type: "tool_use_summary", summary: msg.summary } };
   }
+  if (msg.type === "system" && msg.subtype === "local_command_output") {
+    return {
+      type: "output",
+      data: {
+        type: "local_command_output",
+        content: msg.content
+      }
+    };
+  }
   if (msg.type === "tool_progress") {
     return {
       type: "progress",
@@ -1237,6 +1263,15 @@ function messageToEvent(msg) {
       data: { type: "status", status: msg.status, permissionMode: msg.permissionMode }
     };
   }
+  if (msg.type === "system" && msg.subtype === "compact_boundary") {
+    return {
+      type: "progress",
+      data: {
+        type: "compact_boundary",
+        compact_metadata: msg.compact_metadata
+      }
+    };
+  }
   if (msg.type === "system" && msg.subtype === "hook_started") {
     return {
       type: "progress",
@@ -1289,6 +1324,19 @@ function messageToEvent(msg) {
       }
     };
   }
+  if (msg.type === "system" && msg.subtype === "api_retry") {
+    return {
+      type: "progress",
+      data: {
+        type: "api_retry",
+        attempt: msg.attempt,
+        max_retries: msg.max_retries,
+        retry_delay_ms: msg.retry_delay_ms,
+        error_status: msg.error_status,
+        error: msg.error
+      }
+    };
+  }
   if (msg.type === "system" && msg.subtype === "task_started") {
     return {
       type: "progress",
@@ -1297,7 +1345,8 @@ function messageToEvent(msg) {
         task_id: msg.task_id,
         tool_use_id: msg.tool_use_id,
         description: msg.description,
-        task_type: msg.task_type
+        task_type: msg.task_type,
+        prompt: msg.prompt
       }
     };
   }
@@ -1310,7 +1359,8 @@ function messageToEvent(msg) {
         tool_use_id: msg.tool_use_id,
         description: msg.description,
         usage: msg.usage,
-        last_tool_name: msg.last_tool_name
+        last_tool_name: msg.last_tool_name,
+        summary: msg.summary
       }
     };
   }
@@ -1328,7 +1378,17 @@ function messageToEvent(msg) {
       }
     };
   }
-  if (msg.type === "rate_limit" || msg.type === "prompt_suggestion") {
+  if (msg.type === "system" && msg.subtype === "elicitation_complete") {
+    return {
+      type: "progress",
+      data: {
+        type: "elicitation_complete",
+        mcp_server_name: msg.mcp_server_name,
+        elicitation_id: msg.elicitation_id
+      }
+    };
+  }
+  if (msg.type === "rate_limit_event" || msg.type === "prompt_suggestion") {
     const rest = { ...msg };
     delete rest.type;
     delete rest.uuid;
@@ -1416,8 +1476,10 @@ function consumeQuery(params) {
       requestId,
       toolName,
       input: normalizedInput,
-      summary: summarizePermission(toolName, normalizedInput),
-      description: describeTool(toolName, params.toolCache),
+      summary: options2.title ?? summarizePermission(toolName, normalizedInput),
+      title: options2.title,
+      displayName: options2.displayName,
+      description: options2.description ?? describeTool(toolName, params.toolCache),
       decisionReason: options2.decisionReason,
       blockedPath: options2.blockedPath,
       toolUseID: options2.toolUseID,
@@ -1514,6 +1576,11 @@ function consumeQuery(params) {
             params.toolCache?.updateFromInit(message.tools);
             params.onInit?.(message);
             params.sessionManager.setInitTools(message.session_id, message.tools);
+            params.sessionManager.update(message.session_id, {
+              model: message.model,
+              permissionMode: message.permissionMode,
+              fastModeState: message.fast_mode_state
+            });
             activeSessionId = message.session_id;
             if (!sessionIdResolved && shouldWaitForInit) {
               sessionIdResolved = true;
@@ -1580,6 +1647,7 @@ function consumeQuery(params) {
                 status: agentResult.isError ? "error" : "idle",
                 totalTurns: sessionTotalTurns,
                 totalCostUsd: sessionTotalCostUsd,
+                fastModeState: agentResult.fastModeState,
                 abortController: void 0,
                 queryInterrupt: void 0
               });
@@ -1587,6 +1655,7 @@ function consumeQuery(params) {
               params.sessionManager.update(sessionId2, {
                 totalTurns: sessionTotalTurns,
                 totalCostUsd: sessionTotalCostUsd,
+                fastModeState: agentResult.fastModeState,
                 abortController: void 0,
                 queryInterrupt: void 0
               });
@@ -1821,10 +1890,14 @@ function buildOptions(src) {
   if (src.fallbackModel !== void 0) opts.fallbackModel = src.fallbackModel;
   if (src.enableFileCheckpointing !== void 0)
     opts.enableFileCheckpointing = src.enableFileCheckpointing;
+  if (src.toolConfig !== void 0) opts.toolConfig = src.toolConfig;
   if (src.includePartialMessages !== void 0)
     opts.includePartialMessages = src.includePartialMessages;
   if (src.promptSuggestions !== void 0) opts.promptSuggestions = src.promptSuggestions;
+  if (src.agentProgressSummaries !== void 0)
+    opts.agentProgressSummaries = src.agentProgressSummaries;
   if (src.strictMcpConfig !== void 0) opts.strictMcpConfig = src.strictMcpConfig;
+  if (src.settings !== void 0) opts.settings = src.settings;
   if (src.settingSources !== void 0) opts.settingSources = src.settingSources;
   else opts.settingSources = DEFAULT_SETTING_SOURCES;
   if (src.debug !== void 0) opts.debug = src.debug;
@@ -1861,9 +1934,12 @@ function toSessionCreateParams(input) {
     sandbox: src.sandbox,
     fallbackModel: src.fallbackModel,
     enableFileCheckpointing: src.enableFileCheckpointing,
+    toolConfig: src.toolConfig,
     includePartialMessages: src.includePartialMessages,
     promptSuggestions: src.promptSuggestions,
+    agentProgressSummaries: src.agentProgressSummaries,
     strictMcpConfig: src.strictMcpConfig,
+    settings: src.settings,
     settingSources: src.settingSources ?? DEFAULT_SETTING_SOURCES,
     debug: src.debug,
     debugFile: src.debugFile,
@@ -2477,7 +2553,7 @@ function groupByCategory(tools) {
 function buildInternalToolsDescription(tools) {
   const grouped = groupByCategory(tools);
   const categories = Object.keys(grouped).sort((a, b) => a.localeCompare(b));
-  let desc = "Start a Claude Code session and return sessionId.\nUse claude_code_check to poll events/results and handle permissions.\n\n";
+  let desc = "Start a Claude Code session and return sessionId.\nUse claude_code_check to poll events/results and handle permissions.\nAdjust polling cadence to progress: poll faster while new events/actions are arriving, and slower when the session is quietly thinking.\nLong-running work is normal: Claude Code can keep working for 10+ minutes, especially with high/max effort, so wait for polling to settle before assuming it is stuck.\nIf you want to continue after a run pauses or finishes, use claude_code_reply with the same sessionId instead of starting a brand-new claude_code session.\n\n";
   desc += "Internal tools (authoritative list: includeTools=true in claude_code_check):\n";
   for (const category of categories) {
     desc += `
@@ -2512,11 +2588,15 @@ function toPermissionResult(params) {
     interrupt: params.interrupt
   };
 }
-function appendAllowForSessionUpdate(updates, toolName) {
+function appendAllowForSessionUpdate(updates, suggestions, toolName) {
+  const merged = [...updates ?? []];
+  if (Array.isArray(suggestions) && suggestions.length > 0) {
+    return [...merged, ...suggestions];
+  }
   const normalizedToolName = toolName?.trim();
-  if (!normalizedToolName) return updates;
+  if (!normalizedToolName) return merged.length > 0 ? merged : void 0;
   return [
-    ...updates ?? [],
+    ...merged,
     {
       type: "addRules",
       behavior: "allow",
@@ -2754,7 +2834,7 @@ function buildResult(sessionManager, toolCache, input) {
         if (e.type !== "progress") return true;
         const d = e.data;
         const progressType = d?.type;
-        return progressType !== "tool_progress" && progressType !== "auth_status" && progressType !== "task_progress" && progressType !== "hook_progress";
+        return progressType !== "tool_progress" && progressType !== "auth_status" && progressType !== "api_retry" && progressType !== "task_progress" && progressType !== "hook_progress";
       });
     }
     return filtered;
@@ -2804,6 +2884,8 @@ function buildResult(sessionManager, toolCache, input) {
         toolName: req.toolName,
         input: req.input,
         summary: req.summary,
+        title: req.title,
+        displayName: req.displayName,
         decisionReason: req.decisionReason,
         blockedPath: req.blockedPath,
         toolUseID: req.toolUseID,
@@ -2897,6 +2979,7 @@ function executeClaudeCodeCheck(input, sessionManager, toolCache, requestSignal)
   const pendingRequest = input.decision === "allow_for_session" ? sessionManager.getPendingPermission(input.sessionId, input.requestId) : void 0;
   const updatedPermissions = input.decision === "allow_for_session" ? appendAllowForSessionUpdate(
     input.permissionOptions?.updatedPermissions,
+    pendingRequest?.suggestions,
     pendingRequest?.toolName
   ) : input.permissionOptions?.updatedPermissions;
   const ok = sessionManager.finishRequest(
@@ -2929,6 +3012,7 @@ var ALWAYS_REDACTED_FIELDS = [
   "env",
   "mcpServers",
   "sandbox",
+  "settings",
   "debugFile",
   "pathToClaudeCodeExecutable"
 ];
@@ -2936,7 +3020,8 @@ var CONDITIONAL_REDACTED_FIELDS = [
   "cwd",
   "systemPrompt",
   "agents",
-  "additionalDirectories"
+  "additionalDirectories",
+  "toolConfig"
 ];
 function buildRedactions(includeSensitive) {
   const redactions = [];
@@ -3121,6 +3206,7 @@ function buildSessionRedactions(includeSensitive) {
     { field: "env", reason: "secret_or_internal" },
     { field: "mcpServers", reason: "secret_or_internal" },
     { field: "sandbox", reason: "secret_or_internal" },
+    { field: "settings", reason: "secret_or_internal" },
     { field: "debugFile", reason: "secret_or_internal" },
     { field: "pathToClaudeCodeExecutable", reason: "secret_or_internal" }
   ];
@@ -3129,7 +3215,8 @@ function buildSessionRedactions(includeSensitive) {
       { field: "cwd", reason: "sensitive_by_default" },
       { field: "systemPrompt", reason: "sensitive_by_default" },
       { field: "agents", reason: "sensitive_by_default" },
-      { field: "additionalDirectories", reason: "sensitive_by_default" }
+      { field: "additionalDirectories", reason: "sensitive_by_default" },
+      { field: "toolConfig", reason: "sensitive_by_default" }
     );
   }
   return redactions;
@@ -3350,9 +3437,22 @@ function registerResources(server, deps) {
         "3. If actions are returned, respond with `claude_code_check(action='respond_permission')`.",
         "4. Continue polling until status becomes `idle` / `error` / `cancelled`.",
         "",
+        "Usage reminders:",
+        "- Claude Code may keep working for 10+ minutes on larger tasks, especially with `effort='high'` or `effort='max'`; keep polling and be patient before treating it as stuck.",
+        "- Adjust poll intervals to the current progress: poll faster while new events or permission actions are arriving, and slower while the session is quietly thinking with no new output.",
+        "- If Claude Code stops and you want to keep going, call `claude_code_reply` with the existing `sessionId` instead of starting a fresh `claude_code` session.",
+        "",
+        "Common mistakes:",
+        "- Do not call `claude_code_reply` on a non-persistent session; if you plan to continue later, start with `advanced.persistSession=true`.",
+        "- `model` is optional. If omitted, Claude Code chooses the effective model from its own defaults/settings.",
+        "- Store `nextCursor` and feed it back into the next `claude_code_check(action='poll')`; otherwise you will keep replaying old events.",
+        "- On Windows, set `CLAUDE_CODE_GIT_BASH_PATH` or Claude Code may fail before the session starts.",
+        "- If `decision='allow_for_session'` still shows a permission request, inspect `actions[].suggestions` / `blockedPath`; directory access may need a more specific permission update.",
+        "",
         "Notes:",
         "- `respond_user_input` is not supported on this backend.",
         "- `allowedTools` is pre-approval by default; set `strictAllowedTools=true` for strict allowlist behavior.",
+        "- OpenCode/Codex-style clients usually work best when they store `sessionId` + `nextCursor` and answer approvals with `decision=allow_for_session`.",
         "- Prefer `responseMode='delta_compact'` for high-frequency polling."
       ].join("\n"),
       "text/markdown"
@@ -3695,7 +3795,7 @@ function registerResources(server, deps) {
 }
 
 // src/server.ts
-var SERVER_VERSION = true ? "2.5.0" : "0.0.0-dev";
+var SERVER_VERSION = true ? "2.8.1" : "0.0.0-dev";
 function createServerContext(serverCwd) {
   const sessionManager = new SessionManager();
   const server = new McpServer(
@@ -3735,7 +3835,7 @@ function createServerContext(serverCwd) {
     prompt: z.string(),
     tools: z.array(z.string()).optional().describe("Default: inherit"),
     disallowedTools: z.array(z.string()).optional().describe("Default: none"),
-    model: z.enum(AGENT_MODELS).optional().describe("Default: inherit"),
+    model: z.string().optional().describe("Default: inherit"),
     maxTurns: z.number().int().positive().optional().describe("Default: none"),
     mcpServers: z.array(z.union([z.string(), z.record(z.string(), z.unknown())])).optional().describe("Default: inherit"),
     skills: z.array(z.string()).optional().describe("Default: none"),
@@ -3784,9 +3884,12 @@ function createServerContext(serverCwd) {
     sandbox: z.record(z.string(), z.unknown()).optional().describe("Default: none"),
     fallbackModel: z.string().optional().describe("Default: none"),
     enableFileCheckpointing: z.boolean().optional().describe("Default: false"),
+    toolConfig: z.record(z.string(), z.unknown()).optional().describe("Default: none"),
     includePartialMessages: z.boolean().optional().describe("Default: false"),
     promptSuggestions: z.boolean().optional().describe("Default: false"),
+    agentProgressSummaries: z.boolean().optional().describe("Default: false"),
     strictMcpConfig: z.boolean().optional().describe("Default: false"),
+    settings: z.union([z.string(), z.record(z.string(), z.unknown())]).optional().describe("Default: none"),
     settingSources: z.array(z.enum(["user", "project", "local"])).optional().describe("Default: ['user','project','local']. []=isolation"),
     debug: z.boolean().optional().describe("Default: false"),
     debugFile: z.string().optional().describe("Default: none"),
@@ -3873,7 +3976,9 @@ function createServerContext(serverCwd) {
     {
       description: buildInternalToolsDescription(toolCache.getTools()),
       inputSchema: {
-        prompt: z.string().describe("Prompt"),
+        prompt: z.string().describe(
+          "Prompt. Long runs are normal; keep polling, adapt poll cadence to current progress, and reuse sessionId with claude_code_reply if you want to continue."
+        ),
         cwd: z.string().optional().describe("Working dir. Default: server cwd"),
         allowedTools: z.array(z.string()).optional().describe("Default: []"),
         disallowedTools: z.array(z.string()).optional().describe("Default: []"),
@@ -3937,10 +4042,12 @@ function createServerContext(serverCwd) {
   server.registerTool(
     "claude_code_reply",
     {
-      description: "Send a follow-up to an existing session. Returns immediately; use claude_code_check to poll.",
+      description: "Send a follow-up to an existing session. Reuse the same sessionId instead of starting a new claude_code session when you want to continue. Returns immediately; use claude_code_check to poll, and adjust poll cadence to current progress.",
       inputSchema: {
-        sessionId: z.string().describe("Session ID"),
-        prompt: z.string().describe("Prompt"),
+        sessionId: z.string().describe(
+          "Session ID from the existing conversation you want to continue; prefer this over starting a fresh claude_code session."
+        ),
+        prompt: z.string().describe("Follow-up prompt for the existing session."),
         forkSession: z.boolean().optional().describe("Default: false"),
         effort: effortOptionSchema.describe("Default: SDK"),
         thinking: thinkingOptionSchema.describe("Default: SDK"),
@@ -4043,12 +4150,14 @@ function createServerContext(serverCwd) {
   server.registerTool(
     "claude_code_check",
     {
-      description: "Poll session events or respond to permission requests.",
+      description: "Poll session events or respond to permission requests. Long Claude Code runs are normal, especially with high/max effort; poll faster when progress is active and slower when the session is quietly thinking.",
       inputSchema: {
         action: z.enum(CHECK_ACTIONS),
         sessionId: z.string().describe("Session ID"),
         cursor: z.number().int().nonnegative().optional().describe("Default: 0"),
-        responseMode: z.enum(CHECK_RESPONSE_MODES).optional().describe("Default: 'minimal'. Use 'delta_compact' for lightweight polling."),
+        responseMode: z.enum(CHECK_RESPONSE_MODES).optional().describe(
+          "Default: 'minimal'. Use 'delta_compact' for lightweight polling, especially for faster adaptive polling loops."
+        ),
         maxEvents: z.number().int().positive().optional().describe("Default: 200 (minimal), unlimited (full/delta_compact)"),
         requestId: z.string().optional().describe("Default: none"),
         decision: z.enum(["allow", "deny", "allow_for_session"]).optional().describe("Default: none"),