@pikku/core 0.12.0 → 0.12.1

package/dist/wirings/ai-agent/ai-agent-runner.js

@@ -1,9 +1,11 @@
 import { saveMessages } from './ai-agent-memory.js';
 import { prepareAgentRun } from './ai-agent-prepare.js';
+import { getSingletonServices } from '../../pikku-state.js';
+import { randomUUID } from 'crypto';
 export async function runAIAgent(agentName, input, params, agentSessionMap) {
     const sessionMap = agentSessionMap ?? new Map();
-    const { agent, agentRunner, storage, memoryConfig, threadId, userMessage, runnerParams, missingRpcs, workingMemoryJsonSchema, workingMemorySchemaName, } = await prepareAgentRun(agentName, input, params, sessionMap);
-    const { singletonServices } = params;
+    const { agent, agentRunner, storage, memoryConfig, threadId, userMessage, runnerParams, maxSteps, missingRpcs, workingMemoryJsonSchema, workingMemorySchemaName, } = await prepareAgentRun(agentName, input, params, sessionMap);
+    const singletonServices = getSingletonServices();
     const { aiRunState } = singletonServices;
     if (!aiRunState) {
         throw new Error('AIRunStateService not available in singletonServices');
@@ -53,7 +55,90 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
         updatedAt: new Date(),
     });
     try {
-        const result = await agentRunner.run(runnerParams);
+        const accumulatedSteps = [];
+        const totalUsage = { inputTokens: 0, outputTokens: 0 };
+        let lastStepResult = null;
+        for (let step = 0; step < maxSteps; step++) {
+            if (agent.prepareStep) {
+                let stopped = false;
+                await agent.prepareStep({
+                    stepNumber: step,
+                    messages: runnerParams.messages,
+                    tools: runnerParams.tools,
+                    toolChoice: runnerParams.toolChoice,
+                    model: runnerParams.model,
+                    stop: () => {
+                        stopped = true;
+                    },
+                });
+                if (stopped)
+                    break;
+            }
+            const stepResult = await agentRunner.run(runnerParams);
+            lastStepResult = stepResult;
+            totalUsage.inputTokens += stepResult.usage.inputTokens;
+            totalUsage.outputTokens += stepResult.usage.outputTokens;
+            for (const mw of aiMiddlewares) {
+                if (mw.afterStep) {
+                    await mw.afterStep(singletonServices, {
+                        stepNumber: step,
+                        text: stepResult.text,
+                        toolCalls: stepResult.toolCalls,
+                        toolResults: stepResult.toolResults,
+                        usage: stepResult.usage,
+                        finishReason: stepResult.finishReason,
+                    });
+                }
+            }
+            accumulatedSteps.push({
+                usage: stepResult.usage,
+                toolCalls: stepResult.toolCalls.map((tc) => {
+                    const tr = stepResult.toolResults.find((r) => r.toolCallId === tc.toolCallId);
+                    return {
+                        name: tc.toolName,
+                        args: tc.args,
+                        result: typeof tr?.result === 'string'
+                            ? tr.result
+                            : JSON.stringify(tr?.result ?? ''),
+                    };
+                }),
+            });
+            if (stepResult.toolCalls.length === 0)
+                break;
+            const assistantMsg = {
+                id: randomUUID(),
+                role: 'assistant',
+                content: stepResult.text || undefined,
+                toolCalls: stepResult.toolCalls.map((tc) => ({
+                    id: tc.toolCallId,
+                    name: tc.toolName,
+                    args: tc.args,
+                })),
+                createdAt: new Date(),
+            };
+            runnerParams.messages.push(assistantMsg);
+            if (stepResult.toolResults.length > 0) {
+                const toolMsg = {
+                    id: randomUUID(),
+                    role: 'tool',
+                    toolResults: stepResult.toolResults.map((tr) => ({
+                        id: tr.toolCallId,
+                        name: tr.toolName,
+                        result: typeof tr.result === 'string'
+                            ? tr.result
+                            : JSON.stringify(tr.result),
+                    })),
+                    createdAt: new Date(),
+                };
+                runnerParams.messages.push(toolMsg);
+            }
+        }
+        const finalText = lastStepResult?.text ?? '';
+        const finalObject = lastStepResult?.object;
+        const result = {
+            text: finalText,
+            steps: accumulatedSteps,
+        };
         const responseText = await saveMessages(storage, threadId, input.resourceId, memoryConfig, userMessage, result, {
             workingMemoryJsonSchema,
             workingMemorySchemaName,
@@ -68,7 +153,7 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
                 const modResult = await mw.modifyOutput(singletonServices, {
                     text: outputText,
                     messages: outputMessages,
-                    usage: result.usage,
+                    usage: totalUsage,
                 });
                 outputText = modResult.text;
                 outputMessages = modResult.messages;
@@ -76,18 +161,32 @@ export async function runAIAgent(agentName, input, params, agentSessionMap) {
         }
         await aiRunState.updateRun(runId, {
             status: 'completed',
-            usage: { ...result.usage, model: agent.model },
+            usage: { ...totalUsage, model: agent.model },
         });
         return {
             runId,
             text: outputText,
-            object: result.object,
+            object: finalObject,
             threadId,
-            steps: result.steps,
-            usage: result.usage,
+            steps: accumulatedSteps,
+            usage: totalUsage,
         };
     }
     catch (error) {
+        for (const mw of aiMiddlewares) {
+            if (mw.onError) {
+                try {
+                    await mw.onError(singletonServices, {
+                        error: error instanceof Error ? error : new Error(String(error)),
+                        stepNumber: -1,
+                        messages: runnerParams.messages,
+                    });
+                }
+                catch {
+                    // onError hooks must not affect error flow
+                }
+            }
+        }
         await aiRunState.updateRun(runId, {
             status: 'failed',
         });

package/dist/wirings/ai-agent/ai-agent-stream.d.ts

@@ -4,8 +4,9 @@ export declare function streamAIAgent(agentName: string, input: {
     message: string;
     threadId: string;
     resourceId: string;
-}, channel: AIStreamChannel, params: RunAIAgentParams, agentSessionMap?: Map<string, string>, options?: StreamAIAgentOptions): Promise<void>;
+} | Record<string, unknown>, channel: AIStreamChannel, params: RunAIAgentParams, agentSessionMap?: Map<string, string>, options?: StreamAIAgentOptions): Promise<void>;
 export declare function resumeAIAgent(input: {
+    runId: string;
     toolCallId: string;
     approved: boolean;
 }, channel: AIStreamChannel, params: RunAIAgentParams, options?: StreamAIAgentOptions): Promise<void>;

package/dist/wirings/ai-agent/ai-agent-stream.js

@@ -1,14 +1,19 @@
-import { pikkuState } from '../../pikku-state.js';
+import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { combineChannelMiddleware, wrapChannelWithMiddleware, } from '../channel/channel-middleware-runner.js';
 import { randomUUID } from 'crypto';
 import { parseWorkingMemory, deepMergeWorkingMemory, resolveMemoryServices, loadContextMessages, trimMessages, } from './ai-agent-memory.js';
 import { prepareAgentRun, resolveAgent, buildInstructions, buildToolDefs, createScopedChannel, ToolApprovalRequired, } from './ai-agent-prepare.js';
+import { createAssistantUIChannel, parseAssistantUIInput, } from './ai-agent-assistant-ui.js';
 import { resolveModelConfig } from './ai-agent-model-config.js';
 function createPersistingChannel(parent, storage, threadId) {
     let fullText = '';
     let stepText = '';
     let stepToolCalls = [];
     let stepToolResults = [];
+    const totalUsage = {
+        inputTokens: 0,
+        outputTokens: 0,
+    };
     const flushStep = async () => {
         if (!storage)
             return;
@@ -47,6 +52,9 @@ function createPersistingChannel(parent, storage, threadId) {
         get fullText() {
             return fullText;
         },
+        get totalUsage() {
+            return totalUsage;
+        },
         flush: flushStep,
         close: () => parent.close(),
         send: (event) => {
@@ -73,6 +81,10 @@ function createPersistingChannel(parent, storage, threadId) {
                         });
                         break;
                     case 'usage':
+                        totalUsage.inputTokens += event.tokens.input;
+                        totalUsage.outputTokens += event.tokens.output;
+                        if (event.model)
+                            totalUsage.model = event.model;
                         flushStep();
                         break;
                     case 'done':
@@ -86,6 +98,7 @@ function createPersistingChannel(parent, storage, threadId) {
     return channel;
 }
 async function postStreamCleanup(persistingChannel, aiMiddlewares, singletonServices, storage, memoryConfig, threadId, workingMemorySchemaName, messages, aiRunState, runId) {
+    const usage = persistingChannel.totalUsage;
     let outputText = persistingChannel.fullText;
     let outputMessages = messages;
     for (let i = aiMiddlewares.length - 1; i >= 0; i--) {
@@ -94,7 +107,10 @@ async function postStreamCleanup(persistingChannel, aiMiddlewares, singletonServ
             const result = await mw.modifyOutput(singletonServices, {
                 text: outputText,
                 messages: outputMessages,
-                usage: { inputTokens: 0, outputTokens: 0 },
+                usage: {
+                    inputTokens: usage.inputTokens,
+                    outputTokens: usage.outputTokens,
+                },
             });
             outputText = result.text;
             outputMessages = result.messages;
@@ -116,13 +132,160 @@ async function postStreamCleanup(persistingChannel, aiMiddlewares, singletonServ
             await storage.saveWorkingMemory(threadId, 'thread', merged);
         }
     }
-    await aiRunState.updateRun(runId, { status: 'completed' });
+    await aiRunState.updateRun(runId, {
+        status: 'completed',
+        ...(usage.model
+            ? {
+                usage: {
+                    inputTokens: usage.inputTokens,
+                    outputTokens: usage.outputTokens,
+                    model: usage.model,
+                },
+            }
+            : {}),
+    });
+}
+async function runStreamStepLoop(params) {
+    const { agent, runnerParams, maxSteps, agentRunner, persistingChannel, channel, runId, aiMiddlewares, } = params;
+    const singletonServices = getSingletonServices();
+    for (let step = 0; step < maxSteps; step++) {
+        if (agent.prepareStep) {
+            let stopped = false;
+            await agent.prepareStep({
+                stepNumber: step,
+                messages: runnerParams.messages,
+                tools: runnerParams.tools,
+                toolChoice: runnerParams.toolChoice,
+                model: runnerParams.model,
+                stop: () => {
+                    stopped = true;
+                },
+            });
+            if (stopped)
+                break;
+        }
+        channel.send({ type: 'step-start', stepNumber: step });
+        const stepResult = await agentRunner.stream(runnerParams, persistingChannel);
+        for (const mw of aiMiddlewares) {
+            if (mw.afterStep) {
+                await mw.afterStep(singletonServices, {
+                    stepNumber: step,
+                    text: stepResult.text,
+                    toolCalls: stepResult.toolCalls,
+                    toolResults: stepResult.toolResults,
+                    usage: stepResult.usage,
+                    finishReason: stepResult.finishReason,
+                });
+            }
+        }
+        if (stepResult.toolCalls.length === 0)
+            break;
+        const approvalNeeded = checkForApproval(stepResult, runnerParams.tools, runId);
+        if (approvalNeeded) {
+            return { outcome: 'approval', approval: approvalNeeded };
+        }
+        appendStepMessages(runnerParams, stepResult);
+    }
+    return { outcome: 'done' };
+}
+function checkForApproval(stepResult, tools, runId) {
+    for (const tc of stepResult.toolCalls) {
+        const toolDef = tools.find((t) => t.name === tc.toolName);
+        if (toolDef?.needsApproval) {
+            return new ToolApprovalRequired(tc.toolCallId, tc.toolName, tc.args);
+        }
+        const tr = stepResult.toolResults.find((r) => r.toolCallId === tc.toolCallId);
+        if (tr?.result &&
+            typeof tr.result === 'object' &&
+            '__approvalRequired' in tr.result) {
+            const r = tr.result;
+            return new ToolApprovalRequired(tc.toolCallId, r.toolName, r.args, r.reason, r.displayToolName, r.displayArgs, r.agentRunId);
+        }
+    }
+    return null;
+}
+function appendStepMessages(runnerParams, stepResult) {
+    const assistantMsg = {
+        id: randomUUID(),
+        role: 'assistant',
+        content: stepResult.text || undefined,
+        toolCalls: stepResult.toolCalls.length > 0
+            ? stepResult.toolCalls.map((tc) => ({
+                id: tc.toolCallId,
+                name: tc.toolName,
+                args: tc.args,
+            }))
+            : undefined,
+        createdAt: new Date(),
+    };
+    runnerParams.messages.push(assistantMsg);
+    if (stepResult.toolResults.length > 0) {
+        const toolMsg = {
+            id: randomUUID(),
+            role: 'tool',
+            toolResults: stepResult.toolResults.map((tr) => ({
+                id: tr.toolCallId,
+                name: tr.toolName,
+                result: typeof tr.result === 'string' ? tr.result : JSON.stringify(tr.result),
+            })),
+            createdAt: new Date(),
+        };
+        runnerParams.messages.push(toolMsg);
+    }
+}
+function handleApproval(err, runId, channel, aiRunState, persistingChannel) {
+    return (async () => {
+        await persistingChannel.flush();
+        const pendingApproval = err.agentRunId
+            ? {
+                type: 'agent-call',
+                toolCallId: err.toolCallId,
+                agentName: err.toolName,
+                agentRunId: err.agentRunId,
+                displayToolName: err.displayToolName ?? err.toolName,
+                displayArgs: err.displayArgs ?? err.args,
+            }
+            : {
+                type: 'tool-call',
+                toolCallId: err.toolCallId,
+                toolName: err.toolName,
+                args: err.args,
+            };
+        await aiRunState.updateRun(runId, {
+            status: 'suspended',
+            suspendReason: 'approval',
+            pendingApprovals: [pendingApproval],
+        });
+        const approvalEvent = {
+            type: 'approval-request',
+            toolCallId: err.toolCallId,
+            toolName: err.displayToolName ?? err.toolName,
+            args: err.displayArgs ?? err.args,
+            reason: err.reason,
+            runId,
+        };
+        channel.send(approvalEvent);
+        channel.send({ type: 'done' });
+        channel.close();
+    })();
 }
 export async function streamAIAgent(agentName, input, channel, params, agentSessionMap, options) {
     const sessionMap = agentSessionMap ?? new Map();
+    const { agent: resolvedAgentForProtocol } = resolveAgent(agentName);
+    const inputRecord = input;
+    const useUIMessageStream = resolvedAgentForProtocol.protocol === 'ui-message-stream' ||
+        Array.isArray(inputRecord.messages);
+    let normalizedInput;
+    if (useUIMessageStream) {
+        normalizedInput = parseAssistantUIInput(inputRecord);
+        channel = createAssistantUIChannel(channel);
+    }
+    else {
+        normalizedInput = input;
+    }
     const streamContext = { channel, options };
-    const { agent, packageName, resolvedName, agentRunner, storage, memoryConfig, threadId, userMessage, runnerParams, missingRpcs, workingMemorySchemaName, } = await prepareAgentRun(agentName, input, params, sessionMap, streamContext);
-    const { singletonServices } = params;
+    const { agent, packageName, resolvedName, agentRunner, storage, memoryConfig, threadId, userMessage, runnerParams, maxSteps, missingRpcs, workingMemorySchemaName, } = await prepareAgentRun(agentName, normalizedInput, params, sessionMap, streamContext);
+    const singletonServices = getSingletonServices();
     const { aiRunState } = singletonServices;
     if (!aiRunState) {
         throw new Error('AIRunStateService not available in singletonServices');
@@ -131,7 +294,7 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
         await aiRunState.createRun({
             agentName,
             threadId,
-            resourceId: input.resourceId,
+            resourceId: normalizedInput.resourceId,
             status: 'suspended',
             suspendReason: 'rpc-missing',
             missingRpcs,
@@ -161,7 +324,7 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
     const runId = await aiRunState.createRun({
         agentName,
         threadId,
-        resourceId: input.resourceId,
+        resourceId: normalizedInput.resourceId,
         status: 'running',
         usage: { inputTokens: 0, outputTokens: 0, model: agent.model },
         createdAt: new Date(),
@@ -200,44 +363,38 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
         : channel;
     const persistingChannel = createPersistingChannel(wrappedChannel, storage, threadId);
     try {
-        await agentRunner.stream(runnerParams, persistingChannel);
+        const loopResult = await runStreamStepLoop({
+            agent,
+            runnerParams,
+            maxSteps,
+            agentRunner,
+            persistingChannel,
+            channel,
+            runId,
+            aiMiddlewares,
+        });
+        if (loopResult.outcome === 'approval') {
+            await handleApproval(loopResult.approval, runId, channel, aiRunState, persistingChannel);
+            return;
+        }
         await postStreamCleanup(persistingChannel, aiMiddlewares, singletonServices, storage, memoryConfig, threadId, workingMemorySchemaName, runnerParams.messages, aiRunState, runId);
+        channel.send({ type: 'done' });
+        channel.close();
     }
     catch (err) {
-        if (err instanceof ToolApprovalRequired) {
-            await persistingChannel.flush();
-            const pendingApproval = err.agentRunId
-                ? {
-                    type: 'agent-call',
-                    toolCallId: err.toolCallId,
-                    agentName: err.toolName,
-                    agentRunId: err.agentRunId,
-                    displayToolName: err.displayToolName ?? err.toolName,
-                    displayArgs: err.displayArgs ?? err.args,
+        for (const mw of aiMiddlewares) {
+            if (mw.onError) {
+                try {
+                    await mw.onError(singletonServices, {
+                        error: err instanceof Error ? err : new Error(String(err)),
+                        stepNumber: -1,
+                        messages: runnerParams.messages,
+                    });
                 }
-                : {
-                    type: 'tool-call',
-                    toolCallId: err.toolCallId,
-                    toolName: err.toolName,
-                    args: err.args,
-                };
-            await aiRunState.updateRun(runId, {
-                status: 'suspended',
-                suspendReason: 'approval',
-                pendingApprovals: [pendingApproval],
-            });
-            const approvalEvent = {
-                type: 'approval-request',
-                toolCallId: err.toolCallId,
-                toolName: err.displayToolName ?? err.toolName,
-                args: err.displayArgs ?? err.args,
-                reason: err.reason,
-                runId,
-            };
-            channel.send(approvalEvent);
-            channel.send({ type: 'done' });
-            channel.close();
-            return;
+                catch {
+                    // onError hooks must not affect error flow
+                }
+            }
         }
         await aiRunState.updateRun(runId, { status: 'failed' });
         channel.send({
@@ -249,16 +406,19 @@ export async function streamAIAgent(agentName, input, channel, params, agentSess
     }
 }
 export async function resumeAIAgent(input, channel, params, options) {
-    const { singletonServices } = params;
+    const singletonServices = getSingletonServices();
     const { aiRunState } = singletonServices;
     if (!aiRunState) {
         throw new Error('AIRunStateService not available in singletonServices');
     }
-    const found = await aiRunState.findRunByToolCallId(input.toolCallId);
-    if (!found) {
-        throw new Error(`No suspended run found for toolCallId ${input.toolCallId}`);
+    const run = await aiRunState.getRun(input.runId);
+    if (!run) {
+        throw new Error(`No run found for runId ${input.runId}`);
+    }
+    const pending = run.pendingApprovals?.find((p) => p.toolCallId === input.toolCallId);
+    if (!pending) {
+        throw new Error(`No pending approval for toolCallId ${input.toolCallId} on run ${input.runId}`);
     }
-    const { run, approval: pending } = found;
     await aiRunState.resolveApproval(input.toolCallId, input.approved ? 'approved' : 'denied');
     const { agent, packageName, resolvedName } = resolveAgent(run.agentName);
     const { storage } = resolveMemoryServices(agent, singletonServices);
@@ -310,7 +470,11 @@ export async function resumeAIAgent(input, channel, params, options) {
             session: 'resume',
             input: null,
         });
-        await resumeAIAgent({ toolCallId: subPending.toolCallId, approved: true }, subChannel, params, options);
+        await resumeAIAgent({
+            runId: pending.agentRunId,
+            toolCallId: subPending.toolCallId,
+            approved: true,
+        }, subChannel, params, options);
         channel.send({
             type: 'agent-result',
             agentName: subRun.agentName,
@@ -339,16 +503,16 @@ export async function resumeAIAgent(input, channel, params, options) {
             channel,
             options: { ...options, requiresToolApproval: false },
         };
-        const { tools } = buildToolDefs(singletonServices, params, new Map(), run.resourceId, resolvedName, packageName, streamContext);
+        const aiMiddlewaresForResume = agent.aiMiddleware ?? [];
+        const { tools } = buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, aiMiddlewaresForResume);
         const matchingTool = tools.find((t) => t.name === pending.toolName);
         if (!matchingTool) {
             throw new Error(`Tool "${pending.toolName}" not found in agent definition`);
         }
         const toolArgs = typeof pending.args === 'string' ? JSON.parse(pending.args) : pending.args;
-        const { toolApprovalReason: _ignored, ...cleanArgs } = toolArgs;
         let toolResult;
         try {
-            toolResult = await matchingTool.execute(cleanArgs);
+            toolResult = await matchingTool.execute(toolArgs);
         }
         catch (execErr) {
             toolResult = `Error: ${execErr instanceof Error ? execErr.message : String(execErr)}`;
@@ -381,7 +545,7 @@ export async function resumeAIAgent(input, channel, params, options) {
     await continueAfterToolResult(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, channel, params, aiRunState, options);
 }
 async function continueAfterToolResult(run, agent, packageName, resolvedName, storage, memoryConfig, agentRunner, channel, params, aiRunState, options) {
-    const { singletonServices } = params;
+    const singletonServices = getSingletonServices();
     const agentsMeta = pikkuState(packageName, 'agent', 'agentsMeta');
     const meta = agentsMeta[resolvedName];
     const workingMemorySchemaName = meta?.workingMemorySchema ?? null;
@@ -438,59 +602,54 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
         : channel;
     const persistingChannel = createPersistingChannel(wrappedChannel, storage, run.threadId);
     const streamContext = { channel, options };
-    const resumeTools = buildToolDefs(singletonServices, params, new Map(), run.resourceId, resolvedName, packageName, streamContext).tools;
+    const resumeTools = buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, aiMiddlewares).tools;
     const resolved = resolveModelConfig(resolvedName, agent);
+    const maxSteps = resolved.maxSteps ?? 10;
     const runnerParams = {
         model: resolved.model,
         temperature: resolved.temperature,
         instructions: modifiedInstructions,
         messages: modifiedMessages,
         tools: resumeTools,
-        maxSteps: resolved.maxSteps ?? 10,
+        maxSteps: 1,
         toolChoice: (agent.toolChoice ?? 'auto'),
         outputSchema: meta?.outputSchema
             ? pikkuState(packageName, 'misc', 'schemas').get(meta.outputSchema)
             : undefined,
     };
     try {
-        await agentRunner.stream(runnerParams, persistingChannel);
+        const loopResult = await runStreamStepLoop({
+            agent,
+            runnerParams,
+            maxSteps,
+            agentRunner,
+            persistingChannel,
+            channel,
+            runId: run.runId,
+            aiMiddlewares,
+        });
+        if (loopResult.outcome === 'approval') {
+            await handleApproval(loopResult.approval, run.runId, channel, aiRunState, persistingChannel);
+            return;
+        }
         await postStreamCleanup(persistingChannel, aiMiddlewares, singletonServices, storage, memoryConfig, run.threadId, workingMemorySchemaName, runnerParams.messages, aiRunState, run.runId);
+        channel.send({ type: 'done' });
+        channel.close();
     }
     catch (err) {
-        if (err instanceof ToolApprovalRequired) {
-            await persistingChannel.flush();
-            const pendingApproval = err.agentRunId
-                ? {
-                    type: 'agent-call',
-                    toolCallId: err.toolCallId,
-                    agentName: err.toolName,
-                    agentRunId: err.agentRunId,
-                    displayToolName: err.displayToolName ?? err.toolName,
-                    displayArgs: err.displayArgs ?? err.args,
+        for (const mw of aiMiddlewares) {
+            if (mw.onError) {
+                try {
+                    await mw.onError(singletonServices, {
+                        error: err instanceof Error ? err : new Error(String(err)),
+                        stepNumber: -1,
+                        messages: runnerParams.messages,
+                    });
                 }
-                : {
-                    type: 'tool-call',
-                    toolCallId: err.toolCallId,
-                    toolName: err.toolName,
-                    args: err.args,
-                };
-            await aiRunState.updateRun(run.runId, {
-                status: 'suspended',
-                suspendReason: 'approval',
-                pendingApprovals: [pendingApproval],
-            });
-            const approvalEvent = {
-                type: 'approval-request',
-                toolCallId: err.toolCallId,
-                toolName: err.displayToolName ?? err.toolName,
-                args: err.displayArgs ?? err.args,
-                reason: err.reason,
-                runId: run.runId,
-            };
-            channel.send(approvalEvent);
-            channel.send({ type: 'done' });
-            channel.close();
-            return;
+                catch {
+                    // onError hooks must not affect error flow
+                }
+            }
         }
         await aiRunState.updateRun(run.runId, { status: 'failed' });
         channel.send({