@lleverage-ai/agent-sdk 0.0.7 → 0.0.9

package/dist/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA4DH,OAAO,KAAK,EACV,KAAK,EACL,YAAY,EAwBb,MAAM,YAAY,CAAC;AA6pBpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,KAAK,CAmrFxD"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA4DH,OAAO,KAAK,EACV,KAAK,EACL,YAAY,EAwBb,MAAM,YAAY,CAAC;AA6pBpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,KAAK,CAiyFxD"}

package/dist/agent.js

@@ -1286,6 +1286,250 @@ export function createAgent(options) {
         }
         return null;
     }
+    /**
+     * Collect all tools (core + static plugin tools + MCP tools) for
+     * deterministic tool execution during resume. This is the unwrapped set
+     * — no permission mode, hooks, or signal-catching wrappers applied.
+     */
+    function collectAllTools() {
+        const allTools = { ...coreTools };
+        for (const plugin of options.plugins ?? []) {
+            if (plugin.tools && typeof plugin.tools !== "function") {
+                Object.assign(allTools, plugin.tools);
+            }
+        }
+        Object.assign(allTools, mcpManager.getToolSet());
+        return allTools;
+    }
+    /**
+     * Shared logic for resume() and resumeDataResponse().
+     *
+     * Validates the checkpoint/interrupt, stores the user response, emits hooks,
+     * executes the interrupted tool (approval or custom), updates the checkpoint,
+     * and returns a discriminated outcome so the caller can decide how to continue.
+     */
+    async function executeResumeCore(threadId, interruptId, response, genOptions) {
+        if (!options.checkpointer) {
+            throw new Error("Cannot resume: checkpointer is required");
+        }
+        const checkpoint = await options.checkpointer.load(threadId);
+        if (!checkpoint) {
+            throw new Error(`Cannot resume: no checkpoint found for thread ${threadId}`);
+        }
+        const interrupt = checkpoint.pendingInterrupt;
+        if (!interrupt) {
+            throw new Error(`Cannot resume: no pending interrupt found for thread ${threadId}`);
+        }
+        if (interrupt.id !== interruptId) {
+            throw new Error(`Cannot resume: interrupt ID mismatch. Expected ${interrupt.id}, got ${interruptId}`);
+        }
+        // Store the response keyed by interrupt ID (format: "int_<toolCallId>").
+        // The interrupt() function in the tool wrapper looks up responses using
+        // this exact key format, so we must use interrupt.id — NOT the raw
+        // toolCallId which would never match.
+        pendingResponses.set(interrupt.id, response);
+        // Emit InterruptResolved hook
+        const interruptResolvedHooks = effectiveHooks?.InterruptResolved ?? [];
+        if (interruptResolvedHooks.length > 0) {
+            const isApproval = isApprovalInterrupt(interrupt);
+            const approvalResponse = isApproval ? response : undefined;
+            const hookInput = {
+                hook_event_name: "InterruptResolved",
+                session_id: threadId,
+                cwd: process.cwd(),
+                interrupt_id: interrupt.id,
+                interrupt_type: interrupt.type,
+                tool_call_id: interrupt.toolCallId,
+                tool_name: interrupt.toolName,
+                response,
+                approved: approvalResponse?.approved,
+            };
+            await invokeHooksWithTimeout(interruptResolvedHooks, hookInput, null, agent);
+        }
+        // Handle approval interrupt
+        if (isApprovalInterrupt(interrupt)) {
+            const approvalResponse = response;
+            // For backward compatibility, also store in approvalDecisions
+            approvalDecisions.set(interrupt.toolCallId, approvalResponse.approved);
+            // Build the assistant message with the tool call
+            const assistantMessage = {
+                role: "assistant",
+                content: [
+                    {
+                        type: "tool-call",
+                        toolCallId: interrupt.toolCallId,
+                        toolName: interrupt.toolName,
+                        input: interrupt.request.args,
+                    },
+                ],
+            };
+            let toolResultOutput;
+            if (approvalResponse.approved) {
+                // Approved: Execute the tool deterministically
+                const unwrappedTools = collectAllTools();
+                const tool = unwrappedTools[interrupt.toolName];
+                if (!tool || !tool.execute) {
+                    throw new Error(`Cannot resume: tool "${interrupt.toolName}" not found or has no execute function`);
+                }
+                try {
+                    toolResultOutput = await tool.execute(interrupt.request.args, {
+                        toolCallId: interrupt.toolCallId,
+                        messages: checkpoint.messages,
+                        abortSignal: genOptions?.signal,
+                    });
+                }
+                catch (error) {
+                    toolResultOutput = `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            }
+            else {
+                // Denied: Create a synthetic denial result
+                toolResultOutput = `Tool "${interrupt.toolName}" was denied by user${approvalResponse.reason ? `: ${approvalResponse.reason}` : ""}`;
+            }
+            // Build the tool result message with proper ToolResultOutput format.
+            // The AI SDK validates messages against modelMessageSchema which
+            // requires output to be { type: 'text', value } or { type: 'json', value }.
+            const approvalOutput = typeof toolResultOutput === "string"
+                ? { type: "text", value: toolResultOutput }
+                : { type: "json", value: toolResultOutput };
+            const toolResultMessage = {
+                role: "tool",
+                content: [
+                    {
+                        type: "tool-result",
+                        toolCallId: interrupt.toolCallId,
+                        toolName: interrupt.toolName,
+                        output: approvalOutput,
+                    },
+                ],
+            };
+            // Update checkpoint with the tool call and result messages, clear interrupt
+            const updatedMessages = [
+                ...checkpoint.messages,
+                assistantMessage,
+                toolResultMessage,
+            ];
+            const updatedCheckpoint = updateCheckpoint(checkpoint, {
+                messages: updatedMessages,
+                pendingInterrupt: undefined,
+                step: checkpoint.step + 1,
+            });
+            await options.checkpointer.save(updatedCheckpoint);
+            threadCheckpoints.set(threadId, updatedCheckpoint);
+            // Clean up the response from our maps
+            pendingResponses.delete(interrupt.id);
+            approvalDecisions.delete(interrupt.toolCallId);
+            return { type: "continue", threadId, genOptions };
+        }
+        // For custom interrupts (e.g. ask_user), manually execute the tool so
+        // that its interrupt() call receives the stored response deterministically.
+        // Re-running generate() would rely on the model re-calling the same tool,
+        // but tool call IDs change each generation so pendingResponses would never
+        // be matched.
+        const customToolCallId = interrupt.toolCallId;
+        const customToolName = interrupt.toolName;
+        if (!customToolCallId || !customToolName) {
+            throw new Error("Cannot resume custom interrupt: missing toolCallId or toolName on interrupt");
+        }
+        // Build the assistant message with the original tool call
+        const customAssistantMessage = {
+            role: "assistant",
+            content: [
+                {
+                    type: "tool-call",
+                    toolCallId: customToolCallId,
+                    toolName: customToolName,
+                    input: interrupt.request,
+                },
+            ],
+        };
+        // Collect all tools
+        const customTools = collectAllTools();
+        const customTool = customTools[customToolName];
+        if (!customTool || !customTool.execute) {
+            throw new Error(`Cannot resume: tool "${customToolName}" not found or has no execute function`);
+        }
+        let customToolResult;
+        try {
+            // Execute the tool, providing an interrupt function that returns
+            // the stored user response. This mirrors what happens inside the
+            // permission-mode tool wrapper when pendingResponses has a match.
+            customToolResult = await customTool.execute(interrupt.request, {
+                toolCallId: customToolCallId,
+                messages: checkpoint.messages,
+                abortSignal: genOptions?.signal,
+                interrupt: async (request) => {
+                    // First call: return the stored user response (mirrors the
+                    // permission-mode wrapper when pendingResponses has a match).
+                    if (pendingResponses.has(interrupt.id)) {
+                        const stored = pendingResponses.get(interrupt.id);
+                        pendingResponses.delete(interrupt.id);
+                        return stored;
+                    }
+                    // Subsequent calls: no stored response — throw InterruptSignal
+                    // so the tool can pause again (e.g. multi-step wizards).
+                    const newInterruptData = createInterrupt({
+                        id: `int_${customToolCallId}`,
+                        threadId,
+                        type: "custom",
+                        toolCallId: customToolCallId,
+                        toolName: customToolName,
+                        request,
+                        step: checkpoint.step,
+                    });
+                    throw new InterruptSignal(newInterruptData);
+                },
+            });
+        }
+        catch (executeError) {
+            if (isInterruptSignal(executeError)) {
+                // Tool threw another interrupt — persist it and return re-interrupted
+                const newInterrupt = executeError.interrupt;
+                const reInterruptCheckpoint = updateCheckpoint(checkpoint, {
+                    pendingInterrupt: newInterrupt,
+                });
+                await options.checkpointer.save(reInterruptCheckpoint);
+                threadCheckpoints.set(threadId, reInterruptCheckpoint);
+                return {
+                    type: "re-interrupted",
+                    interrupt: newInterrupt,
+                    checkpoint: reInterruptCheckpoint,
+                };
+            }
+            customToolResult = `Tool execution failed: ${executeError instanceof Error ? executeError.message : String(executeError)}`;
+        }
+        // Build tool result message with proper ToolResultOutput format.
+        const customOutput = typeof customToolResult === "string"
+            ? { type: "text", value: customToolResult }
+            : { type: "json", value: customToolResult };
+        const customToolResultMessage = {
+            role: "tool",
+            content: [
+                {
+                    type: "tool-result",
+                    toolCallId: customToolCallId,
+                    toolName: customToolName,
+                    output: customOutput,
+                },
+            ],
+        };
+        // Update checkpoint with tool call + result, clear interrupt
+        const customUpdatedMessages = [
+            ...checkpoint.messages,
+            customAssistantMessage,
+            customToolResultMessage,
+        ];
+        const customUpdatedCheckpoint = updateCheckpoint(checkpoint, {
+            messages: customUpdatedMessages,
+            pendingInterrupt: undefined,
+            step: checkpoint.step + 1,
+        });
+        await options.checkpointer.save(customUpdatedCheckpoint);
+        threadCheckpoints.set(threadId, customUpdatedCheckpoint);
+        // Clean up
+        pendingResponses.delete(interrupt.id);
+        return { type: "continue", threadId, genOptions };
+    }
     const agent = {
         id,
         options,
@@ -1685,9 +1929,10 @@ export function createAgent(options) {
             const retryState = createRetryLoopState(options.model);
             while (retryState.retryAttempt <= retryState.maxRetries) {
                 try {
-                    const { messages, checkpoint } = await buildMessages(effectiveGenOptions);
+                    const { messages, checkpoint, forkedSessionId } = await buildMessages(effectiveGenOptions);
                     const maxSteps = options.maxSteps ?? 10;
                     const startStep = checkpoint?.step ?? 0;
+                    const checkpointThreadId = forkedSessionId ?? effectiveGenOptions.threadId;
                     // Signal state for cooperative signal catching in streaming mode
                     const signalState = {};
                     // Build initial params - use active tools (core + dynamically loaded + task)
@@ -1786,12 +2031,39 @@ export function createAgent(options) {
                         steps: mapSteps(steps),
                     };
                     // Save checkpoint if threadId is provided
-                    if (effectiveGenOptions.threadId && options.checkpointer) {
+                    if (checkpointThreadId && options.checkpointer) {
                         const finalMessages = [
                             ...messages,
                             ...(text ? [{ role: "assistant", content: text }] : []),
                         ];
-                        await saveCheckpoint(effectiveGenOptions.threadId, finalMessages, startStep + steps.length);
+                        await saveCheckpoint(checkpointThreadId, finalMessages, startStep + steps.length);
+                    }
+                    // Save pending interrupt to checkpoint (mirrors generate() pattern)
+                    if (signalState.interrupt && checkpointThreadId && options.checkpointer) {
+                        const interrupt = signalState.interrupt.interrupt;
+                        const savedCheckpoint = threadCheckpoints.get(checkpointThreadId);
+                        if (savedCheckpoint) {
+                            const withInterrupt = updateCheckpoint(savedCheckpoint, {
+                                pendingInterrupt: interrupt,
+                            });
+                            await options.checkpointer.save(withInterrupt);
+                            threadCheckpoints.set(checkpointThreadId, withInterrupt);
+                        }
+                        // Emit InterruptRequested hook
+                        const interruptRequestedHooks = effectiveHooks?.InterruptRequested ?? [];
+                        if (interruptRequestedHooks.length > 0) {
+                            const hookInput = {
+                                hook_event_name: "InterruptRequested",
+                                session_id: effectiveGenOptions.threadId ?? "default",
+                                cwd: process.cwd(),
+                                interrupt_id: interrupt.id,
+                                interrupt_type: interrupt.type,
+                                tool_call_id: interrupt.toolCallId,
+                                tool_name: interrupt.toolName,
+                                request: interrupt.request,
+                            };
+                            await invokeHooksWithTimeout(interruptRequestedHooks, hookInput, null, agent);
+                        }
                     }
                     // Invoke unified PostGenerate hooks
                     const postGenerateHooks = effectiveHooks?.PostGenerate ?? [];
@@ -2383,8 +2655,35 @@ export function createAgent(options) {
                             writer.merge(result.toUIMessageStream());
                             // Wait for initial generation to complete to get final text
                             const text = await result.text;
+                            // Save pending interrupt to checkpoint (mirrors stream() pattern)
+                            if (signalState.interrupt && effectiveGenOptions.threadId && options.checkpointer) {
+                                const interrupt = signalState.interrupt.interrupt;
+                                const savedCheckpoint = threadCheckpoints.get(effectiveGenOptions.threadId);
+                                if (savedCheckpoint) {
+                                    const withInterrupt = updateCheckpoint(savedCheckpoint, {
+                                        pendingInterrupt: interrupt,
+                                    });
+                                    await options.checkpointer.save(withInterrupt);
+                                    threadCheckpoints.set(effectiveGenOptions.threadId, withInterrupt);
+                                }
+                                // Emit InterruptRequested hook
+                                const interruptRequestedHooks = effectiveHooks?.InterruptRequested ?? [];
+                                if (interruptRequestedHooks.length > 0) {
+                                    const hookInput = {
+                                        hook_event_name: "InterruptRequested",
+                                        session_id: effectiveGenOptions.threadId ?? "default",
+                                        cwd: process.cwd(),
+                                        interrupt_id: interrupt.id,
+                                        interrupt_type: interrupt.type,
+                                        tool_call_id: interrupt.toolCallId,
+                                        tool_name: interrupt.toolName,
+                                        request: interrupt.request,
+                                    };
+                                    await invokeHooksWithTimeout(interruptRequestedHooks, hookInput, null, agent);
+                                }
+                            }
                             // --- Background task completion loop ---
-                            if (waitForBackgroundTasks) {
+                            if (waitForBackgroundTasks && !signalState.interrupt) {
                                 // Track accumulated steps for checkpoint saves
                                 const initialSteps = await result.steps;
                                 let accumulatedStepCount = initialSteps.length;
@@ -2509,251 +2808,33 @@ export function createAgent(options) {
             return checkpoint?.pendingInterrupt;
         },
         async resume(threadId, interruptId, response, genOptions) {
-            if (!options.checkpointer) {
-                throw new Error("Cannot resume: checkpointer is required");
-            }
-            const checkpoint = await options.checkpointer.load(threadId);
-            if (!checkpoint) {
-                throw new Error(`Cannot resume: no checkpoint found for thread ${threadId}`);
-            }
-            const interrupt = checkpoint.pendingInterrupt;
-            if (!interrupt) {
-                throw new Error(`Cannot resume: no pending interrupt found for thread ${threadId}`);
-            }
-            if (interrupt.id !== interruptId) {
-                throw new Error(`Cannot resume: interrupt ID mismatch. Expected ${interrupt.id}, got ${interruptId}`);
-            }
-            // Store the response keyed by interrupt ID (format: "int_<toolCallId>").
-            // The interrupt() function in the tool wrapper looks up responses using
-            // this exact key format, so we must use interrupt.id — NOT the raw
-            // toolCallId which would never match.
-            pendingResponses.set(interrupt.id, response);
-            // Emit InterruptResolved hook
-            const interruptResolvedHooks = effectiveHooks?.InterruptResolved ?? [];
-            if (interruptResolvedHooks.length > 0) {
-                const isApproval = isApprovalInterrupt(interrupt);
-                const approvalResponse = isApproval ? response : undefined;
-                const hookInput = {
-                    hook_event_name: "InterruptResolved",
-                    session_id: threadId,
-                    cwd: process.cwd(),
-                    interrupt_id: interrupt.id,
-                    interrupt_type: interrupt.type,
-                    tool_call_id: interrupt.toolCallId,
-                    tool_name: interrupt.toolName,
-                    response,
-                    approved: approvalResponse?.approved,
-                };
-                await invokeHooksWithTimeout(interruptResolvedHooks, hookInput, null, agent);
-            }
-            // Handle approval interrupt
-            if (isApprovalInterrupt(interrupt)) {
-                const approvalResponse = response;
-                // For backward compatibility, also store in approvalDecisions
-                approvalDecisions.set(interrupt.toolCallId, approvalResponse.approved);
-                // Build the assistant message with the tool call
-                const assistantMessage = {
-                    role: "assistant",
-                    content: [
-                        {
-                            type: "tool-call",
-                            toolCallId: interrupt.toolCallId,
-                            toolName: interrupt.toolName,
-                            input: interrupt.request.args,
-                        },
-                    ],
-                };
-                let toolResultOutput;
-                if (approvalResponse.approved) {
-                    // Approved: Execute the tool deterministically
-                    const unwrappedTools = { ...coreTools };
-                    for (const plugin of options.plugins ?? []) {
-                        if (plugin.tools && typeof plugin.tools !== "function") {
-                            Object.assign(unwrappedTools, plugin.tools);
-                        }
-                    }
-                    const mcpTools = mcpManager.getToolSet();
-                    Object.assign(unwrappedTools, mcpTools);
-                    const tool = unwrappedTools[interrupt.toolName];
-                    if (!tool || !tool.execute) {
-                        throw new Error(`Cannot resume: tool "${interrupt.toolName}" not found or has no execute function`);
-                    }
-                    try {
-                        toolResultOutput = await tool.execute(interrupt.request.args, {
-                            toolCallId: interrupt.toolCallId,
-                            messages: checkpoint.messages,
-                            abortSignal: genOptions?.signal,
-                        });
-                    }
-                    catch (error) {
-                        toolResultOutput = `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`;
-                    }
-                }
-                else {
-                    // Denied: Create a synthetic denial result
-                    toolResultOutput = `Tool "${interrupt.toolName}" was denied by user${approvalResponse.reason ? `: ${approvalResponse.reason}` : ""}`;
-                }
-                // Build the tool result message with proper ToolResultOutput format.
-                // The AI SDK validates messages against modelMessageSchema which
-                // requires output to be { type: 'text', value } or { type: 'json', value }.
-                const approvalOutput = typeof toolResultOutput === "string"
-                    ? { type: "text", value: toolResultOutput }
-                    : { type: "json", value: toolResultOutput };
-                const toolResultMessage = {
-                    role: "tool",
-                    content: [
-                        {
-                            type: "tool-result",
-                            toolCallId: interrupt.toolCallId,
-                            toolName: interrupt.toolName,
-                            output: approvalOutput,
-                        },
-                    ],
+            const outcome = await executeResumeCore(threadId, interruptId, response, genOptions);
+            if (outcome.type === "re-interrupted") {
+                return {
+                    status: "interrupted",
+                    interrupt: outcome.interrupt,
+                    partial: undefined,
                 };
-                // Update checkpoint with the tool call and result messages, clear interrupt
-                const updatedMessages = [
-                    ...checkpoint.messages,
-                    assistantMessage,
-                    toolResultMessage,
-                ];
-                const updatedCheckpoint = updateCheckpoint(checkpoint, {
-                    messages: updatedMessages,
-                    pendingInterrupt: undefined,
-                    step: checkpoint.step + 1,
-                });
-                await options.checkpointer.save(updatedCheckpoint);
-                // Clean up the response from our maps
-                pendingResponses.delete(interrupt.id);
-                approvalDecisions.delete(interrupt.toolCallId);
-                // Continue generation from the updated checkpoint
-                return agent.generate({
-                    threadId,
-                    ...genOptions,
-                    prompt: undefined,
-                });
             }
-            // For custom interrupts (e.g. ask_user), manually execute the tool so
-            // that its interrupt() call receives the stored response deterministically.
-            // Re-running generate() would rely on the model re-calling the same tool,
-            // but tool call IDs change each generation so pendingResponses would never
-            // be matched.
-            {
-                const customToolCallId = interrupt.toolCallId;
-                const customToolName = interrupt.toolName;
-                if (!customToolCallId || !customToolName) {
-                    throw new Error("Cannot resume custom interrupt: missing toolCallId or toolName on interrupt");
-                }
-                // Build the assistant message with the original tool call
-                const customAssistantMessage = {
-                    role: "assistant",
-                    content: [
-                        {
-                            type: "tool-call",
-                            toolCallId: customToolCallId,
-                            toolName: customToolName,
-                            input: interrupt.request,
-                        },
-                    ],
-                };
-                // Collect all tools (same pattern as the approval path above)
-                const customTools = { ...coreTools };
-                for (const plugin of options.plugins ?? []) {
-                    if (plugin.tools && typeof plugin.tools !== "function") {
-                        Object.assign(customTools, plugin.tools);
-                    }
-                }
-                const customMcpTools = mcpManager.getToolSet();
-                Object.assign(customTools, customMcpTools);
-                const customTool = customTools[customToolName];
-                if (!customTool || !customTool.execute) {
-                    throw new Error(`Cannot resume: tool "${customToolName}" not found or has no execute function`);
-                }
-                let customToolResult;
-                try {
-                    // Execute the tool, providing an interrupt function that returns
-                    // the stored user response. This mirrors what happens inside the
-                    // permission-mode tool wrapper when pendingResponses has a match.
-                    customToolResult = await customTool.execute(interrupt.request, {
-                        toolCallId: customToolCallId,
-                        messages: checkpoint.messages,
-                        abortSignal: genOptions?.signal,
-                        interrupt: async (request) => {
-                            // First call: return the stored user response (mirrors the
-                            // permission-mode wrapper when pendingResponses has a match).
-                            if (pendingResponses.has(interrupt.id)) {
-                                const stored = pendingResponses.get(interrupt.id);
-                                pendingResponses.delete(interrupt.id);
-                                return stored;
-                            }
-                            // Subsequent calls: no stored response — throw InterruptSignal
-                            // so the tool can pause again (e.g. multi-step wizards).
-                            const newInterruptData = createInterrupt({
-                                id: `int_${customToolCallId}`,
-                                threadId,
-                                type: "custom",
-                                toolCallId: customToolCallId,
-                                toolName: customToolName,
-                                request,
-                                step: checkpoint.step,
-                            });
-                            throw new InterruptSignal(newInterruptData);
-                        },
-                    });
-                }
-                catch (executeError) {
-                    if (isInterruptSignal(executeError)) {
-                        // Tool threw another interrupt — persist it and return interrupted
-                        const newInterrupt = executeError.interrupt;
-                        const reInterruptCheckpoint = updateCheckpoint(checkpoint, {
-                            pendingInterrupt: newInterrupt,
-                        });
-                        await options.checkpointer.save(reInterruptCheckpoint);
-                        threadCheckpoints.set(threadId, reInterruptCheckpoint);
-                        return {
-                            status: "interrupted",
-                            interrupt: newInterrupt,
-                            partial: undefined,
-                        };
-                    }
-                    customToolResult = `Tool execution failed: ${executeError instanceof Error ? executeError.message : String(executeError)}`;
-                }
-                // Build tool result message with proper ToolResultOutput format.
-                const customOutput = typeof customToolResult === "string"
-                    ? { type: "text", value: customToolResult }
-                    : { type: "json", value: customToolResult };
-                const customToolResultMessage = {
-                    role: "tool",
-                    content: [
-                        {
-                            type: "tool-result",
-                            toolCallId: customToolCallId,
-                            toolName: customToolName,
-                            output: customOutput,
-                        },
-                    ],
-                };
-                // Update checkpoint with tool call + result, clear interrupt
-                const customUpdatedMessages = [
-                    ...checkpoint.messages,
-                    customAssistantMessage,
-                    customToolResultMessage,
-                ];
-                const customUpdatedCheckpoint = updateCheckpoint(checkpoint, {
-                    messages: customUpdatedMessages,
-                    pendingInterrupt: undefined,
-                    step: checkpoint.step + 1,
-                });
-                await options.checkpointer.save(customUpdatedCheckpoint);
-                threadCheckpoints.set(threadId, customUpdatedCheckpoint);
-                // Clean up
-                pendingResponses.delete(interrupt.id);
-                // Continue generation from the updated checkpoint
-                return agent.generate({
-                    threadId,
-                    ...genOptions,
-                    prompt: undefined,
-                });
+            return agent.generate({
+                threadId: outcome.threadId,
+                ...outcome.genOptions,
+                prompt: undefined,
+            });
+        },
+        async resumeDataResponse(threadId, interruptId, response, genOptions) {
+            const outcome = await executeResumeCore(threadId, interruptId, response, genOptions);
+            if (outcome.type === "re-interrupted") {
+                // Return an empty response — the client already has the interrupt widget.
+                // The new interrupt is persisted to the checkpoint and retrievable
+                // via getInterrupt().
+                return new Response(null, { status: 204 });
             }
+            return agent.streamDataResponse({
+                threadId: outcome.threadId,
+                ...outcome.genOptions,
+                prompt: undefined,
+            });
         },
         async dispose() {
             // Kill all running background tasks