@ai-sdk/harness-claude-code 1.0.171 → 1.0.173

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @ai-sdk/harness-claude-code
 
+## 1.0.173
+
+### Patch Changes
+
+- edd4d4f: fix(harness-claude-code): correctly map dotted AI Gateway model IDs to the ID shapes Claude Code expects
+- Updated dependencies [7716e18]
+- Updated dependencies [5c247e9]
+- Updated dependencies [dcd2f8d]
+  - @ai-sdk/provider-utils@5.0.72
+  - @ai-sdk/provider@4.0.35
+  - @ai-sdk/harness@1.0.169
+
+## 1.0.172
+
+### Patch Changes
+
+- 4ab93bb: feat(harness-claude-code): add `toolHints` to mark host tools read-only or always-loaded
+- ede06e3: carry out an approval answered after a resume instead of asking again
+- 0808bf4: fix(harness-claude-code): preserve host tool numeric bounds, string lengths, array item counts, and defaults in Zod schemas
+- Updated dependencies [033f8d9]
+- Updated dependencies [e7a8988]
+- Updated dependencies [2c12e25]
+- Updated dependencies [61a315e]
+- Updated dependencies [6eab0f7]
+  - @ai-sdk/harness@1.0.168
+  - @ai-sdk/provider-utils@5.0.71
+
 ## 1.0.171
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -1224,7 +1224,8 @@ function defaultUsage() {
 //#endregion
 //#region src/bridge/json-schema-to-zod.ts
 function jsonSchemaToZodObject(input) {
-	return toZodObject(isJsonSchemaObject(input) ? input : {});
+	const schema = isJsonSchemaObject(input) ? input : {};
+	return withJsonSchemaMetadata(toZodObject(schema), schema);
 }
 function toZodObject(schema) {
 	const object = z.object(toZodShape(schema));
@@ -1248,7 +1249,22 @@ function toZodType(schema) {
 	let zType = zodForConst(schema) ?? zodForEnum(schema) ?? zodForUnion(schema) ?? zodForType(schema);
 	if (isNullable(schema)) zType = zType.nullable();
 	if (schema.description) zType = zType.describe(schema.description);
-	return zType;
+	return withJsonSchemaMetadata(zType, schema);
+}
+function withJsonSchemaMetadata(zType, schema) {
+	const metadata = {};
+	for (const key of [
+		"minimum",
+		"maximum",
+		"exclusiveMinimum",
+		"exclusiveMaximum",
+		"minLength",
+		"maxLength",
+		"minItems",
+		"maxItems",
+		"default"
+	]) if (schema[key] !== void 0) metadata[key] = schema[key];
+	return zType.meta(metadata);
 }
 function zodForType(schema) {
 	const types = getNonNullTypes(schema);
@@ -1487,18 +1503,23 @@ function createPermissionOptions(input) {
 	return {
 		...baseOptions,
 		canUseTool: async (toolName, toolInput, options) => {
-			if (toolName.startsWith("mcp__harness-tools__")) return {
-				behavior: "allow",
-				updatedInput: toolInput
-			};
-			if (!inactiveNativeTools.has(toolName) && !nativeToolRequiresApproval({
-				nativeName: toolName,
-				permissionMode
+			if (!needsHostApproval({
+				toolName,
+				permissionMode,
+				inactiveNativeTools
 			})) return {
 				behavior: "allow",
 				updatedInput: toolInput
 			};
 			const approvalId = options.toolUseID;
+			if (input.approvalDecisions.get(approvalId)?.approved === true) {
+				input.approvalDecisions.delete(approvalId);
+				return {
+					behavior: "allow",
+					updatedInput: toolInput,
+					toolUseID: approvalId
+				};
+			}
 			input.approvalRequestedToolUseIds.add(approvalId);
 			input.nativeToolCallNames.set(approvalId, toolName);
 			if (!input.emittedToolCallIds.has(approvalId)) {
@@ -1582,6 +1603,53 @@ function createPermissionSettings(input) {
 		sandbox: { autoAllowBashIfSandboxed: false }
 	};
 }
+/**
+* Claude Code picks a model's output limit, system prompt and default effort
+* from its own reading of the model id, and misreads AI Gateway ids with a
+* dotted version such as `anthropic/claude-opus-5.5`. `modelOverrides` maps
+* the id Claude Code expects (`claude-opus-5-5`) to the gateway id, which
+* stays the id sent to the gateway.
+*/
+function createGatewayModelOverrides(model) {
+	if (!model?.startsWith("anthropic/")) return void 0;
+	const id = model.slice(10).replace(/\[[^\]]*\]$/, "");
+	return id.includes(".") ? { [id.replace(/\./g, "-")]: model } : void 0;
+}
+function needsHostApproval(input) {
+	if (input.toolName.startsWith("mcp__harness-tools__")) return false;
+	return input.inactiveNativeTools.has(input.toolName) || nativeToolRequiresApproval({
+		nativeName: input.toolName,
+		permissionMode: input.permissionMode
+	});
+}
+function createApprovalPreToolUseHook(input) {
+	return async (hookInput, toolUseID) => {
+		const toolName = hookInput.tool_name;
+		if (toolUseID == null || typeof toolName !== "string" || toolName === "AskUserQuestion") return {};
+		const decision = input.decisions.get(toolUseID);
+		if (decision != null) {
+			input.nativeToolCallNames.set(toolUseID, toolName);
+			if (!decision.approved) input.decisions.delete(toolUseID);
+			return { hookSpecificOutput: {
+				hookEventName: "PreToolUse",
+				...decision.approved ? { permissionDecision: "allow" } : {
+					permissionDecision: "deny",
+					permissionDecisionReason: decision.reason ?? "Denied"
+				}
+			} };
+		}
+		if (!needsHostApproval({
+			toolName,
+			permissionMode: input.permissionMode,
+			inactiveNativeTools: input.inactiveNativeTools
+		})) return {};
+		input.deferredToolUseIds.add(toolUseID);
+		return { hookSpecificOutput: {
+			hookEventName: "PreToolUse",
+			permissionDecision: "defer"
+		} };
+	};
+}
 function nativeToolRequiresApproval(input) {
 	if (input.permissionMode === "allow-all") return false;
 	const kind = NATIVE_TOOL_KINDS[input.nativeName] ?? "edit";
@@ -1606,70 +1674,75 @@ async function runTurn(start, turn) {
 			name: "harness-tools",
 			version: "1.0.0"
 		});
-		for (const tool of start.tools) server.registerTool(tool.name, {
-			description: tool.description ?? "",
-			inputSchema: jsonSchemaToZodObject(tool.inputSchema)
-		}, async (...handlerArgs) => {
-			const [input, extra] = handlerArgs;
-			const metadataToolCallId = extra._meta?.["claudecode/toolUseId"];
-			const toolCallId = resolveMcpHandlerToolUseId({
-				state: streamEventState,
-				metadataToolUseId: typeof metadataToolCallId === "string" ? metadataToolCallId : void 0,
-				toolName: tool.name,
-				input
-			}) ?? randomUUID();
-			streamEventState.mcpHandlerCalls.set(toolCallId, {
-				toolName: tool.name,
-				input
-			});
-			if (!streamEventState.emittedToolCallIds.has(toolCallId)) {
-				streamEventState.emittedToolCallIds.add(toolCallId);
-				emit({
-					type: "tool-call",
-					toolCallId,
+		for (const tool of start.tools) {
+			const hints = start.toolHints?.[tool.name];
+			server.registerTool(tool.name, {
+				description: tool.description ?? "",
+				inputSchema: jsonSchemaToZodObject(tool.inputSchema),
+				...hints?.readOnly == null ? {} : { annotations: { readOnlyHint: hints.readOnly } },
+				...hints?.alwaysLoad == null ? {} : { _meta: { "anthropic/alwaysLoad": hints.alwaysLoad } }
+			}, async (...handlerArgs) => {
+				const [input, extra] = handlerArgs;
+				const metadataToolCallId = extra._meta?.["claudecode/toolUseId"];
+				const toolCallId = resolveMcpHandlerToolUseId({
+					state: streamEventState,
+					metadataToolUseId: typeof metadataToolCallId === "string" ? metadataToolCallId : void 0,
+					toolName: tool.name,
+					input
+				}) ?? randomUUID();
+				streamEventState.mcpHandlerCalls.set(toolCallId, {
 					toolName: tool.name,
-					input: JSON.stringify(input),
-					providerExecuted: false
+					input
 				});
-				markWaitingOnHostInput({
-					state: streamEventState,
-					emit,
-					toolUseId: toolCallId
+				if (!streamEventState.emittedToolCallIds.has(toolCallId)) {
+					streamEventState.emittedToolCallIds.add(toolCallId);
+					emit({
+						type: "tool-call",
+						toolCallId,
+						toolName: tool.name,
+						input: JSON.stringify(input),
+						providerExecuted: false
+					});
+					markWaitingOnHostInput({
+						state: streamEventState,
+						emit,
+						toolUseId: toolCallId
+					});
+				}
+				const { output, isError, toolResult } = await turn.requestToolResult(toolCallId).finally(() => {
+					clearWaitingOnHostInput({
+						state: streamEventState,
+						toolUseId: toolCallId
+					});
+					if (!streamEventState.mcpToolCalls.has(toolCallId)) streamEventState.pendingStepToolUseIds.delete(toolCallId);
 				});
-			}
-			const { output, isError, toolResult } = await turn.requestToolResult(toolCallId).finally(() => {
-				clearWaitingOnHostInput({
-					state: streamEventState,
-					toolUseId: toolCallId
+				emit({
+					type: "tool-result",
+					toolCallId,
+					toolName: tool.name,
+					result: output ?? null,
+					isError: !!isError
 				});
-				if (!streamEventState.mcpToolCalls.has(toolCallId)) streamEventState.pendingStepToolUseIds.delete(toolCallId);
-			});
-			emit({
-				type: "tool-result",
-				toolCallId,
-				toolName: tool.name,
-				result: output ?? null,
-				isError: !!isError
-			});
-			if (toolResult != null) {
-				const converted = convertHarnessToolModelOutput({ output: toolResult.output });
+				if (toolResult != null) {
+					const converted = convertHarnessToolModelOutput({ output: toolResult.output });
+					return {
+						content: converted.content.map((part) => part.type === "text" ? part : {
+							type: "image",
+							data: part.data,
+							mimeType: part.mediaType
+						}),
+						isError: isError === true || converted.isError
+					};
+				}
 				return {
-					content: converted.content.map((part) => part.type === "text" ? part : {
-						type: "image",
-						data: part.data,
-						mimeType: part.mediaType
-					}),
-					isError: isError === true || converted.isError
+					content: [{
+						type: "text",
+						text: JSON.stringify(output ?? null)
+					}],
+					isError
 				};
-			}
-			return {
-				content: [{
-					type: "text",
-					text: JSON.stringify(output ?? null)
-				}],
-				isError
-			};
-		});
+			});
+		}
 		mcpServers["harness-tools"] = {
 			type: "sdk",
 			name: "harness-tools",
@@ -1693,7 +1766,10 @@ async function runTurn(start, turn) {
 	const skillsOption = toClaudeSkillsOption(start.skills);
 	const nativeTools = resolveNativeTools(start.builtinToolFiltering);
 	const inactiveNativeTools = resolveInactiveNativeTools(start.builtinToolFiltering);
+	const permissionMode = start.permissionMode ?? "allow-all";
+	const approvalDecisions = /* @__PURE__ */ new Map();
 	const permissionOptions = createPermissionOptions({
+		approvalDecisions,
 		start,
 		inactiveNativeTools,
 		turn,
@@ -1711,6 +1787,15 @@ async function runTurn(start, turn) {
 		approvalRequestedToolUseIds: streamEventState.approvalRequestedToolUseIds,
 		emittedToolCallIds: streamEventState.emittedToolCallIds
 	});
+	const modelOverrides = createGatewayModelOverrides(start.model);
+	const deferredToolUseIds = /* @__PURE__ */ new Set();
+	const approvalPreToolUseHook = createApprovalPreToolUseHook({
+		permissionMode,
+		inactiveNativeTools: new Set(inactiveNativeTools),
+		decisions: approvalDecisions,
+		deferredToolUseIds,
+		nativeToolCallNames: streamEventState.nativeToolCallNames
+	});
 	const questionPreToolUseHook = createQuestionPreToolUseHook({
 		turn,
 		emit,
@@ -1725,7 +1810,7 @@ async function runTurn(start, turn) {
 			toolUseId
 		})
 	});
-	const q = claudeSdk.query({
+	const queryArgs = {
 		prompt: queryInput.input,
 		options: {
 			...start.model ? { model: start.model } : {},
@@ -1750,7 +1835,7 @@ async function runTurn(start, turn) {
 			} } : {},
 			includePartialMessages: true,
 			hooks: {
-				PreToolUse: [{
+				PreToolUse: [...permissionMode === "allow-all" ? [] : [{ hooks: [approvalPreToolUseHook] }], {
 					matcher: "AskUserQuestion",
 					hooks: [questionPreToolUseHook],
 					...start.questionTimeoutMs !== void 0 ? { timeout: Math.ceil(start.questionTimeoutMs / 1e3) } : {}
@@ -1762,18 +1847,70 @@ async function runTurn(start, turn) {
 			},
 			...start.resumeSessionId ?? lastClaudeSessionId ? { resume: start.resumeSessionId ?? lastClaudeSessionId } : start.continue === true || !turn.firstTurn ? { continue: true } : {},
 			...permissionOptions,
+			...modelOverrides ? { settings: {
+				...permissionOptions.settings,
+				modelOverrides
+			} } : {},
 			mcpServers,
 			cwd: workdir,
 			abortSignal: abortCtl.signal
 		}
+	};
+	let deferredToolUseId = start.deferredToolUseId;
+	let resumingDeferredCall = false;
+	let q = deferredToolUseId == null ? claudeSdk.query(queryArgs) : void 0;
+	const hostAborted = new Promise((resolve) => {
+		if (abortCtl.signal.aborted) resolve(void 0);
+		abortCtl.signal.addEventListener("abort", () => resolve(void 0), { once: true });
 	});
 	gracefulAbort = () => {
 		hardAbortTimer = setTimeout(() => abortCtl.abort(), 5e3);
 		hardAbortTimer.unref?.();
-		Promise.resolve().then(() => q.interrupt()).catch(() => abortCtl.abort());
+		Promise.resolve().then(() => q?.interrupt()).catch(() => abortCtl.abort());
 	};
 	let turnUsage;
 	let totalCostUsd;
+	let deferredDecision;
+	const requestDeferredApproval = (call) => {
+		for (const droppedToolUseId of deferredToolUseIds) {
+			if (droppedToolUseId === call.toolUseId) continue;
+			const nativeName = streamEventState.nativeToolCallNames.get(droppedToolUseId) ?? "unknown";
+			emit({
+				type: "tool-result",
+				toolCallId: droppedToolUseId,
+				toolName: toCommonName(nativeName),
+				result: "Claude Code can wait for only one approval at a time, so this call did not run.",
+				isError: true
+			});
+			streamEventState.pendingStepToolUseIds.delete(droppedToolUseId);
+		}
+		deferredToolUseIds.clear();
+		streamEventState.approvalRequestedToolUseIds.add(call.toolUseId);
+		streamEventState.nativeToolCallNames.set(call.toolUseId, call.toolName);
+		if (!streamEventState.emittedToolCallIds.has(call.toolUseId)) {
+			streamEventState.emittedToolCallIds.add(call.toolUseId);
+			emit({
+				type: "tool-call",
+				toolCallId: call.toolUseId,
+				toolName: toCommonName(call.toolName),
+				nativeName: call.toolName,
+				input: JSON.stringify(call.toolInput ?? {}),
+				providerExecuted: true,
+				...isExternalMcpTool(call.toolName) ? { dynamic: true } : {}
+			});
+		}
+		deferredDecision = turn.requestToolApproval(call.toolUseId);
+		emit({
+			type: "tool-approval-request",
+			approvalId: call.toolUseId,
+			toolCallId: call.toolUseId
+		});
+		markWaitingOnHostInput({
+			state: streamEventState,
+			emit,
+			toolUseId: call.toolUseId
+		});
+	};
 	let emittedTerminalError = false;
 	let emittedTerminalFinish = false;
 	const emitTerminalError = (message) => {
@@ -1796,14 +1933,59 @@ async function runTurn(start, turn) {
 		onCompactionBoundary: (boundary) => compaction.onBoundary(boundary),
 		toCommonName
 	});
+	async function* messages() {
+		for (;;) {
+			if (deferredToolUseId != null) {
+				const toolUseId = deferredToolUseId;
+				const decision = await Promise.race([deferredDecision ?? turn.requestToolApproval(toolUseId), hostAborted]).finally(() => clearWaitingOnHostInput({
+					state: streamEventState,
+					toolUseId
+				}));
+				deferredDecision = void 0;
+				if (decision == null || abortCtl.signal.aborted) return;
+				approvalDecisions.set(toolUseId, decision);
+				deferredToolUseId = void 0;
+				resumingDeferredCall = true;
+				q = claudeSdk.query({
+					prompt: withoutInitialMessage(queryInput.input),
+					options: {
+						...queryArgs.options,
+						...lastClaudeSessionId != null ? {
+							continue: void 0,
+							resume: lastClaudeSessionId
+						} : {}
+					}
+				});
+			}
+			for await (const msg of q) {
+				yield msg;
+				if (deferredToolUseId != null) break;
+			}
+			if (deferredToolUseId == null || abortCtl.signal.aborted) return;
+			queryInput.retire();
+			await disposeQuery(q);
+		}
+	}
 	try {
-		for await (const msg of q) {
+		for await (const msg of messages()) {
 			if (abortCtl.signal.aborted) break;
 			const type = msg.type;
 			if (type === "command_lifecycle") queryInput.handleLifecycle(msg);
 			const sessionId = msg.session_id;
 			if (typeof sessionId === "string" && sessionId.length > 0) lastClaudeSessionId = sessionId;
 			emitStreamEvent(msg);
+			if (type === "result" && msg.terminal_reason === "tool_deferred" && msg.deferred_tool_use?.id != null) {
+				const harnessUsage = mapUsage(msg.usage ?? msg.message?.usage);
+				if (harnessUsage) turnUsage = addUsage(turnUsage, harnessUsage);
+				if (typeof msg.total_cost_usd === "number") totalCostUsd = msg.total_cost_usd;
+				deferredToolUseId = msg.deferred_tool_use.id;
+				requestDeferredApproval({
+					toolUseId: msg.deferred_tool_use.id,
+					toolName: msg.deferred_tool_use.name,
+					toolInput: msg.deferred_tool_use.input
+				});
+				continue;
+			}
 			if (type === "result") {
 				if (msg.subtype === "success") {
 					if (msg.is_error) {
@@ -1839,7 +2021,7 @@ async function runTurn(start, turn) {
 						emit,
 						usage: streamEventState.pendingStepUsage ?? harnessUsage
 					});
-					if (!queryInput.answersSentMessage(msg)) continue;
+					if (!resumingDeferredCall && !queryInput.answersSentMessage(msg)) continue;
 					queryInput.observeResult();
 					if (!queryInput.hasActiveUserMessages()) {
 						queryInput.close();
@@ -1864,9 +2046,7 @@ async function runTurn(start, turn) {
 		if (hardAbortTimer != null) clearTimeout(hardAbortTimer);
 		turn.abortSignal.removeEventListener("abort", onHostAbort);
 		queryInput.close();
-		try {
-			await q.return?.(void 0);
-		} catch {}
+		await disposeQuery(q);
 	}
 	if (emittedTerminalError) return;
 	emittedTerminalFinish = true;
@@ -1923,6 +2103,24 @@ function createQueryInput({ initialUserMessage, userMessages, abortSignal }) {
 		...options.priority == null ? {} : { priority: options.priority }
 	});
 	const messageIterator = userMessages[Symbol.asyncIterator]();
+	let liveInputId = 0;
+	let bufferedMessage;
+	let pulling;
+	const takeMessage = async (inputId) => {
+		for (;;) {
+			if (inputId !== liveInputId) return void 0;
+			if (bufferedMessage != null) {
+				const message = bufferedMessage;
+				bufferedMessage = void 0;
+				return message;
+			}
+			pulling ??= messageIterator.next().then((result) => {
+				bufferedMessage = result;
+				pulling = void 0;
+			});
+			await pulling;
+		}
+	};
 	return {
 		close,
 		handleLifecycle: (message) => {
@@ -1947,10 +2145,14 @@ function createQueryInput({ initialUserMessage, userMessages, abortSignal }) {
 		observeResult: () => {
 			observedResult = true;
 		},
+		retire: () => {
+			liveInputId++;
+		},
 		get hasObservedResult() {
 			return observedResult;
 		},
 		input: { [Symbol.asyncIterator]() {
+			const inputId = ++liveInputId;
 			let sentInitial = false;
 			return { async next() {
 				if (closed || abortSignal.aborted) return {
@@ -1967,8 +2169,8 @@ function createQueryInput({ initialUserMessage, userMessages, abortSignal }) {
 						done: false
 					};
 				}
-				const nextMessage = await messageIterator.next();
-				if (nextMessage.done) return {
+				const nextMessage = await takeMessage(inputId);
+				if (nextMessage == null || nextMessage.done) return {
 					value: void 0,
 					done: true
 				};
@@ -1986,6 +2188,24 @@ function createQueryInput({ initialUserMessage, userMessages, abortSignal }) {
 		} }
 	};
 }
+function withoutInitialMessage(input) {
+	return { [Symbol.asyncIterator]() {
+		const iterator = input[Symbol.asyncIterator]();
+		let skipped = false;
+		return { async next() {
+			if (!skipped) {
+				skipped = true;
+				await iterator.next();
+			}
+			return iterator.next();
+		} };
+	} };
+}
+async function disposeQuery(query) {
+	try {
+		await query?.return?.(void 0);
+	} catch {}
+}
 function addUsage(total, usage) {
 	if (total == null) return usage;
 	const result = { ...total };