clementine-agent 1.0.62 → 1.0.64

package/dist/agent/assistant.js

@@ -702,6 +702,21 @@ export class PersonalAssistant {
         if (sysMsg.mcp_servers) {
             this._lastMcpStatus = sysMsg.mcp_servers;
             this._lastMcpStatusTime = new Date().toISOString();
+            // Diagnostic (1.0.64+): log per-server connection status on every
+            // init so we can tell whether "No such tool available" errors are
+            // caused by a failed spawn vs misconfigured allowedTools vs session
+            // weirdness. Single-line grep target: 'SDK init — MCP servers'.
+            try {
+                const statuses = sysMsg.mcp_servers.map((s) => `${s.name}:${s.status}`);
+                logger.info({
+                    statuses,
+                    toolCount: Array.isArray(sysMsg.tools) ? sysMsg.tools.length : 0,
+                    sessionId: sysMsg.session_id,
+                    cwd: sysMsg.cwd,
+                    model: sysMsg.model,
+                }, 'SDK init — MCP servers');
+            }
+            catch { /* non-fatal */ }
         }
         // Auto-register Claude Desktop integrations from the authoritative tool
         // list the SDK reports on init. Previously the claude-integrations file
@@ -1624,7 +1639,16 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             ...(fallback ? { fallbackModel: fallback } : {}),
             permissionMode: effectivePermissionMode,
             allowDangerouslySkipPermissions: true,
-            tools: disableAllTools ? [] : allowedTools,
+            // SDK field semantics (per node_modules/@anthropic-ai/claude-agent-sdk/sdk.d.ts):
+            //   - `tools`        → which built-in tools the model can see (Read, Bash, Task, …)
+            //   - `mcpServers`   → MCP servers to spawn; all their declared tools are exposed automatically
+            //   - `allowedTools` → auto-allow list covering both built-ins AND MCP tool names
+            //                      (MCP names MUST live here, not in `tools` — that was the bug
+            //                      producing `<tool_use_error>No such tool available: mcp__*__*`
+            //                      for every Extension and custom stdio server).
+            //   - `disallowedTools` → blocklist, takes precedence.
+            tools: disableAllTools ? [] : allowedTools.filter(t => !t.startsWith('mcp__')),
+            allowedTools: disableAllTools ? [] : allowedTools,
             disallowedTools: disallowed,
             ...(streaming ? { includePartialMessages: true } : {}),
             mcpServers: {
@@ -2237,6 +2261,20 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     eventLog.emitQueryStart(sessionKey, prompt, { model: sdkOptions.model ?? undefined, source: 'chat' });
                 }
                 try {
+                    // Diagnostic (1.0.64+): log the exact options we hand to query().
+                    // Compare against a known-working standalone call to pinpoint
+                    // config drift. Single-line grep target: 'query() options'.
+                    logger.info({
+                        sessionKey,
+                        cwd: sdkOptions.cwd,
+                        mcpServerKeys: Object.keys(sdkOptions.mcpServers ?? {}),
+                        toolsCount: Array.isArray(sdkOptions.tools) ? sdkOptions.tools.length : 'preset-or-omitted',
+                        allowedToolsCount: sdkOptions.allowedTools?.length ?? 0,
+                        disallowedToolsCount: sdkOptions.disallowedTools?.length ?? 0,
+                        hasResume: !!sdkOptions.resume,
+                        resumeSessionId: sdkOptions.resume,
+                        model: sdkOptions.model,
+                    }, 'query() options');
                     const stream = query({ prompt, options: sdkOptions });
                     let gotStreamEvents = false;
                     for await (const message of stream) {
@@ -2600,6 +2638,41 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                                 })(),
                                 replyPreview: responseText.slice(0, 200).replace(/\n/g, ' '),
                             }, 'Contradiction validator pass');
+                            // Diagnostic (1.0.64+): dump EVERY tool_result whose content
+                            // looks like the SDK's "No such tool available" error, with
+                            // its full content + corresponding tool_use. The specific
+                            // pairing is what we need to diagnose whether a particular
+                            // server failed to register vs a specific tool was dropped.
+                            try {
+                                const useById = new Map();
+                                for (const msg of collectedSdkMessages) {
+                                    if (msg.type !== 'assistant' || !msg.message?.content)
+                                        continue;
+                                    for (const b of (Array.isArray(msg.message.content) ? msg.message.content : [])) {
+                                        if (b?.type === 'tool_use' && b.id && b.name)
+                                            useById.set(b.id, b.name);
+                                    }
+                                }
+                                for (const msg of collectedSdkMessages) {
+                                    if (msg.type !== 'user' || !msg.message?.content)
+                                        continue;
+                                    for (const b of (Array.isArray(msg.message.content) ? msg.message.content : [])) {
+                                        if (b?.type !== 'tool_result')
+                                            continue;
+                                        const contentStr = typeof b.content === 'string' ? b.content : JSON.stringify(b.content);
+                                        if (/tool_use_error/i.test(contentStr)) {
+                                            logger.warn({
+                                                sessionKey,
+                                                tool_use_id: b.tool_use_id,
+                                                tool_name: useById.get(b.tool_use_id) ?? '(unknown)',
+                                                is_error: b.is_error,
+                                                content: contentStr.slice(0, 600),
+                                            }, 'SDK tool_use_error surfaced');
+                                        }
+                                    }
+                                }
+                            }
+                            catch { /* non-fatal */ }
                         }
                         const finding = detectContradiction(responseText, toolCallRecords);
                         if (finding) {
@@ -3175,7 +3248,10 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                     model: AUTO_MEMORY_MODEL,
                     permissionMode: 'bypassPermissions',
                     allowDangerouslySkipPermissions: true,
-                    tools: [
+                    // MCP tool names live in allowedTools, not tools. See note at
+                    // buildOptions — `tools` is for built-ins only.
+                    tools: [],
+                    allowedTools: [
                         mcpTool('memory_write'),
                         mcpTool('memory_search'),
                         mcpTool('note_create'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.0.62",
+  "version": "1.0.64",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",