@demicodes/provider-claude-code 0.10.0 → 0.10.1

package/README.md

@@ -27,6 +27,16 @@ See [docs/provider-global-credentials.md](../../docs/provider-global-credentials
 
 See [docs/provider-quota.md](../../docs/provider-quota.md).
 
+## Tool-call batches
+
+Claude Code's SDK-MCP control channel can hold later `tools/call` callbacks until
+the preceding callback receives a result, even when the model emitted several
+`tool_use` blocks in one response. The provider preserves the model's original
+batch and tool-use IDs for the host scheduler, then matches the completed
+results to SDK-MCP callbacks as the CLI releases them.
+
+See [docs/tool-call-concurrency.md](../../docs/tool-call-concurrency.md).
+
 > Diagnostics: the transport writes a raw request/response wire log (including
 > prompts) to `$TMPDIR/demi-claude-wire` by default. Disable with
 > `DEMI_CLAUDE_WIRE_LOG=0`. See [SECURITY](../../SECURITY.md).

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { errorMessage, isRecord, nonEmptyString, numberOrNull, stringOrNull } from "@demicodes/utils";
+import { abortable, errorMessage, isRecord, nonEmptyString, numberOrNull, stringOrNull } from "@demicodes/utils";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { applyModelPolicy, clampUsedPercent, createProviderQuota, defineProvider, numberHeader, severityFromUsedPercent, toolResultContentToText, unixSecondsToIso } from "@demicodes/provider";
 import { execFile, spawn } from "node:child_process";
@@ -834,7 +834,7 @@ function mapClaudeStdoutMessage(message, options = {}) {
 		events,
 		terminal: false
 	};
-	if (message.type === "assistant" && isRecord(message.message) && !options.ignoreAssistantContent) events.push(...mapContentArray(message.message.content, options));
+	if (message.type === "assistant" && isRecord(message.message)) events.push(...mapContentArray(message.message.content, options));
 	if (message.type === "stream_event" && isRecord(message.event)) events.push(...mapStreamEvent(message.event));
 	if (message.type === "control_request") {
 		const request = parseControlRequest(message);
@@ -892,11 +892,11 @@ function mapContentArray(content, options) {
 	const events = [];
 	for (const block of content) {
 		if (!isRecord(block)) continue;
-		if (block.type === "text") events.push({
+		if (block.type === "text" && !options.ignoreAssistantContent) events.push({
 			type: "text_delta",
 			text: String(block.text ?? "")
 		});
-		else if (block.type === "thinking") {
+		else if (block.type === "thinking" && !options.ignoreAssistantContent) {
 			events.push({ type: "thinking_start" });
 			events.push({
 				type: "thinking_delta",
@@ -906,7 +906,7 @@ function mapContentArray(content, options) {
 				type: "thinking_signature",
 				signature: block.signature
 			});
-		} else if (block.type === "redacted_thinking") events.push({
+		} else if (block.type === "redacted_thinking" && !options.ignoreAssistantContent) events.push({
 			type: "redacted_thinking",
 			data: String(block.data ?? "")
 		});
@@ -970,6 +970,7 @@ function parseControlRequest(message) {
 			outerRequestId: message.request_id,
 			serverName: request.server_name,
 			id,
+			toolUseId: sdkMcpToolUseId(inner.params),
 			method,
 			params: inner.params
 		};
@@ -984,6 +985,11 @@ function parseControlRequest(message) {
 		params: message.params
 	};
 }
+function sdkMcpToolUseId(params) {
+	if (!isRecord(params) || !isRecord(params._meta)) return void 0;
+	const value = params._meta["claudecode/toolUseId"];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 /**
 * Usage for the response event from a `result` message. The top-level
 * `result.usage` sums every API call the CLI made within the turn (initial call
@@ -1434,21 +1440,50 @@ var ClaudeCodeProvider = class {
 				}
 				const raw = next.value;
 				this.observeQuotaFromMessage(raw);
-				const mapped = mapClaudeStdoutMessage(raw, {
-					ignoreAssistantContent: active.hasStreamed && isMessageType(raw, "assistant"),
-					ignoreAssistantToolUse: active.sdkMcpEnabled
-				});
+				const mapped = mapClaudeStdoutMessage(raw, { ignoreAssistantContent: active.hasStreamed && isMessageType(raw, "assistant") });
 				if (isMessageType(raw, "stream_event")) active.hasStreamed = true;
 				if (mapped.controlRequest) {
-					if (await this.handleControlRequest(active, mapped.controlRequest, request) === "tool-call") {
+					const handled = await this.handleControlRequest(active, mapped.controlRequest, request);
+					if (handled === "tool-call") {
 						const event = active.pendingControlRequest ? controlRequestToToolCall(active.pendingControlRequest) : null;
 						keepActiveForContinuation = true;
 						if (event) yield event;
 						return;
 					}
+					if (handled === "sdk-tool-call") {
+						const pending = active.pendingSdkControlRequests.get(mapped.controlRequest.toolUseId ?? "");
+						const event = pending ? controlRequestToToolCall(pending) : null;
+						if (event?.type === "tool_call_requested") {
+							active.pendingSdkToolCalls = [event];
+							keepActiveForContinuation = true;
+							yield event;
+						}
+						return;
+					}
 					continue;
 				}
 				const toolUseIds = mapped.events.filter(isToolCallRequested).map((event) => event.toolUseId);
+				if (active.sdkMcpEnabled) {
+					for (const event of mapped.events) {
+						if (event.type === "tool_call_requested") {
+							active.collectingSdkToolCalls.set(event.toolUseId, event);
+							continue;
+						}
+						yield event;
+					}
+					if (isStreamMessageStop(raw) && active.collectingSdkToolCalls.size > 0) {
+						active.pendingSdkToolCalls = [...active.collectingSdkToolCalls.values()];
+						active.collectingSdkToolCalls.clear();
+						keepActiveForContinuation = true;
+						for (const event of active.pendingSdkToolCalls) yield event;
+						return;
+					}
+					if (mapped.terminal) {
+						keepActiveForContinuation = true;
+						return;
+					}
+					continue;
+				}
 				if (toolUseIds.length > 0) active.pendingToolUseIds = toolUseIds;
 				for (const event of mapped.events) {
 					if (event.type === "tool_call_requested") keepActiveForContinuation = true;
@@ -1494,7 +1529,7 @@ var ClaudeCodeProvider = class {
 		const credentialId = this.getActiveCredentialId ? await this.getActiveCredentialId() : null;
 		const existing = this.active;
 		if (existing && existing.sessionId === request.sessionId && existing.modelId === request.modelId && existing.thinkingSig === thinkingSignature(request) && existing.credentialId === credentialId) {
-			if (existing.pendingControlRequest !== null || existing.pendingToolUseIds.length > 0 || !itemsDiverged(existing, request.items)) {
+			if (existing.pendingControlRequest !== null || existing.pendingSdkToolCalls.length > 0 || existing.pendingToolUseIds.length > 0 || !itemsDiverged(existing, request.items)) {
 				await this.sendContinuation(existing, request);
 				return existing;
 			}
@@ -1508,6 +1543,9 @@ var ClaudeCodeProvider = class {
 			transport,
 			iterator: transport.messages()[Symbol.asyncIterator](),
 			pendingControlRequest: null,
+			pendingSdkControlRequests: /* @__PURE__ */ new Map(),
+			pendingSdkToolCalls: [],
+			collectingSdkToolCalls: /* @__PURE__ */ new Map(),
 			pendingToolUseIds: [],
 			bufferedMessages: [],
 			sdkMcpEnabled: request.tools.length > 0,
@@ -1532,6 +1570,10 @@ var ClaudeCodeProvider = class {
 			await this.writeToolResults(request, active.pendingControlRequest);
 			active.pendingControlRequest = null;
 		}
+		if (active.pendingSdkToolCalls.length > 0) {
+			await this.writeSdkMcpToolResults(active, request);
+			active.pendingSdkToolCalls = [];
+		}
 		if (active.pendingToolUseIds.length > 0) {
 			await this.writeToolResultMessages(request, active.pendingToolUseIds);
 			active.pendingToolUseIds = [];
@@ -1585,6 +1627,15 @@ var ClaudeCodeProvider = class {
 				await this.writeControlError(active, request, "Invalid tools/call request");
 				return "handled";
 			}
+			if (request.protocol === "sdk-mcp") {
+				request.toolUseId ??= `mcp-control-${randomUUID()}`;
+				const normalized = {
+					...request,
+					toolUseId: request.toolUseId
+				};
+				active.pendingSdkControlRequests.set(normalized.toolUseId, normalized);
+				return active.hasStreamed ? "handled" : "sdk-tool-call";
+			}
 			active.pendingControlRequest = {
 				...request,
 				toolUseId: `mcp-control-${randomUUID()}`
@@ -1594,6 +1645,38 @@ var ClaudeCodeProvider = class {
 		await this.writeControlError(active, request, `Unsupported method: ${request.method}`);
 		return "handled";
 	}
+	async writeSdkMcpToolResults(active, request) {
+		const results = new Map(request.items.filter((item) => item.type === "tool_result").map((item) => [item.toolUseId, item]));
+		const expected = active.pendingSdkToolCalls.map((event) => event.toolUseId);
+		const missing = expected.filter((toolUseId) => !results.has(toolUseId));
+		if (missing.length > 0) throw new Error(`Claude Code provider missing tool_result for SDK MCP tool_use ${missing.join(", ")}`);
+		const remaining = new Set(expected);
+		while (remaining.size > 0) {
+			let responded = false;
+			for (const toolUseId of remaining) {
+				const controlRequest = active.pendingSdkControlRequests.get(toolUseId);
+				if (!controlRequest) continue;
+				await this.writeToolResults(request, controlRequest);
+				active.pendingSdkControlRequests.delete(toolUseId);
+				remaining.delete(toolUseId);
+				responded = true;
+			}
+			if (remaining.size === 0) return;
+			if (responded) continue;
+			const next = await abortable(active.iterator.next(), request.cancel);
+			if (next.done) throw new Error(`Claude Code exited before requesting SDK MCP tool result for ${[...remaining].join(", ")}`);
+			this.observeQuotaFromMessage(next.value);
+			const mapped = mapClaudeStdoutMessage(next.value, {
+				ignoreAssistantContent: true,
+				ignoreAssistantToolUse: true
+			});
+			if (mapped.controlRequest) {
+				if (await this.handleControlRequest(active, mapped.controlRequest, request) === "tool-call") throw new Error("Claude Code emitted a legacy tool call while awaiting SDK MCP results");
+				continue;
+			}
+			active.bufferedMessages.push(next.value);
+		}
+	}
 	async writeToolResults(request, controlRequest) {
 		if (!this.active) throw new Error("No active Claude transport");
 		const expectedToolUseId = controlRequest.toolUseId ?? String(controlRequest.id);
@@ -1757,6 +1840,9 @@ function toolResultContentToMcp(output) {
 function isMessageType(value, type) {
 	return isRecord(value) && value.type === type;
 }
+function isStreamMessageStop(value) {
+	return isRecord(value) && value.type === "stream_event" && isRecord(value.event) && value.event.type === "message_stop";
+}
 function thinkingSignature(request) {
 	return JSON.stringify(request.thinking ?? null);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@demicodes/provider-claude-code",
   "description": "Claude Code provider adapter for Demi.",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "private": false,
   "type": "module",
   "exports": {
@@ -11,13 +11,13 @@
     }
   },
   "dependencies": {
-    "@demicodes/core": "^0.10.0",
-    "@demicodes/provider": "^0.10.0",
-    "@demicodes/utils": "^0.10.0"
+    "@demicodes/core": "^0.10.1",
+    "@demicodes/provider": "^0.10.1",
+    "@demicodes/utils": "^0.10.1"
   },
   "devDependencies": {
-    "@demicodes/agent": "^0.10.0",
-    "@demicodes/shell": "^0.10.0"
+    "@demicodes/agent": "^0.10.1",
+    "@demicodes/shell": "^0.10.1"
   },
   "license": "Apache-2.0",
   "main": "./dist/index.mjs",