@zhivex-ai/core 0.20.0 → 1.0.0

package/dist/generate-text.js

@@ -1,9 +1,11 @@
+import { createHash } from "node:crypto";
 import { BoundedReplayBroadcast } from "./bounded-broadcast.js";
-import { ParseError, UnsupportedFeatureError, ValidationError } from "./errors.js";
+import { GuardrailTriggeredError, ParseError, UnsupportedFeatureError, ValidationError } from "./errors.js";
 import { emitLanguageModelTelemetryEvent } from "./middleware.js";
 import { createTextMessage, getTextFromMessages, isCallableToolDefinition, normalizeFinishReason, providerDataPart, resultMessages, serializeJsonValue, toolCallPart, toolResultPart, validateMessageParts } from "./messages.js";
 import { mergeAbortSignals } from "./runtime.js";
 import { toToolSet } from "./tool-registry.js";
+import { ToolExecutionSuspendedError } from "./tool-execution-suspension.js";
 const withToolTimeout = async (operation, timeoutMs, abortSignal) => {
     if (!timeoutMs) {
         return operation(abortSignal);
@@ -121,8 +123,52 @@ const toRequest = (options, messages) => ({
     maxRetries: options.maxRetries,
     retryBackoffMs: options.retryBackoffMs
 });
-const executeTools = async (toolCalls, options, context) => {
-    const validatedCalls = toolCalls.map((call) => {
+const canonicalJson = (value) => {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(canonicalJson).join(",")}]`;
+    }
+    return `{${Object.keys(value)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`)
+        .join(",")}}`;
+};
+const localApprovalBinding = (options, item, step) => {
+    const input = serializeJsonValue(item.parsedInput);
+    const toolVersion = item.tool.approvalVersion ?? "1";
+    const payload = canonicalJson({
+        runId: options.toolContext?.runId ?? null,
+        step,
+        toolCallId: item.call.id,
+        toolName: item.call.name,
+        input,
+        toolVersion
+    });
+    const inputDigest = createHash("sha256").update(payload).digest("hex");
+    return {
+        id: `approval_${inputDigest}`,
+        input,
+        inputDigest,
+        payload,
+        toolVersion
+    };
+};
+const localApprovalResolutionPayload = (inputDigest, approve, reason) => JSON.stringify({
+    inputDigest,
+    approve,
+    reason: reason ?? null
+});
+const normalizeApprovalDecision = (rawDecision, toolName) => typeof rawDecision === "boolean"
+    ? {
+        approved: rawDecision,
+        reason: rawDecision ? undefined : `Tool "${toolName}" was denied by the approval policy.`
+    }
+    : rawDecision ?? { approved: true };
+const validateToolCalls = async (toolCalls, options, context) => {
+    const validated = [];
+    for (const call of toolCalls) {
         const tool = context.tools[call.name];
         if (!tool) {
             throw new ValidationError(`Tool "${call.name}" was requested by the model but is not registered.`);
@@ -134,56 +180,165 @@ const executeTools = async (toolCalls, options, context) => {
         if (!parsed.success) {
             throw new ValidationError(`Invalid input for tool "${call.name}": ${parsed.error.message}`);
         }
-        return {
-            call,
-            tool,
-            parsedInput: parsed.data
-        };
-    });
-    const parallel = options.toolExecution?.parallel ?? options.model.capabilities.parallelToolCalls;
-    const maxConcurrency = Math.max(1, options.toolExecution?.maxConcurrency ?? validatedCalls.length ?? 1);
-    const timeoutMs = options.toolExecution?.timeoutMs;
-    const stopOnError = options.toolExecution?.stopOnError ?? false;
-    const results = new Array(validatedCalls.length);
-    const evaluateApproval = async (item) => {
-        const request = {
-            toolCall: item.call,
-            tool: item.tool,
-            input: serializeJsonValue(item.parsedInput),
+        const executionContext = {
+            ...options.toolContext,
+            abortSignal: context.request.abortSignal,
+            toolCall: call,
             step: context.step,
             model: options.model,
             request: context.request
         };
-        if (!options.toolApprovalPolicy) {
-            const decision = item.tool.requiresApproval
+        if (tool.isEnabled && !(await tool.isEnabled(parsed.data, executionContext))) {
+            throw new ValidationError(`Tool "${call.name}" is disabled for this execution context.`);
+        }
+        validated.push({
+            call,
+            tool,
+            parsedInput: parsed.data,
+            executionContext
+        });
+    }
+    return validated;
+};
+const preflightTools = async (toolCalls, options, context) => {
+    const validatedCalls = await validateToolCalls(toolCalls, options, context);
+    const decisions = new Map();
+    const approvalRequests = [];
+    for (const item of validatedCalls) {
+        await runToolGuardrails(item, "input");
+        const binding = localApprovalBinding(options, item, context.step);
+        const resolution = options.toolApprovalResolutions?.find((candidate) => candidate.kind === "local-tool" &&
+            candidate.requestId === binding.id &&
+            candidate.toolCallId === item.call.id);
+        let decision;
+        if (resolution) {
+            if (resolution.inputDigest !== binding.inputDigest ||
+                resolution.toolVersion !== binding.toolVersion ||
+                resolution.step !== context.step) {
+                throw new ValidationError(`Approval request "${resolution.requestId}" no longer matches tool "${item.call.name}".`);
+            }
+            if (options.toolApprovalSigner) {
+                if (!resolution.signature) {
+                    throw new ValidationError(`Approval request "${resolution.requestId}" is missing its required signature.`);
+                }
+                const resolutionPayload = localApprovalResolutionPayload(resolution.inputDigest, resolution.approve, resolution.reason);
+                const validSignature = options.toolApprovalSigner.verify
+                    ? await options.toolApprovalSigner.verify(resolutionPayload, resolution.signature)
+                    : (await options.toolApprovalSigner.sign(resolutionPayload)) === resolution.signature;
+                if (!validSignature) {
+                    throw new ValidationError(`Approval request "${resolution.requestId}" has an invalid signature.`);
+                }
+            }
+            decision = {
+                approved: resolution.approve,
+                reason: resolution.reason
+            };
+        }
+        else if (item.tool.requiresApproval && item.tool.approvalMode === "interrupt") {
+            decision = {
+                approved: false,
+                approvalRequired: true,
+                reason: `Tool "${item.call.name}" requires human approval.`
+            };
+        }
+        else if (!options.toolApprovalPolicy) {
+            decision = item.tool.requiresApproval
                 ? {
                     approved: false,
                     reason: `Tool "${item.call.name}" requires approval, but no toolApprovalPolicy is configured.`
                 }
                 : { approved: true };
-            await options.onToolApprovalDecision?.({
-                request,
-                decision
-            });
-            return decision;
         }
-        const rawDecision = await options.toolApprovalPolicy(request);
-        const decision = typeof rawDecision === "boolean"
-            ? {
-                approved: rawDecision,
-                reason: rawDecision ? undefined : `Tool "${item.call.name}" was denied by the approval policy.`
-            }
-            : rawDecision;
-        const normalizedDecision = decision ?? { approved: true };
+        else {
+            const approvalRequest = {
+                toolCall: item.call,
+                tool: item.tool,
+                input: binding.input,
+                step: context.step,
+                model: options.model,
+                request: context.request,
+                executionContext: item.executionContext
+            };
+            decision = normalizeApprovalDecision(await options.toolApprovalPolicy(approvalRequest), item.call.name);
+        }
+        const approvalRequest = {
+            toolCall: item.call,
+            tool: item.tool,
+            input: binding.input,
+            step: context.step,
+            model: options.model,
+            request: context.request,
+            executionContext: item.executionContext
+        };
+        if (decision.approved && decision.approvalRequired) {
+            throw new ValidationError(`Tool approval decision for "${item.call.name}" cannot be both approved and approvalRequired.`);
+        }
         await options.onToolApprovalDecision?.({
-            request,
-            decision: normalizedDecision
+            request: approvalRequest,
+            decision
         });
-        return normalizedDecision;
+        if (decision.approvalRequired) {
+            const signature = options.toolApprovalSigner
+                ? await options.toolApprovalSigner.sign(binding.inputDigest)
+                : undefined;
+            approvalRequests.push({
+                kind: "local-tool",
+                provider: "zhivex",
+                id: binding.id,
+                name: item.call.name,
+                arguments: canonicalJson(binding.input),
+                toolCallId: item.call.id,
+                step: context.step,
+                inputDigest: binding.inputDigest,
+                toolVersion: binding.toolVersion,
+                signature,
+                rawData: {
+                    type: "tool_approval_request",
+                    id: binding.id,
+                    name: item.call.name,
+                    arguments: canonicalJson(binding.input),
+                    tool_call_id: item.call.id,
+                    step: context.step,
+                    input_digest: binding.inputDigest,
+                    tool_version: binding.toolVersion,
+                    ...(signature ? { signature } : {})
+                }
+            });
+        }
+        else {
+            decisions.set(item.call.id, decision);
+        }
+    }
+    return {
+        validatedCalls,
+        decisions,
+        approvalRequests
     };
+};
+const runToolGuardrails = async (item, stage, output) => {
+    const guardrails = stage === "input" ? item.tool.inputGuardrails : item.tool.outputGuardrails;
+    for (const guardrail of guardrails ?? []) {
+        const trigger = await guardrail({
+            tool: item.tool,
+            input: item.parsedInput,
+            context: item.executionContext,
+            ...(stage === "output" ? { output } : {})
+        });
+        if (trigger?.triggered) {
+            throw new GuardrailTriggeredError(stage === "input" ? "tool-input" : "tool-output", trigger.reason ?? `Tool "${item.call.name}" ${stage} guardrail triggered.`, { metadata: trigger.metadata });
+        }
+    }
+};
+const executeTools = async (preflight, options, context) => {
+    const { validatedCalls, decisions } = preflight;
+    const parallel = options.toolExecution?.parallel ?? options.model.capabilities.parallelToolCalls;
+    const maxConcurrency = Math.max(1, options.toolExecution?.maxConcurrency ?? validatedCalls.length ?? 1);
+    const timeoutMs = options.toolExecution?.timeoutMs;
+    const stopOnError = options.toolExecution?.stopOnError ?? false;
+    const results = new Array(validatedCalls.length);
     const executeSingleTool = async (item, index) => {
-        const { call, tool, parsedInput } = item;
-        const approval = await evaluateApproval(item);
+        const { call, tool } = item;
+        const approval = decisions.get(call.id) ?? { approved: true };
         if (!approval.approved) {
             results[index] = {
                 toolCallId: call.id,
@@ -206,13 +361,23 @@ const executeTools = async (toolCalls, options, context) => {
             startedAt
         });
         try {
-            const output = serializeJsonValue(await withToolTimeout(async (abortSignal) => tool.execute(parsedInput, {
-                abortSignal,
-                toolCall: call,
-                step: context.step,
-                model: options.model,
-                request: context.request
-            }), timeoutMs, context.request.abortSignal));
+            // Schema and availability are deliberately rechecked immediately before
+            // the side effect. Input guardrails already ran in this preflight and run
+            // again when a persisted approval is resumed.
+            const reparsed = tool.schema.safeParse(call.input);
+            if (!reparsed.success) {
+                throw new ValidationError(`Invalid input for tool "${call.name}": ${reparsed.error.message}`);
+            }
+            item.parsedInput = reparsed.data;
+            if (tool.isEnabled && !(await tool.isEnabled(reparsed.data, item.executionContext))) {
+                throw new ValidationError(`Tool "${call.name}" is disabled for this execution context.`);
+            }
+            const rawOutput = await withToolTimeout(async (abortSignal) => tool.execute(item.parsedInput, {
+                ...item.executionContext,
+                abortSignal
+            }), timeoutMs, context.request.abortSignal);
+            await runToolGuardrails(item, "output", rawOutput);
+            const output = serializeJsonValue(rawOutput);
             const result = {
                 toolCallId: call.id,
                 toolName: call.name,
@@ -235,10 +400,49 @@ const executeTools = async (toolCalls, options, context) => {
             });
         }
         catch (error) {
+            if (error instanceof ToolExecutionSuspendedError) {
+                throw error;
+            }
+            const normalizedError = error instanceof Error ? error : new Error(String(error));
+            let recoveredOutput;
+            if (tool.onError && !(normalizedError instanceof GuardrailTriggeredError)) {
+                recoveredOutput = await tool.onError(normalizedError, {
+                    tool,
+                    input: item.parsedInput,
+                    context: item.executionContext
+                });
+            }
+            if (recoveredOutput !== undefined) {
+                await runToolGuardrails(item, "output", recoveredOutput);
+                const recoveredResult = {
+                    toolCallId: call.id,
+                    toolName: call.name,
+                    output: serializeJsonValue(recoveredOutput),
+                    isError: false,
+                    providerMetadata: call.providerMetadata
+                };
+                results[index] = recoveredResult;
+                const finishedAt = Date.now();
+                await emitLanguageModelTelemetryEvent(options.model, {
+                    type: "tool-execution-finish",
+                    model: options.model,
+                    input: context.request,
+                    step: context.step,
+                    toolCall: call,
+                    toolResult: recoveredResult,
+                    startedAt,
+                    finishedAt,
+                    latencyMs: finishedAt - startedAt
+                });
+                return;
+            }
+            if (normalizedError instanceof GuardrailTriggeredError) {
+                throw normalizedError;
+            }
             const result = {
                 toolCallId: call.id,
                 toolName: call.name,
-                error: { message: error instanceof Error ? error.message : "Tool execution failed." },
+                error: { message: normalizedError.message },
                 isError: true,
                 providerMetadata: call.providerMetadata
             };
@@ -250,7 +454,7 @@ const executeTools = async (toolCalls, options, context) => {
                 input: context.request,
                 step: context.step,
                 toolCall: call,
-                error: error instanceof Error ? error : new Error(String(error)),
+                error: normalizedError,
                 startedAt,
                 finishedAt,
                 latencyMs: finishedAt - startedAt
@@ -259,7 +463,15 @@ const executeTools = async (toolCalls, options, context) => {
     };
     if (!parallel || validatedCalls.length <= 1) {
         for (const [index, item] of validatedCalls.entries()) {
-            await executeSingleTool(item, index);
+            try {
+                await executeSingleTool(item, index);
+            }
+            catch (error) {
+                if (error instanceof ToolExecutionSuspendedError) {
+                    throw new ToolExecutionSuspendedError(error.approvals, results.filter((result) => Boolean(result)));
+                }
+                throw error;
+            }
             if (stopOnError && results[index]?.isError) {
                 throw new Error(`Tool "${item.call.name}" failed: ${results[index]?.error?.message ?? "Unknown tool error."}`);
             }
@@ -328,17 +540,61 @@ export const generateText = async (options) => {
     }
     const toolResults = [];
     const generatedMessages = [];
+    const approvalRequests = [];
     let finalResult;
     const pendingToolCalls = extractUnresolvedToolCalls(allMessages);
     if (pendingToolCalls.length) {
         const request = toRequest(options, allMessages);
         const step = options.stepOffset ?? 0;
-        await options.onBeforeToolExecution?.({ request, step, toolCalls: pendingToolCalls });
-        const recoveredToolResults = await executeTools(pendingToolCalls, options, {
+        const preflight = await preflightTools(pendingToolCalls, options, {
             request,
             step,
             tools: resolvedTools
         });
+        if (preflight.approvalRequests.length) {
+            approvalRequests.push(...preflight.approvalRequests);
+            return {
+                text: "",
+                finishReason: "tool-calls",
+                steps,
+                messages: allMessages,
+                toolResults,
+                approvalRequests
+            };
+        }
+        await options.onBeforeToolExecution?.({ request, step, toolCalls: pendingToolCalls });
+        let recoveredToolResults;
+        try {
+            recoveredToolResults = await executeTools(preflight, options, {
+                request,
+                step
+            });
+        }
+        catch (error) {
+            if (!(error instanceof ToolExecutionSuspendedError)) {
+                throw error;
+            }
+            toolResults.push(...error.completedResults);
+            for (const result of error.completedResults) {
+                allMessages.push({ role: "tool", parts: [toolResultPart(result)] });
+            }
+            if (error.completedResults.length) {
+                await options.onToolExecutionComplete?.({
+                    request,
+                    step,
+                    toolResults: error.completedResults
+                });
+            }
+            approvalRequests.push(...error.approvals);
+            return {
+                text: "",
+                finishReason: "tool-calls",
+                steps,
+                messages: allMessages,
+                toolResults,
+                approvalRequests
+            };
+        }
         toolResults.push(...recoveredToolResults);
         for (const result of recoveredToolResults) {
             allMessages.push({ role: "tool", parts: [toolResultPart(result)] });
@@ -346,11 +602,18 @@ export const generateText = async (options) => {
         await options.onToolExecutionComplete?.({ request, step, toolResults: recoveredToolResults });
     }
     for (let step = 0; step < maxSteps; step += 1) {
-        const request = toRequest(options, allMessages);
         const absoluteStep = (options.stepOffset ?? 0) + step + 1;
+        const preparedMessages = await options.prepareModelMessages?.({
+            messages: structuredClone(allMessages),
+            step: absoluteStep
+        });
+        if (preparedMessages) {
+            allMessages.splice(0, allMessages.length, ...structuredClone(preparedMessages));
+        }
+        const request = toRequest(options, allMessages);
         await options.onBeforeModelStep?.({ request, step: absoluteStep });
         const startedAt = Date.now();
-        const response = await options.model.generate(request);
+        let response = await options.model.generate(request);
         stepTimings.set(request, { startedAt, finishedAt: Date.now() });
         steps.push({ request, response });
         finalResult = response;
@@ -360,16 +623,55 @@ export const generateText = async (options) => {
             generatedMessages.push(...responseMessages);
         }
         const toolCalls = extractToolCalls(responseMessages);
-        await options.onModelStep?.({ request, response, step: absoluteStep, toolCalls });
-        if (!toolCalls.length) {
-            break;
+        const preflight = toolCalls.length
+            ? await preflightTools(toolCalls, options, {
+                request,
+                step: absoluteStep,
+                tools: resolvedTools
+            })
+            : undefined;
+        if (preflight?.approvalRequests.length) {
+            approvalRequests.push(...preflight.approvalRequests);
         }
-        await options.onBeforeToolExecution?.({ request, step: absoluteStep, toolCalls });
-        const currentToolResults = await executeTools(toolCalls, options, {
+        await options.onModelStep?.({
             request,
+            response,
             step: absoluteStep,
-            tools: resolvedTools
+            toolCalls,
+            approvalRequests: preflight?.approvalRequests ?? []
         });
+        if (!toolCalls.length || preflight?.approvalRequests.length) {
+            break;
+        }
+        await options.onBeforeToolExecution?.({ request, step: absoluteStep, toolCalls });
+        let currentToolResults;
+        try {
+            currentToolResults = await executeTools(preflight, options, {
+                request,
+                step: absoluteStep
+            });
+        }
+        catch (error) {
+            if (!(error instanceof ToolExecutionSuspendedError)) {
+                throw error;
+            }
+            toolResults.push(...error.completedResults);
+            for (const result of error.completedResults) {
+                allMessages.push({
+                    role: "tool",
+                    parts: [toolResultPart(result)]
+                });
+            }
+            if (error.completedResults.length) {
+                await options.onToolExecutionComplete?.({
+                    request,
+                    step: absoluteStep,
+                    toolResults: error.completedResults
+                });
+            }
+            approvalRequests.push(...error.approvals);
+            break;
+        }
         toolResults.push(...currentToolResults);
         for (const result of currentToolResults) {
             allMessages.push({
@@ -389,7 +691,8 @@ export const generateText = async (options) => {
         usage: aggregateTokenUsage(steps.map((step) => step.response.usage)),
         steps,
         messages: allMessages,
-        toolResults
+        toolResults,
+        approvalRequests
     };
 };
 export const streamText = (options) => {
@@ -428,17 +731,72 @@ export const streamText = (options) => {
         const generatedMessages = [];
         const steps = [];
         const toolResults = [];
+        const approvalRequests = [];
         let finalResult;
         const pendingToolCalls = extractUnresolvedToolCalls(allMessages);
         if (pendingToolCalls.length) {
             const request = toRequest(options, allMessages);
             const step = options.stepOffset ?? 0;
-            await options.onBeforeToolExecution?.({ request, step, toolCalls: pendingToolCalls });
-            const recoveredToolResults = await executeTools(pendingToolCalls, options, {
+            const preflight = await preflightTools(pendingToolCalls, options, {
                 request,
                 step,
                 tools: resolvedTools
             });
+            if (preflight.approvalRequests.length) {
+                approvalRequests.push(...preflight.approvalRequests);
+                for (const approval of preflight.approvalRequests) {
+                    await publish({ type: "tool-approval-request", approval });
+                }
+                await publish({ type: "finish", finishReason: "tool-calls" }, true);
+                broadcast.close();
+                return {
+                    text: "",
+                    finishReason: "tool-calls",
+                    steps,
+                    messages: allMessages,
+                    toolResults,
+                    approvalRequests
+                };
+            }
+            await options.onBeforeToolExecution?.({ request, step, toolCalls: pendingToolCalls });
+            let recoveredToolResults;
+            try {
+                recoveredToolResults = await executeTools(preflight, options, {
+                    request,
+                    step
+                });
+            }
+            catch (error) {
+                if (!(error instanceof ToolExecutionSuspendedError)) {
+                    throw error;
+                }
+                toolResults.push(...error.completedResults);
+                for (const result of error.completedResults) {
+                    await publish({ type: "tool-result", toolResult: result });
+                    allMessages.push({ role: "tool", parts: [toolResultPart(result)] });
+                }
+                if (error.completedResults.length) {
+                    await options.onToolExecutionComplete?.({
+                        request,
+                        step,
+                        toolResults: error.completedResults
+                    });
+                }
+                approvalRequests.push(...error.approvals);
+                for (const approval of error.approvals) {
+                    await publish({ type: "tool-approval-request", approval });
+                }
+                await publish({ type: "finish", finishReason: "tool-calls" }, true);
+                broadcast.close();
+                return {
+                    text: "",
+                    finishReason: "tool-calls",
+                    steps,
+                    messages: allMessages,
+                    toolResults,
+                    approvalRequests
+                };
+            }
             toolResults.push(...recoveredToolResults);
             for (const result of recoveredToolResults) {
                 await publish({ type: "tool-result", toolResult: result });
@@ -447,8 +805,15 @@ export const streamText = (options) => {
             await options.onToolExecutionComplete?.({ request, step, toolResults: recoveredToolResults });
         }
         for (let step = 0; step < maxSteps; step += 1) {
-            const request = toRequest(options, allMessages);
             const absoluteStep = (options.stepOffset ?? 0) + step + 1;
+            const preparedMessages = await options.prepareModelMessages?.({
+                messages: structuredClone(allMessages),
+                step: absoluteStep
+            });
+            if (preparedMessages) {
+                allMessages.splice(0, allMessages.length, ...structuredClone(preparedMessages));
+            }
+            const request = toRequest(options, allMessages);
             await options.onBeforeModelStep?.({ request, step: absoluteStep });
             const startedAt = Date.now();
             const stream = await streamModel(request);
@@ -518,16 +883,62 @@ export const streamText = (options) => {
             allMessages.push(...stepMessages);
             generatedMessages.push(...stepMessages);
             const toolCalls = extractToolCalls(stepMessages);
-            await options.onModelStep?.({ request, response: finalResult, step: absoluteStep, toolCalls });
-            if (!toolCalls.length) {
-                break;
+            const preflight = toolCalls.length
+                ? await preflightTools(toolCalls, options, {
+                    request,
+                    step: absoluteStep,
+                    tools: resolvedTools
+                })
+                : undefined;
+            if (preflight?.approvalRequests.length) {
+                approvalRequests.push(...preflight.approvalRequests);
+                for (const approval of preflight.approvalRequests) {
+                    await publish({ type: "tool-approval-request", approval });
+                }
             }
-            await options.onBeforeToolExecution?.({ request, step: absoluteStep, toolCalls });
-            const currentToolResults = await executeTools(toolCalls, options, {
+            await options.onModelStep?.({
                 request,
+                response: finalResult,
                 step: absoluteStep,
-                tools: resolvedTools
+                toolCalls,
+                approvalRequests: preflight?.approvalRequests ?? []
             });
+            if (!toolCalls.length || preflight?.approvalRequests.length) {
+                break;
+            }
+            await options.onBeforeToolExecution?.({ request, step: absoluteStep, toolCalls });
+            let currentToolResults;
+            try {
+                currentToolResults = await executeTools(preflight, options, {
+                    request,
+                    step: absoluteStep
+                });
+            }
+            catch (error) {
+                if (!(error instanceof ToolExecutionSuspendedError)) {
+                    throw error;
+                }
+                toolResults.push(...error.completedResults);
+                for (const result of error.completedResults) {
+                    await publish({ type: "tool-result", toolResult: result });
+                    allMessages.push({
+                        role: "tool",
+                        parts: [toolResultPart(result)]
+                    });
+                }
+                if (error.completedResults.length) {
+                    await options.onToolExecutionComplete?.({
+                        request,
+                        step: absoluteStep,
+                        toolResults: error.completedResults
+                    });
+                }
+                approvalRequests.push(...error.approvals);
+                for (const approval of error.approvals) {
+                    await publish({ type: "tool-approval-request", approval });
+                }
+                break;
+            }
             toolResults.push(...currentToolResults);
             for (const toolResult of currentToolResults) {
                 await publish({ type: "tool-result", toolResult });
@@ -556,7 +967,8 @@ export const streamText = (options) => {
             usage,
             steps,
             messages: allMessages,
-            toolResults
+            toolResults,
+            approvalRequests
         };
     };
     finalResultPromise = runner().catch(async (error) => {