@better-agent/core 0.1.0-beta.1

package/dist/run/event-queue.mjs

@@ -0,0 +1,67 @@
+//#region src/run/event-queue.ts
+/** Creates an async event queue. */
+const createAsyncEventQueue = () => {
+	const values = [];
+	const waiters = [];
+	let closed = false;
+	let failure;
+	const settleNext = (result) => {
+		const waiter = waiters.shift();
+		if (waiter) {
+			waiter.resolve(result);
+			return true;
+		}
+		return false;
+	};
+	const rejectAll = (error) => {
+		for (const waiter of waiters.splice(0)) waiter.reject(error);
+	};
+	const closeAll = () => {
+		for (const waiter of waiters.splice(0)) waiter.resolve({
+			value: void 0,
+			done: true
+		});
+	};
+	return {
+		push(value) {
+			if (closed || failure !== void 0) return;
+			if (settleNext({
+				value,
+				done: false
+			})) return;
+			values.push(value);
+		},
+		close() {
+			if (closed || failure !== void 0) return;
+			closed = true;
+			closeAll();
+		},
+		fail(error) {
+			if (closed || failure !== void 0) return;
+			failure = error;
+			rejectAll(error);
+		},
+		async *iterate() {
+			while (true) {
+				if (values.length > 0) {
+					yield values.shift();
+					continue;
+				}
+				if (failure !== void 0) throw failure;
+				if (closed) return;
+				const next = await new Promise((resolve, reject) => {
+					waiters.push({
+						resolve,
+						reject
+					});
+				});
+				if (next.done) return;
+				yield next.value;
+			}
+		}
+	};
+};
+
+//#endregion
+export { createAsyncEventQueue };
+//# sourceMappingURL=event-queue.mjs.map

package/dist/run/event-queue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-queue.mjs","names":[],"sources":["../../src/run/event-queue.ts"],"sourcesContent":["/** Async queue for stream events. */\nexport interface AsyncEventQueue<T> {\n    push(value: T): void;\n    close(): void;\n    fail(error: unknown): void;\n    iterate(): AsyncGenerator<T>;\n}\n\n/** Creates an async event queue. */\nexport const createAsyncEventQueue = <T>(): AsyncEventQueue<T> => {\n    const values: T[] = [];\n    const waiters: {\n        resolve: (result: IteratorResult<T>) => void;\n        reject: (error: unknown) => void;\n    }[] = [];\n    let closed = false;\n    let failure: unknown;\n\n    const settleNext = (result: IteratorResult<T>) => {\n        const waiter = waiters.shift();\n        if (waiter) {\n            waiter.resolve(result);\n            return true;\n        }\n\n        return false;\n    };\n\n    const rejectAll = (error: unknown) => {\n        for (const waiter of waiters.splice(0)) {\n            waiter.reject(error);\n        }\n    };\n\n    const closeAll = () => {\n        for (const waiter of waiters.splice(0)) {\n            waiter.resolve({ value: undefined, done: true } as IteratorResult<T>);\n        }\n    };\n\n    return {\n        push(value) {\n            if (closed || failure !== undefined) return;\n            if (settleNext({ value, done: false })) return;\n            values.push(value);\n        },\n        close() {\n            if (closed || failure !== undefined) return;\n            closed = true;\n            closeAll();\n        },\n        fail(error) {\n            if (closed || failure !== undefined) return;\n            failure = error;\n            rejectAll(error);\n        },\n        async *iterate() {\n            while (true) {\n                if (values.length > 0) {\n                    // biome-ignore lint/style/noNonNullAssertion: queue length was checked above\n                    yield values.shift()!;\n                    continue;\n                }\n\n                if (failure !== undefined) {\n                    throw failure;\n                }\n\n                if (closed) {\n                    return;\n                }\n\n                const next = await new Promise<IteratorResult<T>>((resolve, reject) => {\n                    waiters.push({ resolve, reject });\n                });\n\n                if (next.done) {\n                    return;\n                }\n\n                yield next.value;\n            }\n        },\n    };\n};\n"],"mappings":";;AASA,MAAa,8BAAqD;CAC9D,MAAM,SAAc,EAAE;CACtB,MAAM,UAGA,EAAE;CACR,IAAI,SAAS;CACb,IAAI;CAEJ,MAAM,cAAc,WAA8B;EAC9C,MAAM,SAAS,QAAQ,OAAO;AAC9B,MAAI,QAAQ;AACR,UAAO,QAAQ,OAAO;AACtB,UAAO;;AAGX,SAAO;;CAGX,MAAM,aAAa,UAAmB;AAClC,OAAK,MAAM,UAAU,QAAQ,OAAO,EAAE,CAClC,QAAO,OAAO,MAAM;;CAI5B,MAAM,iBAAiB;AACnB,OAAK,MAAM,UAAU,QAAQ,OAAO,EAAE,CAClC,QAAO,QAAQ;GAAE,OAAO;GAAW,MAAM;GAAM,CAAsB;;AAI7E,QAAO;EACH,KAAK,OAAO;AACR,OAAI,UAAU,YAAY,OAAW;AACrC,OAAI,WAAW;IAAE;IAAO,MAAM;IAAO,CAAC,CAAE;AACxC,UAAO,KAAK,MAAM;;EAEtB,QAAQ;AACJ,OAAI,UAAU,YAAY,OAAW;AACrC,YAAS;AACT,aAAU;;EAEd,KAAK,OAAO;AACR,OAAI,UAAU,YAAY,OAAW;AACrC,aAAU;AACV,aAAU,MAAM;;EAEpB,OAAO,UAAU;AACb,UAAO,MAAM;AACT,QAAI,OAAO,SAAS,GAAG;AAEnB,WAAM,OAAO,OAAO;AACpB;;AAGJ,QAAI,YAAY,OACZ,OAAM;AAGV,QAAI,OACA;IAGJ,MAAM,OAAO,MAAM,IAAI,SAA4B,SAAS,WAAW;AACnE,aAAQ,KAAK;MAAE;MAAS;MAAQ,CAAC;MACnC;AAEF,QAAI,KAAK,KACL;AAGJ,UAAM,KAAK;;;EAGtB"}

package/dist/run/execute-tool-calls.mjs

@@ -0,0 +1,550 @@
+import { validateInput } from "../schema/resolve-json-schema.mjs";
+import { Events } from "../events/constants.mjs";
+import { BetterAgentError } from "@better-agent/shared/errors";
+import { logger } from "@better-agent/shared/logger";
+import { safeJsonParse } from "@better-agent/shared/utils";
+
+//#region src/run/execute-tool-calls.ts
+const MAX_TOOL_ERROR_REPAIR_DEPTH = 2;
+const MAX_TOOL_ERROR_RETRY_ATTEMPTS = 3;
+const getToolRunName = (tool) => tool.kind === "hosted" ? typeof tool.name === "string" && tool.name.length > 0 ? tool.name : typeof tool.type === "string" && tool.type.length > 0 ? tool.type : void 0 : typeof tool.name === "string" && tool.name.length > 0 ? tool.name : void 0;
+/** Executes the next batch of tool calls. */
+const executeToolCalls = async (params) => {
+	const results = [];
+	const throwIfAborted = () => {
+		if (params.signal.aborted) throw BetterAgentError.fromCode("ABORTED", "Tool execution was aborted.", { trace: [{ at: "core.run.executeToolCalls.aborted" }] });
+	};
+	const isAbortError = (error) => params.signal.aborted === true || error instanceof BetterAgentError && error.code === "ABORTED";
+	const waitForRetryBackoff = async (ms) => {
+		if (ms <= 0) {
+			throwIfAborted();
+			return;
+		}
+		await new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				params.signal.removeEventListener("abort", onAbort);
+				resolve();
+			}, ms);
+			const onAbort = () => {
+				clearTimeout(timer);
+				reject(BetterAgentError.fromCode("ABORTED", "Tool execution was aborted.", { trace: [{ at: "core.run.executeToolCalls.retryBackoff" }] }));
+			};
+			if (params.signal.aborted) {
+				onAbort();
+				return;
+			}
+			params.signal.addEventListener("abort", onAbort, { once: true });
+		});
+	};
+	const extractToolErrorMessage = (error, errorKind) => {
+		const rawMessage = error instanceof BetterAgentError || error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown tool error";
+		if (errorKind === "parse") return `Tool arguments could not be parsed as valid JSON. ${rawMessage}`.trim();
+		if (errorKind === "validation") return `Tool arguments failed schema validation. ${rawMessage}`.trim();
+		return rawMessage;
+	};
+	const createToolErrorOutcome = (args) => ({
+		result: {
+			type: "tool_error",
+			toolName: args.toolName,
+			errorKind: args.errorKind,
+			message: args.message,
+			retryable: args.retryable
+		},
+		isError: true,
+		errorKind: args.errorKind
+	});
+	const createToolErrorOutcomeFromError = (args) => createToolErrorOutcome({
+		toolName: args.toolName,
+		errorKind: args.errorKind,
+		message: args.message ?? extractToolErrorMessage(args.error, args.errorKind),
+		retryable: args.retryable ?? (args.error instanceof BetterAgentError ? args.error.retryable : void 0)
+	});
+	const emitToolCallStart = async (prepared) => {
+		await params.emit({
+			type: Events.TOOL_CALL_START,
+			runId: params.runId,
+			agentName: params.agentName,
+			parentMessageId: params.parentMessageId,
+			toolCallId: prepared.toolCall.callId,
+			toolCallName: prepared.toolCall.name,
+			toolTarget: prepared.toolTarget,
+			timestamp: Date.now()
+		});
+	};
+	const emitToolCallArgs = async (prepared) => {
+		await params.emit({
+			type: Events.TOOL_CALL_ARGS,
+			runId: params.runId,
+			agentName: params.agentName,
+			parentMessageId: params.parentMessageId,
+			toolCallId: prepared.toolCall.callId,
+			toolCallName: prepared.toolCall.name,
+			delta: prepared.toolCall.arguments,
+			toolTarget: prepared.toolTarget,
+			timestamp: Date.now()
+		});
+	};
+	const emitToolCallEnd = async (prepared) => {
+		await params.emit({
+			type: Events.TOOL_CALL_END,
+			runId: params.runId,
+			agentName: params.agentName,
+			parentMessageId: params.parentMessageId,
+			toolCallId: prepared.toolCall.callId,
+			toolCallName: prepared.toolCall.name,
+			toolTarget: prepared.toolTarget,
+			timestamp: Date.now()
+		});
+	};
+	const emitToolCallResult = async (prepared, outcome) => {
+		await params.emit({
+			type: Events.TOOL_CALL_RESULT,
+			runId: params.runId,
+			agentName: params.agentName,
+			parentMessageId: params.parentMessageId,
+			toolCallId: prepared.toolCall.callId,
+			toolCallName: prepared.toolCall.name,
+			result: outcome.result,
+			isError: outcome.isError,
+			errorKind: outcome.errorKind,
+			toolTarget: prepared.toolTarget,
+			timestamp: Date.now()
+		});
+	};
+	const resolveExecutableTool = (toolCall) => {
+		const tool = params.tools.find((candidate) => getToolRunName(candidate) === toolCall.name);
+		if (!tool) throw BetterAgentError.fromCode("VALIDATION_FAILED", `Tool '${toolCall.name}' was requested by the model but is not available for this run.`, {
+			context: {
+				runId: params.runId,
+				agentName: params.agentName,
+				toolName: toolCall.name
+			},
+			trace: [{ at: "core.run.executeToolCalls.missingTool" }]
+		});
+		if (tool.kind === "hosted") throw BetterAgentError.fromCode("NOT_IMPLEMENTED", `Hosted tool '${getToolRunName(tool) ?? toolCall.name}' reached the in-process tool executor, but hosted tools must be executed by the provider during model invocation.`, {
+			context: {
+				runId: params.runId,
+				agentName: params.agentName,
+				toolName: getToolRunName(tool) ?? toolCall.name,
+				toolTarget: tool.kind,
+				provider: tool.provider,
+				toolType: tool.type
+			},
+			trace: [{ at: "core.run.executeToolCalls.hostedToolInvariant" }]
+		});
+		return {
+			tool,
+			toolTarget: tool.kind === "client" ? "client" : "server"
+		};
+	};
+	const resolveApprovalConfig = async (args) => {
+		const approval = args.approval;
+		if (!approval) return;
+		let resolved = {
+			required: approval.required,
+			timeoutMs: approval.timeoutMs,
+			meta: approval.meta
+		};
+		if (approval.resolve) {
+			const runtimeResolved = await approval.resolve({
+				context: params.context,
+				input: args.input,
+				runId: params.runId,
+				toolCallId: args.toolCall.callId,
+				toolName: args.tool.name,
+				toolTarget: args.toolTarget
+			});
+			resolved = {
+				required: runtimeResolved.required ?? resolved.required,
+				timeoutMs: runtimeResolved.timeoutMs ?? resolved.timeoutMs,
+				meta: runtimeResolved.meta ?? resolved.meta
+			};
+		}
+		return resolved;
+	};
+	const emitApprovalRequested = async (prepared) => {
+		await params.emit({
+			type: Events.TOOL_APPROVAL_REQUIRED,
+			runId: params.runId,
+			agentName: params.agentName,
+			parentMessageId: params.parentMessageId,
+			toolCallId: prepared.toolCall.callId,
+			toolCallName: prepared.toolCall.name,
+			toolTarget: prepared.toolTarget,
+			toolInput: prepared.validatedInput,
+			state: "requested",
+			timestamp: Date.now(),
+			meta: prepared.resolvedApproval?.meta
+		});
+		await params.emit({
+			type: Events.TOOL_APPROVAL_UPDATED,
+			runId: params.runId,
+			agentName: params.agentName,
+			parentMessageId: params.parentMessageId,
+			toolCallId: prepared.toolCall.callId,
+			toolCallName: prepared.toolCall.name,
+			toolTarget: prepared.toolTarget,
+			state: "requested",
+			toolInput: prepared.validatedInput,
+			timestamp: Date.now(),
+			meta: prepared.resolvedApproval?.meta
+		});
+	};
+	const awaitApprovalIfNeeded = async (prepared) => {
+		if (!prepared.resolvedApproval?.required) return { approved: true };
+		if (!params.pendingToolRuntime) throw BetterAgentError.fromCode("NOT_IMPLEMENTED", `Tool '${prepared.tool.name}' requires approval, but no approval runtime is configured.`, {
+			context: {
+				runId: params.runId,
+				toolName: prepared.tool.name,
+				toolCallId: prepared.toolCall.callId,
+				toolTarget: prepared.toolTarget
+			},
+			trace: [{ at: "core.run.executeTools.awaitApprovalIfNeeded" }]
+		});
+		try {
+			const decision = await params.pendingToolRuntime.awaitToolApproval({
+				runId: params.runId,
+				toolCallId: prepared.toolCall.callId,
+				toolName: prepared.tool.name,
+				timeoutMs: prepared.resolvedApproval.timeoutMs ?? params.advanced?.toolApprovalTimeoutMs,
+				signal: params.signal
+			});
+			await params.emit({
+				type: Events.TOOL_APPROVAL_UPDATED,
+				runId: params.runId,
+				agentName: params.agentName,
+				parentMessageId: params.parentMessageId,
+				toolCallId: prepared.toolCall.callId,
+				toolCallName: prepared.toolCall.name,
+				toolTarget: prepared.toolTarget,
+				state: decision.decision,
+				toolInput: prepared.validatedInput,
+				timestamp: Date.now(),
+				meta: prepared.resolvedApproval.meta,
+				note: decision.note,
+				actorId: decision.actorId
+			});
+			if (decision.decision === "denied") return decision.note !== void 0 ? {
+				approved: false,
+				note: decision.note
+			} : { approved: false };
+			return { approved: true };
+		} catch (error) {
+			if (error instanceof BetterAgentError && error.code === "TIMEOUT") await params.emit({
+				type: Events.TOOL_APPROVAL_UPDATED,
+				runId: params.runId,
+				agentName: params.agentName,
+				parentMessageId: params.parentMessageId,
+				toolCallId: prepared.toolCall.callId,
+				toolCallName: prepared.toolCall.name,
+				toolTarget: prepared.toolTarget,
+				state: "expired",
+				toolInput: prepared.validatedInput,
+				timestamp: Date.now(),
+				meta: prepared.resolvedApproval.meta
+			});
+			throw error;
+		}
+	};
+	for (const toolCall of params.toolCalls) {
+		throwIfAborted();
+		const { tool, toolTarget } = resolveExecutableTool(toolCall);
+		const resolvedToolErrorMode = tool.toolErrorMode ?? params.toolErrorMode ?? "tool_error";
+		const defaultToolErrorOutcome = (args) => {
+			if (isAbortError(args.error)) throw args.error;
+			if (resolvedToolErrorMode === "throw") throw args.error;
+			return createToolErrorOutcomeFromError({
+				toolName: toolCall.name,
+				error: args.error,
+				errorKind: args.errorKind,
+				retryable: args.retryable
+			});
+		};
+		const runToolHandler = async (input) => {
+			if (tool.kind === "server") return await tool.handler(input, {
+				signal: params.signal,
+				emit: params.emit
+			});
+			if (!params.pendingToolRuntime) throw BetterAgentError.fromCode("NOT_IMPLEMENTED", `Client tool '${tool.name}' requires a live runtime capable of accepting tool results.`, {
+				context: {
+					runId: params.runId,
+					agentName: params.agentName,
+					toolName: tool.name,
+					toolCallId: toolCall.callId
+				},
+				trace: [{ at: "core.run.executeToolCalls.awaitClientToolResult" }]
+			});
+			return await params.pendingToolRuntime.awaitClientToolResult({
+				runId: params.runId,
+				toolCallId: toolCall.callId,
+				toolName: toolCall.name,
+				timeoutMs: params.advanced?.clientToolResultTimeoutMs,
+				signal: params.signal
+			});
+		};
+		const resolveHookAction = async (context) => {
+			const toolAction = await tool.onToolError?.(context);
+			if (toolAction !== void 0) {
+				if (toolAction.action !== "skip") return toolAction;
+			} else return;
+			const agentAction = await params.onToolError?.(context);
+			if (agentAction !== void 0 && agentAction.action !== "skip") return agentAction;
+		};
+		const resolveToolError = async (args) => {
+			if (isAbortError(args.error)) throw args.error;
+			if (args.recoveryDepth >= MAX_TOOL_ERROR_REPAIR_DEPTH) return defaultToolErrorOutcome({
+				error: args.error,
+				errorKind: args.errorKind
+			});
+			const action = await resolveHookAction(args.errorKind === "parse" ? {
+				toolName: toolCall.name,
+				toolCallId: toolCall.callId,
+				error: args.error,
+				rawArguments: toolCall.arguments,
+				errorKind: "parse"
+			} : args.errorKind === "validation" ? {
+				toolName: toolCall.name,
+				toolCallId: toolCall.callId,
+				error: args.error,
+				rawArguments: toolCall.arguments,
+				input: args.input,
+				errorKind: "validation"
+			} : {
+				toolName: toolCall.name,
+				toolCallId: toolCall.callId,
+				error: args.error,
+				rawArguments: toolCall.arguments,
+				input: args.input,
+				errorKind: "execution"
+			});
+			if (action === void 0) return defaultToolErrorOutcome({
+				error: args.error,
+				errorKind: args.errorKind
+			});
+			switch (action.action) {
+				case "send_to_model": return createToolErrorOutcomeFromError({
+					toolName: toolCall.name,
+					error: args.error,
+					errorKind: args.errorKind,
+					message: action.message ?? extractToolErrorMessage(args.error, args.errorKind),
+					retryable: action.retryable
+				});
+				case "throw": throw args.error;
+				case "skip": return defaultToolErrorOutcome({
+					error: args.error,
+					errorKind: args.errorKind
+				});
+				case "repair": return await validateAndExecuteInput(action.input, args.recoveryDepth + 1);
+				case "retry": {
+					if (args.errorKind !== "execution" || args.input === void 0) {
+						logger.warn(`[better-agent] Ignoring invalid onToolError action '${action.action}' for tool '${toolCall.name}' (${args.errorKind} error).`);
+						return createToolErrorOutcomeFromError({
+							toolName: toolCall.name,
+							error: args.error,
+							errorKind: args.errorKind
+						});
+					}
+					const attempts = Math.max(1, Math.min(action.maxAttempts ?? 1, MAX_TOOL_ERROR_RETRY_ATTEMPTS));
+					let lastError = args.error;
+					for (let attempt = 0; attempt < attempts; attempt += 1) {
+						throwIfAborted();
+						try {
+							return { result: await runToolHandler(args.input) };
+						} catch (retryError) {
+							if (isAbortError(retryError)) throw retryError;
+							lastError = retryError;
+							if (attempt < attempts - 1) await waitForRetryBackoff((attempt + 1) * 500);
+						}
+					}
+					return await resolveToolError({
+						error: lastError,
+						errorKind: "execution",
+						input: args.input,
+						recoveryDepth: args.recoveryDepth + 1
+					});
+				}
+				case "result":
+					if (args.errorKind !== "execution") {
+						logger.warn(`[better-agent] Ignoring invalid onToolError action '${action.action}' for tool '${toolCall.name}' (${args.errorKind} error).`);
+						return createToolErrorOutcomeFromError({
+							toolName: toolCall.name,
+							error: args.error,
+							errorKind: args.errorKind
+						});
+					}
+					return { result: action.value };
+				default: return defaultToolErrorOutcome({
+					error: args.error,
+					errorKind: args.errorKind
+				});
+			}
+		};
+		const executeApprovedInput = async (prepared, input, recoveryDepth) => {
+			const approval = await awaitApprovalIfNeeded(prepared);
+			if (!approval.approved) {
+				const denialReason = approval.note ? ` Reason: ${approval.note}` : "";
+				return { result: `Tool '${toolCall.name}' was denied by the operator.${denialReason}` };
+			}
+			try {
+				return { result: await runToolHandler(input) };
+			} catch (error) {
+				if (isAbortError(error)) throw error;
+				return await resolveToolError({
+					error,
+					errorKind: "execution",
+					input,
+					recoveryDepth
+				});
+			}
+		};
+		const validateAndExecuteInput = async (input, recoveryDepth) => {
+			const validatedInput = await validateInput(tool.schema, input);
+			if (validatedInput.isErr()) return await resolveToolError({
+				error: validatedInput.error.at({ at: "core.run.executeToolCalls.validateToolInput" }),
+				errorKind: "validation",
+				input,
+				recoveryDepth
+			});
+			return await executeApprovedInput({
+				toolCall,
+				tool,
+				toolTarget,
+				args: input,
+				validatedInput: validatedInput.value,
+				resolvedApproval: await resolveApprovalConfig({
+					approval: tool.approval,
+					input: validatedInput.value,
+					toolCall,
+					tool,
+					toolTarget
+				}),
+				skip: false,
+				shouldEmitToolCallEnd: false
+			}, validatedInput.value, recoveryDepth);
+		};
+		const prepareToolCall = async () => {
+			const parsed = safeJsonParse(toolCall.arguments);
+			if (parsed.isErr()) return {
+				toolCall,
+				tool,
+				toolTarget,
+				skip: false,
+				shouldEmitToolCallEnd: false,
+				parseError: BetterAgentError.wrap({
+					err: parsed.error,
+					message: `Failed to parse arguments for tool '${toolCall.name}'`,
+					opts: {
+						code: "VALIDATION_FAILED",
+						context: {
+							toolName: toolCall.name,
+							toolCallId: toolCall.callId
+						},
+						trace: [{ at: "core.run.executeToolCalls.parseToolArguments" }]
+					}
+				})
+			};
+			const beforeHook = params.pluginRuntime?.hasToolHooks === true ? await params.pluginRuntime.applyBeforeToolCall({
+				runId: params.runId,
+				agentName: params.agentName,
+				toolName: toolCall.name,
+				toolCallId: toolCall.callId,
+				args: parsed.value,
+				conversationId: params.conversationId
+			}) : { args: parsed.value };
+			if (beforeHook?.decision?.skip === true) return {
+				toolCall,
+				tool,
+				toolTarget,
+				args: beforeHook.args,
+				skip: true,
+				skipResult: beforeHook.decision.result,
+				shouldEmitToolCallEnd: true
+			};
+			const validatedInput = await validateInput(tool.schema, beforeHook.args);
+			if (validatedInput.isErr()) return {
+				toolCall,
+				tool,
+				toolTarget,
+				args: beforeHook.args,
+				skip: false,
+				shouldEmitToolCallEnd: false,
+				validationError: validatedInput.error.at({ at: "core.run.executeToolCalls.validateToolInput" })
+			};
+			const prepared = {
+				toolCall,
+				tool,
+				toolTarget,
+				args: beforeHook.args,
+				validatedInput: validatedInput.value,
+				resolvedApproval: await resolveApprovalConfig({
+					approval: tool.approval,
+					input: validatedInput.value,
+					toolCall,
+					tool,
+					toolTarget
+				}),
+				skip: false,
+				shouldEmitToolCallEnd: true
+			};
+			if (prepared.resolvedApproval?.required) await emitApprovalRequested(prepared);
+			return prepared;
+		};
+		const executePreparedTool = async (prepared) => {
+			if (prepared.parseError) return await resolveToolError({
+				error: prepared.parseError,
+				errorKind: "parse",
+				recoveryDepth: 0
+			});
+			if (prepared.skip) return { result: prepared.skipResult };
+			if (prepared.validationError) return await resolveToolError({
+				error: prepared.validationError,
+				errorKind: "validation",
+				input: prepared.args,
+				recoveryDepth: 0
+			});
+			return await executeApprovedInput(prepared, prepared.validatedInput, 0);
+		};
+		const applyAfterToolCall = async (prepared, outcome) => {
+			if (params.pluginRuntime?.hasToolHooks !== true) return outcome;
+			const afterHook = await params.pluginRuntime.applyAfterToolCall({
+				runId: params.runId,
+				agentName: params.agentName,
+				toolName: toolCall.name,
+				toolCallId: toolCall.callId,
+				args: prepared.args,
+				result: outcome.result,
+				conversationId: params.conversationId,
+				error: outcome.isError === true && typeof outcome.result === "object" && outcome.result !== null && "message" in outcome.result && typeof outcome.result.message === "string" ? outcome.result.message : void 0
+			});
+			return {
+				...outcome,
+				result: afterHook.result
+			};
+		};
+		await emitToolCallStart({
+			toolCall,
+			toolTarget
+		});
+		await emitToolCallArgs({
+			toolCall,
+			toolTarget
+		});
+		const prepared = await prepareToolCall();
+		if (prepared.shouldEmitToolCallEnd) await emitToolCallEnd(prepared);
+		const finalOutcome = await applyAfterToolCall(prepared, await executePreparedTool(prepared));
+		await emitToolCallResult(prepared, finalOutcome);
+		results.push({
+			type: "tool-call",
+			callId: toolCall.callId,
+			name: toolCall.name,
+			arguments: toolCall.arguments,
+			result: finalOutcome.result,
+			isError: finalOutcome.isError
+		});
+	}
+	return { results };
+};
+
+//#endregion
+export { executeToolCalls };
+//# sourceMappingURL=execute-tool-calls.mjs.map