@ai-sdk/harness 1.0.149 → 1.0.151

package/dist/agent/index.js

@@ -1,7 +1,7 @@
 import { AISDKError, getErrorMessage } from "@ai-sdk/provider";
-import { DelayedPromise, asArray, asSchema, executeTool, generateId, isExecutableTool, normalizeHeaders, safeParseJSON, safeValidateTypes, validateTypes } from "@ai-sdk/provider-utils";
+import { DelayedPromise, asArray, asSchema, convertInlineFileDataToUint8Array, convertUint8ArrayToBase64, detectMediaType, executeTool, generateId, getTopLevelMediaType, isExecutableTool, isFullMediaType, normalizeHeaders, safeParseJSON, safeValidateTypes, validateTypes } from "@ai-sdk/provider-utils";
 import path, { posix } from "node:path";
-import { DefaultStepResult, addLanguageModelUsage, asLanguageModelUsage, createAsyncIterableStream, createNullLanguageModelUsage, createRestrictedTelemetryDispatcher, mergeCallbacks, parseToolCall, toResponseMessages, validateToolContext } from "ai/internal";
+import { DefaultStepResult, addLanguageModelUsage, asLanguageModelUsage, createAsyncIterableStream, createNullLanguageModelUsage, createRestrictedTelemetryDispatcher, createToolModelOutput, mergeCallbacks, parseToolCall, toResponseMessages, validateToolContext } from "ai/internal";
 import { NoSuchToolError, createUIMessageStreamResponse, toUIMessageStream } from "ai";
 import { appendFileSync, mkdirSync } from "node:fs";
 //#region src/errors/harness-error.ts
@@ -226,6 +226,9 @@ async function toHarnessStream(options) {
 * and throw a clear error.
 */
 var HarnessStreamTextResult = class {
+	setToolModelOutput(input) {
+		this.toolModelOutputs.set(input.toolCallId, input.output);
+	}
 	constructor(options) {
 		this._content = new DelayedPromise();
 		this._text = new DelayedPromise();
@@ -251,9 +254,12 @@ var HarnessStreamTextResult = class {
 		this._providerMetadata = new DelayedPromise();
 		this.stepsBuffer = [];
 		this.currentStepContent = [];
+		this.currentStepTextContent = /* @__PURE__ */ new Map();
+		this.currentStepReasoningContent = /* @__PURE__ */ new Map();
 		this.currentStepWarnings = [];
 		this.stepNumber = 0;
 		this.stepStarted = false;
+		this.toolModelOutputs = /* @__PURE__ */ new Map();
 		this.accumulatedUsage = createNullLanguageModelUsage();
 		this.finalProviderMetadata = void 0;
 		this.finalFinishReason = "other";
@@ -319,6 +325,8 @@ var HarnessStreamTextResult = class {
 	*/
 	discardCurrentStepContent() {
 		this.currentStepContent = [];
+		this.currentStepTextContent.clear();
+		this.currentStepReasoningContent.clear();
 		this.currentStepWarnings = [];
 		this.stepStarted = false;
 	}
@@ -372,6 +380,8 @@ var HarnessStreamTextResult = class {
 		if (this.currentStepWarnings.length > 0) this.aggregateWarnings.push(...this.currentStepWarnings);
 		this.stepNumber += 1;
 		this.currentStepContent = [];
+		this.currentStepTextContent.clear();
+		this.currentStepReasoningContent.clear();
 		this.currentStepWarnings = [];
 		this.stepStarted = false;
 		return step;
@@ -426,8 +436,8 @@ var HarnessStreamTextResult = class {
 		const aggregatedContent = this.stepsBuffer.flatMap((s) => s.content);
 		this._content.resolve(aggregatedContent);
 		this._text.resolve(finalStep.text);
-		this._reasoning.resolve([]);
-		this._reasoningText.resolve(void 0);
+		this._reasoning.resolve(finalStep.content.filter((part) => part.type === "reasoning" || part.type === "reasoning-file"));
+		this._reasoningText.resolve(finalStep.reasoningText);
 		this._files.resolve(this.stepsBuffer.flatMap((s) => s.files));
 		this._sources.resolve(this.stepsBuffer.flatMap((s) => s.sources));
 		this._toolCalls.resolve(this.stepsBuffer.flatMap((s) => s.toolCalls));
@@ -445,10 +455,20 @@ var HarnessStreamTextResult = class {
 		this._request.resolve(finalStep.request);
 		this._response.resolve(finalStep.response);
 		this._providerMetadata.resolve(this.finalProviderMetadata);
-		const responseMessages = await toResponseMessages({
-			content: aggregatedContent,
-			tools: this.tools
-		});
+		const responseTools = {};
+		for (const [name, tool] of Object.entries(this.tools)) responseTools[name] = {
+			...tool,
+			toModelOutput: (options) => this.toolModelOutputs.get(options.toolCallId) ?? createToolModelOutput({
+				...options,
+				tool,
+				errorMode: "none"
+			})
+		};
+		const responseMessages = [];
+		for (const step of this.stepsBuffer) responseMessages.push(...await toResponseMessages({
+			content: step.content,
+			tools: responseTools
+		}));
 		this._responseMessages.resolve(responseMessages);
 		this.fullStreamController.enqueue({
 			type: "finish",
@@ -640,12 +660,14 @@ var HarnessStreamTextResult = class {
 			reader.releaseLock();
 		}
 	}
-	toUIMessageStream({ originalMessages, generateMessageId, onEnd, onFinish, messageMetadata, sendReasoning, sendSources, sendStart, sendFinish, onError } = {}) {
+	toUIMessageStream({ originalMessages, generateMessageId, onStepEnd, onStepFinish, onEnd, onFinish, messageMetadata, sendReasoning, sendSources, sendStart, sendFinish, onError } = {}) {
 		return createAsyncIterableStream(toUIMessageStream({
 			stream: this.stream,
 			tools: this.tools,
 			originalMessages,
 			generateMessageId,
+			onStepEnd,
+			onStepFinish,
 			onEnd,
 			onFinish,
 			messageMetadata,
@@ -662,11 +684,13 @@ var HarnessStreamTextResult = class {
 	pipeTextStreamToResponse() {
 		throw notSupportedYet("pipeTextStreamToResponse");
 	}
-	toUIMessageStreamResponse({ originalMessages, generateMessageId, onEnd, onFinish, messageMetadata, sendReasoning, sendSources, sendStart, sendFinish, onError, ...init } = {}) {
+	toUIMessageStreamResponse({ originalMessages, generateMessageId, onStepEnd, onStepFinish, onEnd, onFinish, messageMetadata, sendReasoning, sendSources, sendStart, sendFinish, onError, ...init } = {}) {
 		return createUIMessageStreamResponse({
 			stream: this.toUIMessageStream({
 				originalMessages,
 				generateMessageId,
+				onStepEnd,
+				onStepFinish,
 				onEnd,
 				onFinish,
 				messageMetadata,
@@ -684,22 +708,71 @@ var HarnessStreamTextResult = class {
 	}
 	appendToCurrentStepContent(part) {
 		switch (part.type) {
-			case "text-delta": {
-				const last = this.currentStepContent[this.currentStepContent.length - 1];
-				if (last && last.type === "text") last.text += part.text;
-				else this.currentStepContent.push({
+			case "text-start": {
+				const content = {
 					type: "text",
-					text: part.text
-				});
+					text: "",
+					...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+				};
+				this.currentStepTextContent.set(part.id, content);
+				this.currentStepContent.push(content);
 				return;
 			}
-			case "reasoning-delta": {
-				const last = this.currentStepContent[this.currentStepContent.length - 1];
-				if (last && last.type === "reasoning") last.text += part.text;
-				else this.currentStepContent.push({
+			case "text-delta": {
+				let content = this.currentStepTextContent.get(part.id);
+				if (content == null) {
+					content = {
+						type: "text",
+						text: "",
+						...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+					};
+					this.currentStepTextContent.set(part.id, content);
+					this.currentStepContent.push(content);
+				}
+				content.text += part.text;
+				if (part.providerMetadata != null) content.providerMetadata = part.providerMetadata;
+				return;
+			}
+			case "text-end": {
+				const content = this.currentStepTextContent.get(part.id);
+				if (content != null) {
+					if (part.providerMetadata != null) content.providerMetadata = part.providerMetadata;
+					if (part.citations != null) content.citations = part.citations;
+					this.currentStepTextContent.delete(part.id);
+				}
+				return;
+			}
+			case "reasoning-start": {
+				const content = {
 					type: "reasoning",
-					text: part.text
-				});
+					text: "",
+					...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+				};
+				this.currentStepReasoningContent.set(part.id, content);
+				this.currentStepContent.push(content);
+				return;
+			}
+			case "reasoning-delta": {
+				let content = this.currentStepReasoningContent.get(part.id);
+				if (content == null) {
+					content = {
+						type: "reasoning",
+						text: "",
+						...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {}
+					};
+					this.currentStepReasoningContent.set(part.id, content);
+					this.currentStepContent.push(content);
+				}
+				content.text += part.text;
+				if (part.providerMetadata != null) content.providerMetadata = part.providerMetadata;
+				return;
+			}
+			case "reasoning-end": {
+				const content = this.currentStepReasoningContent.get(part.id);
+				if (content != null) {
+					if (part.providerMetadata != null) content.providerMetadata = part.providerMetadata;
+					this.currentStepReasoningContent.delete(part.id);
+				}
 				return;
 			}
 			case "tool-call":
@@ -869,11 +942,12 @@ function translateStreamPart(event, options = {}) {
 		case "tool-call": return [];
 		case "tool-approval-request": return [];
 		case "tool-result":
-			if (event.isError === true && (options.isProviderExecuted?.(event.toolCallId) ?? true)) return [{
+			const toolCall = options.getToolCall?.(event.toolCallId);
+			if (event.isError === true && (toolCall?.providerExecuted ?? options.isProviderExecuted?.(event.toolCallId) ?? true)) return [{
 				type: "tool-error",
 				toolCallId: event.toolCallId,
 				toolName: event.toolName,
-				input: void 0,
+				input: toolCall?.input,
 				error: event.result,
 				providerExecuted: true,
 				...event.dynamic !== void 0 ? { dynamic: event.dynamic } : {},
@@ -883,8 +957,9 @@ function translateStreamPart(event, options = {}) {
 				type: "tool-result",
 				toolCallId: event.toolCallId,
 				toolName: event.toolName,
-				input: void 0,
+				input: toolCall?.input,
 				output: event.result,
+				...toolCall?.providerExecuted !== void 0 ? { providerExecuted: toolCall.providerExecuted } : {},
 				...event.preliminary !== void 0 ? { preliminary: event.preliminary } : {},
 				...event.dynamic !== void 0 ? { dynamic: event.dynamic } : {},
 				...event.providerMetadata !== void 0 ? { providerMetadata: event.providerMetadata } : {}
@@ -1438,6 +1513,46 @@ function pinSandboxChannelEventCheckpoint(event) {
 	return event[sandboxChannelEventCheckpointSymbol]?.pin();
 }
 //#endregion
+//#region src/utils/normalize-harness-tool-model-output.ts
+function normalizeHarnessToolModelOutput({ output }) {
+	try {
+		return output.type !== "content" ? output : {
+			...output,
+			value: output.value.map((part) => {
+				if (part.type === "text") return part;
+				const file = part.type === "image-data" || part.type === "file-data" ? {
+					...part,
+					type: "file",
+					data: {
+						type: "data",
+						data: part.data
+					}
+				} : part;
+				if (file.type !== "file" || file.data.type !== "data" || getTopLevelMediaType(file.mediaType) !== "image") throw new Error(`Unsupported content '${part.type}'${file.type === "file" ? ` (${file.mediaType}, ${file.data.type})` : ""}.`);
+				const data = typeof file.data.data === "string" ? file.data.data : convertUint8ArrayToBase64(convertInlineFileDataToUint8Array(file.data));
+				const mediaType = isFullMediaType(file.mediaType) ? file.mediaType : detectMediaType({
+					data,
+					topLevelType: "image"
+				});
+				if (mediaType == null) throw new Error("Cannot detect the inline image media type.");
+				return {
+					...file,
+					mediaType,
+					data: {
+						type: "data",
+						data
+					}
+				};
+			})
+		};
+	} catch (cause) {
+		throw new HarnessCapabilityUnsupportedError({
+			message: `Harnesses support only text and inline images in tool model output. ${cause instanceof Error ? cause.message : String(cause)}`,
+			cause
+		});
+	}
+}
+//#endregion
 //#region src/agent/internal/run-prompt.ts
 const invalidToolInputMessage = "Tool input validation failed.";
 function unwrapToolResultOutput(toolResult) {
@@ -1565,10 +1680,13 @@ function runPrompt(input) {
 		const stripToolInputWorkDir = createToolInputWorkDirStripper({ sessionWorkDir: input.sessionWorkDir });
 		const toolCallsByToolCallId = /* @__PURE__ */ new Map();
 		const rawToolCallsByToolCallId = /* @__PURE__ */ new Map();
-		const translateOptions = { isProviderExecuted: (toolCallId) => {
-			const rawToolCall = rawToolCallsByToolCallId.get(toolCallId);
-			return rawToolCall == null || rawToolCall.providerExecuted === true;
-		} };
+		const translateOptions = {
+			getToolCall: (toolCallId) => toolCallsByToolCallId.get(toolCallId),
+			isProviderExecuted: (toolCallId) => {
+				const rawToolCall = rawToolCallsByToolCallId.get(toolCallId);
+				return rawToolCall == null || rawToolCall.providerExecuted === true;
+			}
+		};
 		const pendingApprovalsByApprovalId = new Map(pendingToolApprovals.map((approval) => [approval.approvalId, approval]));
 		const pendingApprovalsByToolCallId = new Map(pendingToolApprovals.map((approval) => [approval.toolCallId, approval]));
 		const continuationsByApprovalId = new Map((input.toolApprovalContinuations ?? []).map((continuation) => [continuation.approvalId, continuation]));
@@ -1622,9 +1740,10 @@ function runPrompt(input) {
 			toolExecutions.clear();
 			bufferedToolOutcomes = [];
 		};
-		let expectedStepToolCallCount;
-		let observedStepToolCallCount = 0;
-		let pauseAfterStepToolCalls = false;
+		let hostInputPauseRequested = false;
+		let deferredPauseFinishStep;
+		let ignoredFinishStep;
+		const hostToolCallIdsAwaitingEcho = /* @__PURE__ */ new Set();
 		const buildModelCallContent = () => {
 			const parts = [];
 			if (stepText) parts.push({
@@ -1648,9 +1767,7 @@ function runPrompt(input) {
 			stepApprovalRequests = [];
 			bufferedToolOutcomes = [];
 			toolExecutions.clear();
-			expectedStepToolCallCount = void 0;
-			observedStepToolCallCount = 0;
-			pauseAfterStepToolCalls = false;
+			ignoredFinishStep = void 0;
 		};
 		const zeroUsage = {
 			inputTokens: {
@@ -1687,20 +1804,25 @@ function runPrompt(input) {
 			resetStepContent();
 			return step;
 		};
-		const finishForHostInputPause = async (options) => {
+		const finishForHostInputPause = async () => {
 			await waitForOutstandingHostToolExecutions();
-			if (options.completeCurrentStep) await completeStep({
-				finishReason: toolCallsFinishReason,
-				usage: zeroUsage,
-				providerMetadata: void 0
-			});
-			else await publishToolExecutions();
+			await publishToolExecutions();
 			await lifecycle.end({
 				steps: completedSteps,
 				usage: asLanguageModelUsage(zeroUsage)
 			});
 			await result.finish();
 		};
+		const pauseForHostInput = async (finishStep) => {
+			await waitForOutstandingHostToolExecutions();
+			closingResumedStep = false;
+			await completeStep({
+				finishReason: toolCallsFinishReason,
+				usage: finishStep?.usage ?? zeroUsage,
+				providerMetadata: finishStep?.harnessMetadata
+			});
+			await finishForHostInputPause();
+		};
 		const enqueueApprovalRequest = (approval) => {
 			const part = {
 				type: "tool-approval-request",
@@ -1768,7 +1890,33 @@ function runPrompt(input) {
 			});
 		};
 		const submitToolResult = async (submission) => {
-			if (!input.isTurnSuspending?.()) return control.submitToolResult(submission);
+			if (submission.toolResult != null) {
+				let output;
+				try {
+					output = normalizeHarnessToolModelOutput({ output: submission.toolResult.output });
+				} catch (error) {
+					if (!continuationsByToolCallId.has(submission.toolCallId) || !HarnessCapabilityUnsupportedError.isInstance(error)) throw error;
+					output = {
+						type: "text",
+						value: JSON.stringify(submission.output) ?? "null"
+					};
+				}
+				submission = {
+					...submission,
+					toolResult: {
+						...submission.toolResult,
+						output
+					}
+				};
+				result.setToolModelOutput({
+					toolCallId: submission.toolCallId,
+					output
+				});
+			}
+			if (!input.isTurnSuspending?.()) {
+				if (!settledHostToolCallIds.has(submission.toolCallId)) hostToolCallIdsAwaitingEcho.add(submission.toolCallId);
+				return control.submitToolResult(submission);
+			}
 			const toolCall = rawToolCallsByToolCallId.get(submission.toolCallId) ?? pendingResultsByToolCallId.get(submission.toolCallId) ?? pendingToolApprovals.find((approval) => approval.toolCallId === submission.toolCallId);
 			if (toolCall == null) throw new Error(`Unknown suspended tool call '${submission.toolCallId}'.`);
 			const { toolCallId, ...completedResult } = submission;
@@ -1915,7 +2063,7 @@ function runPrompt(input) {
 			});
 			if (!execution.executed) {
 				recordPendingToolResult({ toolCall: rawToolCall });
-				await finishForHostInputPause({ completeCurrentStep: false });
+				await finishForHostInputPause();
 				return "awaiting-tool-result";
 			}
 			const toolExecution = toolExecutions.get(rawToolCall.toolCallId);
@@ -1947,8 +2095,8 @@ function runPrompt(input) {
 				}
 			}
 			while (true) {
-				if (pauseAfterStepToolCalls && expectedStepToolCallCount != null && observedStepToolCallCount >= expectedStepToolCallCount) {
-					await finishForHostInputPause({ completeCurrentStep: true });
+				if (deferredPauseFinishStep != null && hostToolCallIdsAwaitingEcho.size === 0) {
+					await pauseForHostInput(deferredPauseFinishStep);
 					return;
 				}
 				const { value, done } = await reader.read();
@@ -1961,6 +2109,7 @@ function runPrompt(input) {
 					result.enqueueRaw(value.rawValue);
 					continue;
 				}
+				if (value.type === "tool-result") hostToolCallIdsAwaitingEcho.delete(value.toolCallId);
 				if (pendingStopBoundary != null) {
 					if (value.type === "finish") releasePendingStopBoundary();
 					else if ((await Promise.all(input.stopConditions.map((condition) => condition({ steps: completedSteps })))).some(Boolean)) {
@@ -1990,6 +2139,43 @@ function runPrompt(input) {
 				const settledHostInputReplay = (displayValue.type === "tool-call" || displayValue.type === "tool-result" || displayValue.type === "tool-approval-request") && settledHostToolCallIds.has(displayValue.toolCallId);
 				const settledBuiltinApprovalReplay = (displayValue.type === "tool-call" || displayValue.type === "tool-approval-request") && settledBuiltinApprovalToolCallIds.has(displayValue.toolCallId);
 				if (settledHostInputReplay || settledBuiltinApprovalReplay) continue;
+				if (value.type === "finish-step") {
+					if (hostInputPauseRequested) {
+						await waitForOutstandingHostToolExecutions();
+						if (hostToolCallIdsAwaitingEcho.size === 0) {
+							await pauseForHostInput(value);
+							return;
+						}
+						deferredPauseFinishStep = value;
+						continue;
+					}
+					if (hostToolCallIdsAwaitingEcho.size > 0) {
+						ignoredFinishStep = value;
+						continue;
+					}
+					ignoredFinishStep = void 0;
+				}
+				if (value.type === "finish") {
+					if (hostInputPauseRequested) {
+						await pauseForHostInput(deferredPauseFinishStep);
+						return;
+					}
+					if (ignoredFinishStep != null) {
+						const finishStep = ignoredFinishStep;
+						ignoredFinishStep = void 0;
+						await waitForOutstandingHostToolExecutions();
+						if (closingResumedStep) {
+							closingResumedStep = false;
+							await publishToolExecutions();
+							resetStepContent();
+							result.discardCurrentStepContent();
+						} else await completeStep({
+							finishReason: finishStep.finishReason,
+							usage: finishStep.usage,
+							providerMetadata: finishStep.harnessMetadata
+						});
+					}
+				}
 				if (displayValue.type === "finish-step" && closingResumedStep) {
 					closingResumedStep = false;
 					await publishToolExecutions();
@@ -2006,6 +2192,7 @@ function runPrompt(input) {
 						toolFiltering: input.builtinToolFiltering
 					})) {
 						if (control.submitToolApproval == null) throw new Error(`Harness '${input.harness.harnessId}' emitted a built-in tool approval request but does not support approval responses.`);
+						hostToolCallIdsAwaitingEcho.add(displayValue.toolCallId);
 						await control.submitToolApproval({
 							approvalId: displayValue.approvalId,
 							approved: false,
@@ -2063,8 +2250,6 @@ function runPrompt(input) {
 				if (value.type === "text-delta") stepText += value.delta;
 				else if (value.type === "reasoning-delta") stepReasoning += value.delta;
 				if (value.type === "tool-call") {
-					observedStepToolCallCount += 1;
-					expectedStepToolCallCount ??= value.stepToolCallCount;
 					const toolCall = toolCallsByToolCallId.get(value.toolCallId);
 					if (toolCall != null) {
 						stepToolCalls.push(toolCall);
@@ -2115,8 +2300,8 @@ function runPrompt(input) {
 						approvalId: pendingApproval.approvalId,
 						toolCall
 					});
-					await finishForHostInputPause({ completeCurrentStep: true });
-					return;
+					hostInputPauseRequested = true;
+					continue;
 				}
 				if (value.type === "finish-step") {
 					await waitForOutstandingHostToolExecutions();
@@ -2167,12 +2352,8 @@ function runPrompt(input) {
 					}
 					if (isClientExecutedBuiltin) {
 						recordPendingToolResult({ toolCall });
-						if (expectedStepToolCallCount != null && observedStepToolCallCount < expectedStepToolCallCount) {
-							pauseAfterStepToolCalls = true;
-							continue;
-						}
-						await finishForHostInputPause({ completeCurrentStep: true });
-						return;
+						hostInputPauseRequested = true;
+						continue;
 					}
 					if (validatedHostToolCall == null) throw new Error(`Harness '${input.harness.harnessId}' could not validate host tool '${toolCall.toolName}'.`);
 					if (validatedHostToolCall.invalid) {
@@ -2260,22 +2441,15 @@ function runPrompt(input) {
 							approvalId: pendingApproval.approvalId,
 							toolCall: pendingParsedToolCall
 						});
-						if (expectedStepToolCallCount != null && observedStepToolCallCount < expectedStepToolCallCount) {
-							pauseAfterStepToolCalls = true;
-							continue;
-						}
-						await finishForHostInputPause({ completeCurrentStep: true });
-						return;
+						hostInputPauseRequested = true;
+						continue;
 					}
 					if (!isExecutableTool(activeTools[toolCall.toolName])) {
 						recordPendingToolResult({ toolCall });
-						if (expectedStepToolCallCount != null && observedStepToolCallCount < expectedStepToolCallCount) {
-							pauseAfterStepToolCalls = true;
-							continue;
-						}
-						await finishForHostInputPause({ completeCurrentStep: true });
-						return;
+						hostInputPauseRequested = true;
+						continue;
 					}
+					hostToolCallIdsAwaitingEcho.add(toolCall.toolCallId);
 					startHostToolExecution((async () => {
 						const toolExecution = toolExecutions.get(toolCall.toolCallId);
 						if (toolExecution == null) throw new Error(`Harness '${input.harness.harnessId}' could not track host tool '${toolCall.toolName}'.`);
@@ -2318,6 +2492,10 @@ function runPrompt(input) {
 					})());
 				}
 			}
+			if (hostInputPauseRequested && input.isTurnSuspending?.() !== true) {
+				await pauseForHostInput(deferredPauseFinishStep);
+				return;
+			}
 			await waitForOutstandingHostToolExecutions();
 			if (input.isTurnSuspending?.() === true) {
 				await publishToolExecutions();
@@ -2442,7 +2620,19 @@ async function maybeExecuteHostTool(input) {
 		});
 		await input.submitToolResult({
 			toolCallId: input.event.toolCallId,
-			output
+			output,
+			...tool.toModelOutput == null ? {} : { toolResult: {
+				type: "tool-result",
+				toolCallId: input.event.toolCallId,
+				toolName: input.event.toolName,
+				output: await createToolModelOutput({
+					toolCallId: input.event.toolCallId,
+					input: input.parsedToolCall.input,
+					output,
+					tool,
+					errorMode: "none"
+				})
+			} }
 		});
 		return {
 			executed: true,
@@ -3034,6 +3224,9 @@ var HarnessAgentSession = class {
 * locally to find the original tool call before it can resume the paused turn.
 * Responses that already have a tool result are ignored, because those
 * approvals were already consumed by a prior continuation.
+* An `execution-denied` result is synthesized by `convertToModelMessages`
+* for a newly denied approval; it does not mean the harness has received
+* the decision, so that approval response must still continue the turn.
 */
 function collectHarnessAgentToolApprovalContinuations(input) {
 	const lastMessage = input.messages.at(-1);
@@ -3046,7 +3239,7 @@ function collectHarnessAgentToolApprovalContinuations(input) {
 		else if (part.type === "tool-approval-request") approvalRequestsByApprovalId.set(part.approvalId, part);
 	}
 	const toolResultIds = /* @__PURE__ */ new Set();
-	for (const part of lastMessage.content) if (part.type === "tool-result") toolResultIds.add(part.toolCallId);
+	for (const part of lastMessage.content) if (part.type === "tool-result" && part.output.type !== "execution-denied") toolResultIds.add(part.toolCallId);
 	const continuations = [];
 	for (const part of lastMessage.content) {
 		if (part.type !== "tool-approval-response") continue;