@skaile/workspaces 4.12.0 → 4.14.0

package/dist/bridge/drivers/claude-sdk.js

@@ -1,31 +1,178 @@
 import { scrubPoisonedTranscript, resolveClaudeConfigDir, claudeEndpointMode, buildClaudeEndpointEnv } from '../../chunk-4SIMGJIU.js';
-import { dispatchCapability } from '../../chunk-CPIAQTYM.js';
-import { fetchProviderModels } from '../../chunk-4G6HFU27.js';
+import { dispatchCapability } from '../../chunk-TOXPRXAK.js';
+import { fetchProviderModels } from '../../chunk-ZXQMKXWR.js';
 import { AuthError, classifyClaudeSdkError, reclassifyAuthAsAccountUnavailable, AccountUnavailableError } from '../../chunk-GAH4YRCI.js';
-import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger, entryCredentialValue, registryDriverConfig } from '../../chunk-RQRWMKST.js';
+import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger, entryCredentialValue, registryDriverConfig } from '../../chunk-LQMALDDB.js';
 import '../../chunk-6E6PKKAD.js';
-import { withActivityLabelShape } from '../../chunk-O64WU6WS.js';
-import '../../chunk-3QCLMSXU.js';
+import { withActivityLabelShape } from '../../chunk-QQ3G5N7X.js';
+import '../../chunk-7NRF7BQB.js';
 import '../../chunk-4GY63JU6.js';
-import '../../chunk-N4DHPRBS.js';
+import '../../chunk-NXTLDFLA.js';
 import '../../chunk-F3HNW354.js';
 import '../../chunk-K5GBV4SA.js';
 import '../../chunk-QVZA2MDT.js';
-import '../../chunk-2J3PASYF.js';
+import '../../chunk-QWGSKDD7.js';
 import '../../chunk-MENCWIHW.js';
 import '../../chunk-P4VHQA4N.js';
 import '../../chunk-2FBPAR2V.js';
 import '../../chunk-GEEW6SY2.js';
-import '../../chunk-RUBPZLMO.js';
+import '../../chunk-JMKB7IB4.js';
 import '../../chunk-DPLIN2RA.js';
 import { mergeRegistries, parseModelRef, isEntryEnabled, resolveEntryBaseUrl } from '../../chunk-GZZPKAV5.js';
-import '../../chunk-BOFL7GIF.js';
+import '../../chunk-C3CAXQMA.js';
+import { createLogger } from '../../chunk-BOFL7GIF.js';
 import '../../chunk-N7B3LZ7V.js';
 import '../../chunk-NSBPE2FW.js';
 import { spawnSync, spawn } from 'child_process';
 import { readFileSync, existsSync } from 'fs';
 import { createRequire } from 'module';
 import * as zNS from 'zod';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+
+var TOOL_PROPERTY_KEY_PATTERN = /^[a-zA-Z0-9_.-]{1,64}$/;
+var DRAFT_2020_12_META = "https://json-schema.org/draft/2020-12/schema";
+var PROBE_TIMEOUT_MS = 5e3;
+var metaValidator = null;
+function draft202012MetaValidator() {
+  if (metaValidator) return metaValidator;
+  const ajv = new Ajv2020({ strict: false, validateFormats: false, logger: false });
+  const validate = ajv.getSchema(DRAFT_2020_12_META);
+  if (!validate) throw new Error("ajv draft 2020-12 meta-schema is unavailable");
+  metaValidator = validate;
+  return validate;
+}
+function checkToolPropertyKeys(schema) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return null;
+  const props = schema.properties;
+  if (!props || typeof props !== "object" || Array.isArray(props)) return null;
+  for (const key of Object.keys(props)) {
+    if (!TOOL_PROPERTY_KEY_PATTERN.test(key)) {
+      return `property key ${JSON.stringify(key)} does not match ${TOOL_PROPERTY_KEY_PATTERN.source}`;
+    }
+  }
+  return null;
+}
+function checkToolInputSchema(schema) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return "input schema is not a JSON object";
+  }
+  const keyReason = checkToolPropertyKeys(schema);
+  if (keyReason) return keyReason;
+  const validate = draft202012MetaValidator();
+  if (!validate(schema)) {
+    const first = validate.errors?.[0];
+    const where = first?.instancePath || "/";
+    return `not valid JSON Schema draft 2020-12: ${where} ${first?.message ?? "is invalid"}`;
+  }
+  return null;
+}
+var filteredInstances = /* @__PURE__ */ new WeakMap();
+function sdkInstanceOf(config) {
+  if (!config || typeof config !== "object") return null;
+  const c = config;
+  if (c.type !== "sdk" || !c.instance || typeof c.instance !== "object") return null;
+  const inst = c.instance;
+  return typeof inst.connect === "function" && typeof inst.close === "function" ? inst : null;
+}
+function withTimeout(p, what) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`${what} timed out`)), PROBE_TIMEOUT_MS);
+  });
+  return Promise.race([p, timeout]).finally(() => clearTimeout(timer));
+}
+async function listInProcessTools(instance) {
+  const [clientSide, serverSide] = InMemoryTransport.createLinkedPair();
+  const pending = /* @__PURE__ */ new Map();
+  clientSide.onmessage = (msg) => {
+    const m = msg;
+    const id = typeof m.id === "number" ? m.id : void 0;
+    if (id === void 0) return;
+    pending.get(id)?.(m);
+    pending.delete(id);
+  };
+  let nextId = 1;
+  const call = (method, params) => withTimeout(
+    new Promise((resolve, reject) => {
+      const id = nextId++;
+      pending.set(id, resolve);
+      clientSide.send({ jsonrpc: "2.0", id, method, params }).catch(reject);
+    }),
+    method
+  ).then((res) => {
+    if (res.error) throw new Error(`${method} failed: ${JSON.stringify(res.error)}`);
+    return res.result ?? {};
+  });
+  await clientSide.start();
+  await instance.connect(serverSide);
+  try {
+    await call("initialize", {
+      protocolVersion: "2025-06-18",
+      capabilities: {},
+      clientInfo: { name: "skaile-tool-schema-filter", version: "1.0.0" }
+    });
+    await clientSide.send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    const tools = [];
+    let cursor;
+    do {
+      const page = await call("tools/list", cursor ? { cursor } : {});
+      tools.push(...page.tools ?? []);
+      cursor = typeof page.nextCursor === "string" ? page.nextCursor : void 0;
+    } while (cursor);
+    return tools;
+  } finally {
+    await instance.close().catch(() => {
+    });
+  }
+}
+var defaultLog = createLogger({ kind: "mcp", subkind: "tool-schema-filter" });
+async function filterInProcessMcpServerTools(server, config, log = defaultLog) {
+  const instance = sdkInstanceOf(config);
+  if (!instance) return [];
+  const cached = filteredInstances.get(instance);
+  if (cached) return cached;
+  const registered = instance._registeredTools;
+  if (!registered || Object.keys(registered).length === 0) return [];
+  if (instance.isConnected?.()) {
+    log.debug("in-process MCP server already connected; schema check skipped", { server });
+    return [];
+  }
+  let wireTools;
+  try {
+    wireTools = await listInProcessTools(instance);
+  } catch (err) {
+    log.warn("could not inspect in-process MCP server tools; passing it unchanged", {
+      server,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return [];
+  }
+  const dropped = [];
+  for (const tool of wireTools) {
+    const reason = checkToolInputSchema(tool.inputSchema);
+    if (!reason) continue;
+    const handle = registered[tool.name];
+    if (typeof handle?.disable !== "function") {
+      log.warn("MCP tool has an invalid input schema but cannot be disabled", {
+        server,
+        tool: tool.name,
+        reason
+      });
+      continue;
+    }
+    handle.disable();
+    dropped.push({ server, tool: tool.name, reason });
+    log.warn("MCP tool dropped: invalid input schema", { server, tool: tool.name, reason });
+  }
+  filteredInstances.set(instance, dropped);
+  return dropped;
+}
+function formatDroppedToolsNotice(dropped) {
+  if (dropped.length === 0) return null;
+  const items = dropped.map((d) => `${d.tool} (server ${d.server}: ${d.reason})`).join("; ");
+  return `Some MCP tools were not loaded because the Claude API would reject their input schema: ${items}. Do not try to call them.`;
+}
 
 // bridge/src/drivers/sanitize-assistant-text.ts
 var NS = "(?:[a-z][a-z0-9]*:)?";
@@ -306,6 +453,8 @@ var ClaudeSdkDriver = class extends AgentDriver {
     supportsInBandAbort: true
   };
   log = getBridgeLogger("claude-sdk");
+  /** `kind: mcp` logger for tool-schema drops, alongside the runner's MCP rows. */
+  mcpLog = createLogger({ kind: "mcp", subkind: "tool-schema-filter" });
   config;
   abortController = null;
   running = false;
@@ -522,6 +671,8 @@ var ClaudeSdkDriver = class extends AgentDriver {
    * upstream auth-shaped failures get a quota-aware hint when warranted.
    */
   usingOauthCredential = false;
+  /** Capability tools already warned about, so a per-turn rebuild logs each once. */
+  warnedDroppedCapabilityTools = /* @__PURE__ */ new Set();
   /**
    * @param config - Driver configuration. Claude SDK-relevant fields:
    *   - `cwd` — working directory; SDK session files and agent definitions are read from here.
@@ -1264,10 +1415,16 @@ var ClaudeSdkDriver = class extends AgentDriver {
     this.usingOauthCredential = endpoint.mode === "anthropic" && !endpoint.credential;
     const claudePath = this.findClaudeBinary();
     const onStderr = (data) => this.log.warn("claude stderr", { line: data.trim() });
+    const { patch: mcpServersPatch, dropped: droppedMcpTools } = await this.buildEffectiveMcpServers();
+    const systemPromptAppend = [this.config.systemPrompt, formatDroppedToolsNotice(droppedMcpTools)].filter((part) => !!part).join("\n\n");
     const options = {
       cwd: this.config.cwd,
       // Load project + user settings so .claude/skills/ are discovered
       settingSources: ["user", "project"],
+      // MCP servers come only from the runner (`mcpServers` below). Without
+      // this the CLI also loads the workspace repo's `.mcp.json` unprompted,
+      // which bypasses the runner's approval flow and the schema filter.
+      strictMcpConfig: true,
       // Use full Claude Code tool preset so skills, agents, etc. work
       tools: { type: "preset", preset: "claude_code" },
       permissionMode: "bypassPermissions",
@@ -1319,7 +1476,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
       systemPrompt: {
         type: "preset",
         preset: "claude_code",
-        ...this.config.systemPrompt ? { append: this.config.systemPrompt } : {}
+        ...systemPromptAppend ? { append: systemPromptAppend } : {}
       },
       // ── Session continuity ────────────────────────────────────────────────
       // Three-level fallback ensures the right session is always resumed:
@@ -1340,7 +1497,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
       // calls into that server route back through `hooks.invoke()` so the
       // registry's per-handler logger fires and fire-and-forget / render
       // semantics apply uniformly.
-      ...await this.buildEffectiveMcpServers(),
+      ...mcpServersPatch,
       // ── Main-agent handoff ────────────────────────────────────────────────
       // agentName (from AgentConfig) is the equivalent of `claude --agent <name>`.
       // The SDK reads .claude/agents/<agentName>.md from the cwd; that file was
@@ -1468,40 +1625,81 @@ var ClaudeSdkDriver = class extends AgentDriver {
    *
    * Returns an empty options patch when neither source is configured, so legacy
    * v1 sessions remain unaffected.
+   *
+   * Tools the Claude API would reject are removed on the way out and
+   * reported in `dropped`, so one bad tool cannot fail every turn when the
+   * CLI's own flag-gated filter is off: `config.mcpServers` entries get the
+   * wire probe, and `skaile-capabilities` gets the key rule while it is built
+   * (see {@link buildCapabilityMcpServer}).
    */
   async buildEffectiveMcpServers() {
     const out = {};
+    const dropped = [];
     if (this.config.mcpServers) {
       Object.assign(out, this.config.mcpServers);
     }
     const hooks = this.config.capabilities;
     if (hooks) {
-      const capServer = await this.buildCapabilityMcpServer();
-      if (capServer) {
-        out["skaile-capabilities"] = capServer;
+      const cap = await this.buildCapabilityMcpServer();
+      dropped.push(...cap.dropped);
+      if (cap.server) {
+        out["skaile-capabilities"] = cap.server;
       }
     }
-    return Object.keys(out).length > 0 ? { mcpServers: out } : {};
+    if (this.config.mcpServers) {
+      const results = await Promise.all(
+        Object.entries(this.config.mcpServers).map(
+          ([name, config]) => filterInProcessMcpServerTools(name, config, this.mcpLog)
+        )
+      );
+      for (const r of results) dropped.push(...r);
+    }
+    return {
+      patch: Object.keys(out).length > 0 ? { mcpServers: out } : {},
+      dropped
+    };
   }
   /**
    * Build the synthetic MCP server that exposes registered capabilities to the
    * Claude Agent SDK. Lazy-imports `createSdkMcpServer` from the SDK and `zod`
    * (an SDK peer) since both are optional peers of this bridge.
    *
-   * Returns null when the SDK or zod is unavailable, or when the registry
+   * `server` is null when the SDK or zod is unavailable, or when the registry
    * exposes no tools — leaving the legacy `mcpServers` untouched.
+   *
+   * A tool whose declared schema has a property key the API rejects
+   * ({@link checkToolPropertyKeys}) is left out and reported in `dropped`.
+   * Only the key rule applies here: `jsonSchemaToZodLoose` copies keys
+   * verbatim but flattens every other construct to string/number/boolean/
+   * array/record/any, so the wire schema is always valid draft 2020-12 and
+   * a declared-schema meta check would drop tools that work.
    */
   async buildCapabilityMcpServer() {
+    const dropped = [];
     const hooks = this.config.capabilities;
-    if (!hooks) return null;
-    const tools = hooks.composeTools();
-    if (tools.length === 0) return null;
+    if (!hooks) return { server: null, dropped };
+    const tools = hooks.composeTools().filter((tool) => {
+      const reason = checkToolPropertyKeys(tool.parameters);
+      if (!reason) return true;
+      dropped.push({ server: "skaile-capabilities", tool: tool.name, reason });
+      const key = `${tool.name}\0${reason}`;
+      if (!this.warnedDroppedCapabilityTools.has(key)) {
+        this.warnedDroppedCapabilityTools.add(key);
+        this.mcpLog.warn("MCP tool dropped: invalid input schema", {
+          server: "skaile-capabilities",
+          tool: tool.name,
+          reason
+        });
+      }
+      return false;
+    });
+    if (tools.length === 0) return { server: null, dropped };
     let sdk;
     try {
       sdk = await import('@anthropic-ai/claude-agent-sdk');
     } catch {
       this.log.warn("claude-agent-sdk unavailable; cannot build capability MCP server");
-      return null;
+      return { server: null, dropped };
     }
     const z2 = zStatic;
     const sdkTools = tools.map((tool) => ({
@@ -1541,7 +1739,10 @@ var ClaudeSdkDriver = class extends AgentDriver {
         }
       }
     }));
-    return sdk.createSdkMcpServer({ name: "skaile-capabilities", tools: sdkTools });
+    return {
+      server: sdk.createSdkMcpServer({ name: "skaile-capabilities", tools: sdkTools }),
+      dropped
+    };
   }
   /** Fetch and cache slash commands from the SDK query. */
   async fetchSlashCommands() {
@@ -1933,10 +2134,12 @@ var ClaudeSdkDriver = class extends AgentDriver {
   handleAssistantMessage(msg) {
     this.captureAssistantContext(msg);
     const agentMsg = this.mapAssistantMessage(msg);
-    const apiErrorKind = msg.error;
-    if (!msg.parent_tool_use_id) {
-      this.lastApiErrorRender = typeof apiErrorKind === "string" ? { kind: apiErrorKind, excerpt: apiErrorExcerpt(this.assistantTextOf(agentMsg)) } : null;
+    if (msg.parent_tool_use_id) {
+      this.emitSubagentAssistantMessage(agentMsg, msg.parent_tool_use_id);
+      return;
     }
+    const apiErrorKind = msg.error;
+    this.lastApiErrorRender = typeof apiErrorKind === "string" ? { kind: apiErrorKind, excerpt: apiErrorExcerpt(this.assistantTextOf(agentMsg)) } : null;
     if (this.isSuppressibleAuthRender(agentMsg)) {
       this.log.info("suppressing SDK auth-error assistant text; self-heal will retry");
       this.stashSuppressedAuthRender(this.assistantTextOf(agentMsg));
@@ -1963,6 +2166,31 @@ var ClaudeSdkDriver = class extends AgentDriver {
     this.suppressedAuthRenderText = null;
     this.emit("agent-event", { type: "message_end", message: agentMsg });
   }
+  /**
+   * A subagent runs concurrently with the main reply, so its messages must not
+   * touch the main thread's stream state (the reset below would cut the main
+   * reply's sanitizer and auth-render tracking mid-stream). Its tool calls are
+   * still reported, tagged so consumers can tell them from the main thread's.
+   */
+  emitSubagentAssistantMessage(agentMsg, parentToolUseId) {
+    if (this.isSuppressibleAuthRender(agentMsg)) {
+      this.log.info("suppressing SDK auth-error subagent text; self-heal will retry");
+      this.stashSuppressedAuthRender(this.assistantTextOf(agentMsg));
+      return;
+    }
+    this.emit("agent-event", { type: "message_start", message: agentMsg });
+    for (const tc of agentMsg.toolCalls ?? []) {
+      this.emit("agent-event", {
+        type: "tool_call",
+        name: tc.name,
+        tool: { name: tc.name },
+        toolCallId: tc.id,
+        input: tc.input,
+        parentToolUseId
+      });
+    }
+    this.emit("agent-event", { type: "message_end", message: agentMsg });
+  }
   // True when this assistant text is the SDK's render of a 401 about to be self-healed.
   isSuppressibleAuthRender(msg) {
     if (msg.toolCalls && msg.toolCalls.length > 0) return false;
@@ -2011,6 +2239,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
     return classifyClaudeSdkError({ errors: [text], oauthCredential: this.usingOauthCredential }).category === "auth";
   }
   handleStreamEvent(msg) {
+    if (msg.parent_tool_use_id) return;
     const event = msg.event;
     if (event?.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta.text) {
       const delta = event.delta.text;
@@ -2043,7 +2272,8 @@ var ClaudeSdkDriver = class extends AgentDriver {
     for (const result of toolResults) {
       this.emit("agent-event", {
         type: "tool_execution_end",
-        toolName: result.toolName
+        toolName: result.toolName,
+        ...result.parentToolUseId ? { parentToolUseId: result.parentToolUseId } : {}
       });
     }
     if (toolResults.length > 0) {
@@ -2273,7 +2503,8 @@ var ClaudeSdkDriver = class extends AgentDriver {
     return {
       role: "assistant",
       content: contentBlocks,
-      toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+      ...msg.parent_tool_use_id ? { parentToolUseId: msg.parent_tool_use_id } : {}
     };
   }
   mapToolResults(msg) {
@@ -2286,7 +2517,8 @@ var ClaudeSdkDriver = class extends AgentDriver {
             role: "tool",
             content: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
             toolName: this.toolIdToName.get(block.tool_use_id) ?? block.tool_use_id,
-            isError: block.is_error
+            isError: block.is_error,
+            ...msg.parent_tool_use_id ? { parentToolUseId: msg.parent_tool_use_id } : {}
           });
         }
       }