@n8n/agents 0.10.1 → 0.12.0

package/dist/runtime/agent-runtime.js

@@ -6,6 +6,7 @@ const catalog_1 = require("../sdk/catalog");
 const message_1 = require("../sdk/message");
 const background_task_tracker_1 = require("./background-task-tracker");
 const deferred_tool_manager_1 = require("./deferred-tool-manager");
+const delegate_sub_agent_tool_1 = require("./delegate-sub-agent-tool");
 const episodic_memory_1 = require("./episodic-memory");
 const event_bus_1 = require("./event-bus");
 const execution_counter_1 = require("./execution-counter");
@@ -26,9 +27,12 @@ const runtime_helpers_1 = require("./runtime-helpers");
 const scoped_memory_task_runner_1 = require("./scoped-memory-task-runner");
 const stream_1 = require("./stream");
 const strip_orphaned_tool_messages_1 = require("./strip-orphaned-tool-messages");
+const sub_agent_task_path_1 = require("./sub-agent-task-path");
 const title_generation_1 = require("./title-generation");
 const tool_adapter_1 = require("./tool-adapter");
+const cancellation_1 = require("../sdk/cancellation");
 const telemetry_1 = require("../sdk/telemetry");
+const json_schema_1 = require("../utils/json-schema");
 const parse_1 = require("../utils/parse");
 const zod_1 = require("../utils/zod");
 function isActiveSpanTracer(value) {
@@ -56,9 +60,7 @@ function summarizeToolForTelemetry(tool) {
         description: tool.description,
         type: tool.mcpTool ? 'mcp' : 'local',
         ...(tool.mcpServerName ? { mcp_server: tool.mcpServerName } : {}),
-        ...(tool.suspendSchema || tool.resumeSchema || tool.withDefaultApproval
-            ? { approval: true }
-            : {}),
+        ...(tool.suspendSchema || tool.resumeSchema || tool.approval ? { approval: true } : {}),
         ...(tool.inputSchema ? { input_schema: getToolInputSchema(tool) } : {}),
     };
 }
@@ -72,6 +74,23 @@ function summarizeProviderToolForTelemetry(tool) {
         ...(tool.inputSchema ? { input_schema: getToolInputSchema(tool) } : {}),
     };
 }
+function isDeniedApprovalResumeData(value) {
+    return value !== null && typeof value === 'object' && Reflect.get(value, 'approved') === false;
+}
+function shouldEmitToolExecutionStart(tool, resumeData) {
+    if (!tool.approval)
+        return true;
+    if (!tool.approval.required && tool.approval.conditional !== true)
+        return true;
+    if (resumeData === undefined)
+        return false;
+    return !isDeniedApprovalResumeData(resumeData);
+}
+function getToolResumeJsonSchema(tool) {
+    if (!tool.resumeSchema)
+        return undefined;
+    return (0, zod_1.isZodSchema)(tool.resumeSchema) ? (0, zod_to_json_schema_1.zodToJsonSchema)(tool.resumeSchema) : tool.resumeSchema;
+}
 function buildAgentRootInputAttributes(config) {
     const localTools = (config.tools ?? []).map(summarizeToolForTelemetry);
     const providerTools = (config.providerTools ?? []).map(summarizeProviderToolForTelemetry);
@@ -115,11 +134,13 @@ class AgentRuntime {
         this.backgroundTasks = new background_task_tracker_1.BackgroundTaskTracker();
         this.episodicMemoryTasksByResource = new Map();
         this.config = config;
+        this.runId = config.runId ?? (0, run_state_1.generateRunId)();
         if (config.deferredTools && config.deferredTools.length > 0) {
             this.deferredToolManager = new deferred_tool_manager_1.DeferredToolManager(config.deferredTools, config.toolSearch);
         }
-        this.runState = new run_state_1.RunStateManager(config.checkpointStorage);
+        this.runState = config.runState ?? new run_state_1.RunStateManager(config.checkpointStorage);
         this.eventBus = config.eventBus ?? new event_bus_1.AgentEventBus();
+        this.modelCost = config.modelCost;
         this.currentState = {
             persistence: undefined,
             status: 'idle',
@@ -131,6 +152,7 @@ class AgentRuntime {
         this.config.telemetry = telemetry;
     }
     async dispose() {
+        this.eventBus.dispose();
         await this.backgroundTasks.flush();
     }
     getState() {
@@ -140,44 +162,59 @@ class AgentRuntime {
         this.eventBus.abort();
     }
     async generate(input, options) {
-        const runId = (0, run_state_1.generateRunId)();
+        const abortScope = this.eventBus.createAbortScope(options?.abortSignal);
         let list = undefined;
         try {
             const initializedList = await this.initRun(input, options);
             list = initializedList;
-            const rawResult = await this.withTelemetryRootSpan('generate', options, runId, async () => await this.runGenerateLoop({ list: initializedList, options, runId }));
-            return this.finalizeGenerate(rawResult, list, runId);
+            const rawResult = await this.withTelemetryRootSpan('generate', options, this.runId, async () => await this.runGenerateLoop({ list: initializedList, options, abortScope }));
+            return this.finalizeGenerate(rawResult, list);
         }
         catch (error) {
             await this.flushTelemetry(options);
-            const isAbort = this.eventBus.isAborted;
+            const isAbort = abortScope.isAborted;
             this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
             if (!isAbort) {
                 this.eventBus.emit({ type: "error", message: String(error), error });
             }
-            return { runId, messages: list?.responseDelta() ?? [], finishReason: 'error', error };
+            return {
+                runId: this.runId,
+                messages: list?.responseDelta() ?? [],
+                finishReason: 'error',
+                error,
+                getState: () => this.getState(),
+            };
+        }
+        finally {
+            abortScope.dispose();
         }
     }
     async stream(input, options) {
-        const runId = (0, run_state_1.generateRunId)();
+        const abortScope = this.eventBus.createAbortScope(options?.abortSignal);
         let list;
         try {
             list = await this.initRun(input, options);
         }
         catch (error) {
-            const isAbort = this.eventBus.isAborted;
+            const isAbort = abortScope.isAborted;
             this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
             if (!isAbort) {
                 this.eventBus.emit({ type: "error", message: String(error), error });
             }
-            return { runId, stream: (0, runtime_helpers_1.makeErrorStream)(error) };
+            abortScope.dispose();
+            return { runId: this.runId, stream: (0, runtime_helpers_1.makeErrorStream)(error), getState: () => this.getState() };
         }
-        return { runId, stream: this.startStreamLoop({ list, options, runId }) };
+        return {
+            runId: this.runId,
+            stream: this.startStreamLoop({ list, options, abortScope }),
+            getState: () => this.getState(),
+        };
     }
     async resume(method, data, options) {
-        const state = await this.runState.resume(options.runId);
+        this.runId = options.runId;
+        const state = await this.runState.resume(this.runId);
         if (!state)
-            throw new Error(`No suspended run found for runId: ${options.runId}`);
+            throw new Error(`No suspended run found for runId: ${this.runId}`);
         const toolCall = state.pendingToolCalls[options.toolCallId];
         if (!toolCall)
             throw new Error(`No tool call found for toolCallId: ${options.toolCallId}`);
@@ -187,7 +224,8 @@ class AgentRuntime {
         if (!toolForValidation)
             throw new Error(`Tool ${toolCall.toolName} not found`);
         let resumeData = data;
-        if (toolForValidation.resumeSchema) {
+        let abortScope;
+        if (!(0, cancellation_1.isCancellation)(resumeData) && toolForValidation.resumeSchema) {
             const parseResult = await (0, parse_1.parseWithSchema)(toolForValidation.resumeSchema, data);
             if (!parseResult.success) {
                 throw new Error(`Invalid resume payload: ${parseResult.error}`);
@@ -217,7 +255,8 @@ class AgentRuntime {
                 persistence: state.persistence,
                 ...mergedExecOptions,
             };
-            this.eventBus.resetAbort(resumeOptions.abortSignal);
+            abortScope = this.eventBus.createAbortScope(resumeOptions.abortSignal);
+            const activeAbortScope = abortScope;
             const pendingResume = {
                 pendingToolCalls: state.pendingToolCalls,
                 resumeToolCallId: options.toolCallId,
@@ -227,42 +266,50 @@ class AgentRuntime {
             await this.ensureModelCost();
             await this.setListObservationLogMemory(list, state.persistence);
             if (method === 'generate') {
-                const rawResult = await this.withTelemetryRootSpan('generate', resumeOptions, options.runId, async () => await this.runGenerateLoop({
+                const rawResult = await this.withTelemetryRootSpan('generate', resumeOptions, this.runId, async () => await this.runGenerateLoop({
                     list,
                     options: resumeOptions,
-                    runId: options.runId,
+                    abortScope: activeAbortScope,
                     pendingResume,
                 }));
                 if (!rawResult.pendingSuspend) {
-                    await this.cleanupRun(options.runId);
+                    await this.cleanupRun();
+                }
+                try {
+                    return this.finalizeGenerate(rawResult, list);
+                }
+                finally {
+                    abortScope.dispose();
                 }
-                return this.finalizeGenerate(rawResult, list, options.runId);
             }
             return {
-                runId: options.runId,
+                runId: this.runId,
                 stream: this.startStreamLoop({
                     list,
                     options: resumeOptions,
-                    runId: options.runId,
+                    abortScope: activeAbortScope,
                     pendingResume,
                 }),
+                getState: () => this.getState(),
             };
         }
         catch (error) {
-            const isAbort = this.eventBus.isAborted;
+            const isAbort = abortScope?.isAborted ?? false;
+            abortScope?.dispose();
             this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
             if (!isAbort) {
                 this.eventBus.emit({ type: "error", message: String(error), error });
             }
             if (method === 'generate') {
                 return {
-                    runId: options.runId,
+                    runId: this.runId,
                     messages: [],
                     finishReason: 'error',
                     error,
+                    getState: () => this.getState(),
                 };
             }
-            return { runId: options.runId, stream: (0, runtime_helpers_1.makeErrorStream)(error) };
+            return { runId: this.runId, stream: (0, runtime_helpers_1.makeErrorStream)(error), getState: () => this.getState() };
         }
     }
     async buildMessageList(input, options) {
@@ -273,9 +320,6 @@ class AgentRuntime {
                 list.addHistory((0, strip_orphaned_tool_messages_1.stripOrphanedToolMessages)(memMessages));
             }
         }
-        if (this.config.semanticRecall && options?.persistence?.threadId) {
-            await this.performSemanticRecall(list, input, options.persistence, options.executionCounter);
-        }
         await this.setListObservationLogMemory(list, options?.persistence);
         list.addInput(input);
         return list;
@@ -300,87 +344,7 @@ class AgentRuntime {
             resourceId,
         });
     }
-    async performSemanticRecall(list, input, persistence, executionCounter) {
-        if (!this.config.semanticRecall || !this.config.memory)
-            return;
-        const userText = input
-            .filter((m) => (0, message_1.isLlmMessage)(m) && m.role === 'user')
-            .flatMap((m) => ((0, message_1.isLlmMessage)(m) ? m.content : []))
-            .filter((c) => c.type === 'text')
-            .map((c) => c.text)
-            .join(' ');
-        if (!userText)
-            return;
-        let recalled = [];
-        if (this.config.memory.queryEmbeddings && this.config.semanticRecall.embedder) {
-            const { embed } = getAiSdk();
-            const embeddingModel = (0, model_factory_1.createEmbeddingModel)(this.config.semanticRecall.embedder, this.config.semanticRecall.apiKey);
-            const { embedding, usage } = await embed({ model: embeddingModel, value: userText });
-            (0, execution_counter_1.incrementTokenCountFromUsage)(executionCounter, usage);
-            const hits = await this.config.memory.queryEmbeddings({
-                scope: this.config.semanticRecall.scope ?? 'resource',
-                threadId: persistence.threadId,
-                resourceId: persistence.resourceId,
-                vector: embedding,
-                topK: this.config.semanticRecall.topK,
-            });
-            if (hits.length > 0) {
-                const hitIds = new Set(hits.map((h) => h.id));
-                const allMsgs = await this.config.memory.getMessages(persistence.threadId);
-                if (this.config.semanticRecall.messageRange) {
-                    recalled = this.expandMessageRange(allMsgs, hitIds, this.config.semanticRecall.messageRange);
-                }
-                else {
-                    recalled = allMsgs.filter((m) => {
-                        const id = m.id;
-                        return id !== undefined && hitIds.has(id);
-                    });
-                }
-            }
-        }
-        else if (this.config.memory.search) {
-            recalled = await this.config.memory.search(userText, {
-                threadId: persistence.threadId,
-                resourceId: persistence.resourceId,
-                topK: this.config.semanticRecall.topK,
-                messageRange: this.config.semanticRecall.messageRange,
-            });
-        }
-        if (recalled.length === 0)
-            return;
-        const { historyIds } = list.serialize();
-        const historyIdSet = new Set(historyIds);
-        const newRecalled = recalled.filter((m) => {
-            const id = m.id;
-            return !id || !historyIdSet.has(id);
-        });
-        if (newRecalled.length > 0) {
-            list.addHistory(newRecalled);
-        }
-    }
-    expandMessageRange(allMsgs, hitIds, range) {
-        const expandedIds = new Set();
-        for (const msg of allMsgs) {
-            const id = 'id' in msg && typeof msg.id === 'string' ? msg.id : undefined;
-            if (!id || !hitIds.has(id))
-                continue;
-            const idx = allMsgs.indexOf(msg);
-            const start = Math.max(0, idx - (range.before ?? 0));
-            const end = Math.min(allMsgs.length - 1, idx + (range.after ?? 0));
-            for (let i = start; i <= end; i++) {
-                const el = allMsgs[i];
-                const mid = 'id' in el && typeof el.id === 'string' ? el.id : undefined;
-                if (mid)
-                    expandedIds.add(mid);
-            }
-        }
-        return allMsgs.filter((m) => {
-            const mid = 'id' in m && typeof m.id === 'string' ? m.id : undefined;
-            return mid && expandedIds.has(mid);
-        });
-    }
     async initRun(input, options) {
-        this.eventBus.resetAbort(options?.abortSignal);
         this.updateState({
             status: 'running',
             persistence: options?.persistence,
@@ -391,14 +355,13 @@ class AgentRuntime {
         this.incrementMessageCount(options?.executionCounter);
         return await this.buildMessageList(normalizedInput, options);
     }
-    finalizeGenerate(result, list, runId) {
-        result.runId = runId;
+    finalizeGenerate(result, list) {
+        result.runId = this.runId;
         result.usage = this.applyCost(result.usage);
         result.model = this.modelIdString;
-        const finalized = (0, runtime_helpers_1.applySubAgentUsage)(result);
         this.updateState({ status: 'success', messageList: list.serialize() });
-        this.eventBus.emit({ type: "agent_end", messages: finalized.messages });
-        return finalized;
+        this.eventBus.emit({ type: "agent_end", messages: result.messages });
+        return { ...result, getState: () => this.getState() };
     }
     resolveTelemetry(options) {
         if (this.config.telemetry)
@@ -422,6 +385,12 @@ class AgentRuntime {
             },
         };
     }
+    buildSmoothStreamTransformOptions(options) {
+        if (options?.smoothStream === false)
+            return {};
+        const { smoothStream } = (0, lazy_ai_1.loadAi)();
+        return { experimental_transform: smoothStream(options?.smoothStream ?? {}) };
+    }
     buildTelemetryOptions(options) {
         const t = this.resolveTelemetry(options);
         if (!t?.enabled)
@@ -537,13 +506,12 @@ class AgentRuntime {
         });
     }
     async runGenerateLoop(ctx) {
-        const { list, options, runId, pendingResume } = ctx;
+        const { list, options, abortScope, pendingResume } = ctx;
         this.hydrateDeferredToolsFromList(list);
         let totalUsage;
         let lastFinishReason = 'stop';
         let structuredOutput;
         const toolCallSummary = [];
-        const collectedSubAgentUsage = [];
         const runTelemetry = this.resolveTelemetry(options);
         const staticLoopContext = this.buildStaticLoopContext({
             ...options,
@@ -553,10 +521,12 @@ class AgentRuntime {
         const pendingToolCtx = {
             toolMap: pendingLoopContext.toolMap,
             list,
-            runId,
+            runId: this.runId,
             persistence: options?.persistence,
             telemetry: runTelemetry,
             executionCounter: options?.executionCounter,
+            abortSignal: abortScope.signal,
+            isAborted: () => abortScope.isAborted,
         };
         const maxIterations = options?.maxIterations ?? MAX_LOOP_ITERATIONS;
         let iterationCount = options?.iterationCount ?? 0;
@@ -568,11 +538,9 @@ class AgentRuntime {
             });
             for (const r of batch.results) {
                 toolCallSummary.push(r.toolEntry);
-                if (r.subAgentUsage)
-                    collectedSubAgentUsage.push(...r.subAgentUsage);
             }
             if (Object.keys(batch.pending).length > 0) {
-                const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, runId, maxIterations, iterationCount);
+                const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, maxIterations, iterationCount);
                 return {
                     runId: suspendRunId,
                     messages: list.responseDelta(),
@@ -586,21 +554,24 @@ class AgentRuntime {
                         suspendPayload: s.payload,
                         resumeSchema: s.resumeSchema,
                     })),
+                    getState: () => this.getState(),
                 };
             }
         }
         const { generateText } = (0, lazy_ai_1.loadAi)();
         for (; iterationCount < maxIterations; iterationCount++) {
-            if (this.eventBus.isAborted) {
+            if (abortScope.isAborted) {
                 this.updateState({ status: 'cancelled' });
                 throw new Error('Agent run was aborted');
             }
             this.eventBus.emit({ type: "turn_start" });
             const { toolMap, aiTools, hasTools, effectiveInstructions } = this.buildToolLoopContext(staticLoopContext.aiProviderTools, options?.persistence, options?.executionCounter);
+            const { system, messages } = list.forLlm(effectiveInstructions, this.config.instructionProviderOptions);
             const result = await generateText({
                 model: staticLoopContext.model,
-                messages: list.forLlm(effectiveInstructions, this.config.instructionProviderOptions),
-                abortSignal: this.eventBus.signal,
+                system,
+                messages,
+                abortSignal: abortScope.signal,
                 ...(hasTools ? { tools: aiTools } : {}),
                 ...(staticLoopContext.providerOptions
                     ? { providerOptions: staticLoopContext.providerOptions }
@@ -626,19 +597,19 @@ class AgentRuntime {
             const batch = await this.iterateToolCallsConcurrent({
                 toolMap,
                 list,
-                runId,
+                runId: this.runId,
                 persistence: options?.persistence,
                 telemetry: runTelemetry,
                 executionCounter: options?.executionCounter,
+                abortSignal: abortScope.signal,
+                isAborted: () => abortScope.isAborted,
                 toolCalls: result.toolCalls,
             });
             for (const r of batch.results) {
                 toolCallSummary.push(r.toolEntry);
-                if (r.subAgentUsage)
-                    collectedSubAgentUsage.push(...r.subAgentUsage);
             }
             if (Object.keys(batch.pending).length > 0) {
-                const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, runId, maxIterations, iterationCount + 1);
+                const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, maxIterations, iterationCount + 1);
                 return {
                     runId: suspendRunId,
                     messages: list.responseDelta(),
@@ -652,6 +623,7 @@ class AgentRuntime {
                         suspendPayload: s.payload,
                         resumeSchema: s.resumeSchema,
                     })),
+                    getState: () => this.getState(),
                 };
             }
             this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractSettledToolCalls)(list.responseDelta()));
@@ -677,35 +649,68 @@ class AgentRuntime {
             }
         }
         return {
-            runId: runId ?? '',
+            runId: this.runId,
             messages: list.responseDelta(),
             finishReason: lastFinishReason,
             usage: totalUsage,
             ...(structuredOutput !== undefined && { structuredOutput }),
             ...(toolCallSummary.length > 0 && { toolCalls: toolCallSummary }),
-            ...(collectedSubAgentUsage.length > 0 && { subAgentUsage: collectedSubAgentUsage }),
+            getState: () => this.getState(),
         };
     }
     startStreamLoop(ctx) {
-        const { options, runId } = ctx;
+        const { options } = ctx;
         const { readable, writable } = new TransformStream();
         const writer = writable.getWriter();
+        const writeEventChunk = (chunk) => {
+            writer.write(chunk).catch(() => { });
+        };
         const onToolExecutionStart = (data) => {
             if (data.type !== "tool_execution_start")
                 return;
-            writer
-                .write({
+            writeEventChunk({
                 type: 'tool-execution-start',
                 toolCallId: data.toolCallId,
                 toolName: data.toolName,
-            })
-                .catch(() => { });
+                startTime: Date.now(),
+            });
+        };
+        const onToolExecutionEnd = (data) => {
+            if (data.type !== "tool_execution_end")
+                return;
+            writeEventChunk({
+                type: 'tool-execution-end',
+                toolCallId: data.toolCallId,
+                toolName: data.toolName,
+                isError: data.isError,
+                endTime: Date.now(),
+            });
+        };
+        const onSubAgentStarted = (data) => {
+            if (data.type !== "subagent_started")
+                return;
+            const { type: _type, ...payload } = data;
+            writeEventChunk({ type: 'subagent-started', ...payload });
+        };
+        const onSubAgentCompleted = (data) => {
+            if (data.type !== "subagent_completed")
+                return;
+            const { type: _type, ...payload } = data;
+            writeEventChunk({ type: 'subagent-completed', ...payload });
         };
         this.eventBus.on("tool_execution_start", onToolExecutionStart);
-        this.withTelemetryRootSpan('stream', options, runId, async () => await this.runStreamLoop({ ...ctx, writer }))
+        this.eventBus.on("tool_execution_end", onToolExecutionEnd);
+        this.eventBus.on("subagent_started", onSubAgentStarted);
+        this.eventBus.on("subagent_completed", onSubAgentCompleted);
+        this.withTelemetryRootSpan('stream', options, this.runId, async () => await this.runStreamLoop({ ...ctx, writer }))
             .catch(async (error) => {
             await this.flushTelemetry(options);
-            await this.cleanupRun(runId);
+            await this.cleanupRun();
+            const isAbort = ctx.abortScope.isAborted;
+            this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
+            if (!isAbort) {
+                this.eventBus.emit({ type: "error", message: String(error), error });
+            }
             try {
                 await writer.write({ type: 'error', error });
                 await writer.write({ type: 'finish', finishReason: 'error' });
@@ -715,13 +720,18 @@ class AgentRuntime {
                 writer.abort(error).catch(() => { });
             }
         })
-            .finally(() => {
+            .finally(async () => {
+            await writer.close().catch(() => { });
             this.eventBus.off("tool_execution_start", onToolExecutionStart);
+            this.eventBus.off("tool_execution_end", onToolExecutionEnd);
+            this.eventBus.off("subagent_started", onSubAgentStarted);
+            this.eventBus.off("subagent_completed", onSubAgentCompleted);
+            ctx.abortScope.dispose();
         });
         return readable;
     }
     async runStreamLoop(ctx) {
-        const { list, options, runId, pendingResume, writer } = ctx;
+        const { list, options, abortScope, pendingResume, writer } = ctx;
         this.hydrateDeferredToolsFromList(list);
         const writeChunk = async (chunk) => {
             await writer.write(chunk);
@@ -729,20 +739,19 @@ class AgentRuntime {
         let totalUsage;
         let lastFinishReason = 'stop';
         let structuredOutput;
-        const collectedSubAgentUsage = [];
         const maxIterations = options?.maxIterations ?? MAX_LOOP_ITERATIONS;
         let iterationCount = options?.iterationCount ?? 0;
         let reachedStopCondition = false;
         const { streamText } = (0, lazy_ai_1.loadAi)();
         const closeStreamWithError = async (error, status) => {
-            await this.cleanupRun(runId);
+            await this.cleanupRun();
             this.updateState({ status });
             await writer.write({ type: 'error', error });
             await writer.write({ type: 'finish', finishReason: 'error' });
             await writer.close();
         };
         const handleAbort = async () => {
-            if (!this.eventBus.isAborted)
+            if (!abortScope.isAborted)
                 return false;
             await closeStreamWithError(new Error('Agent run was aborted'), 'cancelled');
             return true;
@@ -756,10 +765,12 @@ class AgentRuntime {
         const pendingToolCtx = {
             toolMap: pendingLoopContext.toolMap,
             list,
-            runId,
+            runId: this.runId,
             persistence: options?.persistence,
             telemetry: runTelemetry,
             executionCounter: options?.executionCounter,
+            abortSignal: abortScope.signal,
+            isAborted: () => abortScope.isAborted,
         };
         if (pendingResume) {
             try {
@@ -768,13 +779,12 @@ class AgentRuntime {
                     pendingResume,
                 });
                 for (const r of batch.results) {
-                    if (r.subAgentUsage)
-                        collectedSubAgentUsage.push(...r.subAgentUsage);
                     await writer.write({
                         type: 'tool-result',
                         toolCallId: r.toolCallId,
                         toolName: r.toolName,
                         output: r.modelOutput,
+                        ...(r.toolEntry.canceled ? { canceled: true } : {}),
                     });
                     if (r.customMessage) {
                         await writer.write({ type: 'message', message: r.customMessage });
@@ -790,7 +800,7 @@ class AgentRuntime {
                     });
                 }
                 if (Object.keys(batch.pending).length > 0) {
-                    const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, runId, maxIterations, iterationCount);
+                    const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, maxIterations, iterationCount);
                     for (const s of batch.suspensions) {
                         await writer.write({
                             type: 'tool-call-suspended',
@@ -818,25 +828,45 @@ class AgentRuntime {
                 return;
             this.eventBus.emit({ type: "turn_start" });
             const { toolMap, aiTools, hasTools, effectiveInstructions } = this.buildToolLoopContext(staticLoopContext.aiProviderTools, options?.persistence, options?.executionCounter);
-            const messages = list.forLlm(effectiveInstructions, this.config.instructionProviderOptions);
+            const { system, messages } = list.forLlm(effectiveInstructions, this.config.instructionProviderOptions);
             const result = streamText({
                 model: staticLoopContext.model,
+                system,
                 messages,
-                abortSignal: this.eventBus.signal,
+                abortSignal: abortScope.signal,
                 ...(hasTools ? { tools: aiTools } : {}),
                 ...(staticLoopContext.providerOptions
                     ? { providerOptions: staticLoopContext.providerOptions }
                     : {}),
                 ...(staticLoopContext.outputSpec ? { output: staticLoopContext.outputSpec } : {}),
                 ...this.buildAiSdkOptions(toolMap, options),
+                ...this.buildSmoothStreamTransformOptions(options),
             });
             try {
                 for await (const chunk of result.fullStream) {
                     if (chunk.type === 'finish')
                         continue;
+                    if ((chunk.type === 'tool-result' || chunk.type === 'tool-error') &&
+                        chunk.providerExecuted) {
+                        await writeChunk({
+                            type: 'tool-execution-end',
+                            toolCallId: chunk.toolCallId,
+                            toolName: chunk.toolName ?? '',
+                            isError: chunk.type === 'tool-error',
+                            endTime: Date.now(),
+                        });
+                    }
                     const converted = (0, stream_1.convertChunk)(chunk);
                     if (converted)
                         await writeChunk(converted);
+                    if (chunk.type === 'tool-call' && chunk.providerExecuted) {
+                        await writeChunk({
+                            type: 'tool-execution-start',
+                            toolCallId: chunk.toolCallId,
+                            toolName: chunk.toolName ?? '',
+                            startTime: Date.now(),
+                        });
+                    }
                 }
             }
             catch (streamError) {
@@ -874,22 +904,23 @@ class AgentRuntime {
                 const batch = await this.iterateToolCallsConcurrent({
                     toolMap,
                     list,
-                    runId,
+                    runId: this.runId,
                     persistence: options?.persistence,
                     telemetry: runTelemetry,
                     executionCounter: options?.executionCounter,
+                    abortSignal: abortScope.signal,
+                    isAborted: () => abortScope.isAborted,
                     toolCalls,
                 });
                 if (await handleAbort())
                     return;
                 for (const r of batch.results) {
-                    if (r.subAgentUsage)
-                        collectedSubAgentUsage.push(...r.subAgentUsage);
                     await writer.write({
                         type: 'tool-result',
                         toolCallId: r.toolCallId,
                         toolName: r.toolName,
                         output: r.modelOutput,
+                        ...(r.toolEntry.canceled ? { canceled: true } : {}),
                     });
                     if (r.customMessage) {
                         await writer.write({ type: 'message', message: r.customMessage });
@@ -905,7 +936,7 @@ class AgentRuntime {
                     });
                 }
                 if (Object.keys(batch.pending).length > 0) {
-                    const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, runId, maxIterations, iterationCount + 1);
+                    const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, maxIterations, iterationCount + 1);
                     for (const s of batch.suspensions) {
                         await writer.write({
                             type: 'tool-call-suspended',
@@ -932,45 +963,35 @@ class AgentRuntime {
         if (!reachedStopCondition && iterationCount >= maxIterations) {
             lastFinishReason = 'max-iterations';
         }
+        await this.saveToMemory(list, options);
+        if (this.config.titleGeneration && options?.persistence && this.config.memory) {
+            const titlePromise = (0, title_generation_1.generateThreadTitle)({
+                memory: this.config.memory,
+                threadId: options.persistence.threadId,
+                resourceId: options.persistence.resourceId,
+                titleConfig: this.config.titleGeneration,
+                agentModel: this.config.model,
+                turnDelta: list.turnDelta(),
+                executionCounter: options.executionCounter,
+            });
+            this.backgroundTasks.track(titlePromise);
+            if (this.config.titleGeneration.sync) {
+                await titlePromise;
+            }
+        }
+        await this.cleanupRun();
+        await this.flushTelemetry(options);
         const costUsage = this.applyCost(totalUsage);
-        const parentCost = costUsage?.cost ?? 0;
-        const subCost = collectedSubAgentUsage.reduce((sum, s) => sum + (s.usage.cost ?? 0), 0);
         await writer.write({
             type: 'finish',
             finishReason: lastFinishReason,
             ...(costUsage && { usage: costUsage }),
             model: this.modelIdString,
             ...(structuredOutput !== undefined && { structuredOutput }),
-            ...(collectedSubAgentUsage.length > 0 && {
-                subAgentUsage: collectedSubAgentUsage,
-                totalCost: parentCost + subCost,
-            }),
         });
-        try {
-            await this.saveToMemory(list, options);
-            if (this.config.titleGeneration && options?.persistence && this.config.memory) {
-                const titlePromise = (0, title_generation_1.generateThreadTitle)({
-                    memory: this.config.memory,
-                    threadId: options.persistence.threadId,
-                    resourceId: options.persistence.resourceId,
-                    titleConfig: this.config.titleGeneration,
-                    agentModel: this.config.model,
-                    turnDelta: list.turnDelta(),
-                    executionCounter: options.executionCounter,
-                });
-                this.backgroundTasks.track(titlePromise);
-                if (this.config.titleGeneration.sync) {
-                    await titlePromise;
-                }
-            }
-            await this.cleanupRun(runId);
-            await this.flushTelemetry(options);
-            this.updateState({ status: 'success', messageList: list.serialize() });
-            this.eventBus.emit({ type: "agent_end", messages: list.responseDelta() });
-        }
-        finally {
-            await writer.close();
-        }
+        this.updateState({ status: 'success', messageList: list.serialize() });
+        this.eventBus.emit({ type: "agent_end", messages: list.responseDelta() });
+        await writer.close();
     }
     async saveToMemory(list, options) {
         if (!this.config.memory || !options?.persistence)
@@ -979,9 +1000,6 @@ class AgentRuntime {
         if (delta.length === 0)
             return;
         await (0, memory_store_1.saveMessagesToThread)(this.config.memory, options.persistence.threadId, options.persistence.resourceId, delta);
-        if (this.config.semanticRecall?.embedder && this.config.memory.saveEmbeddings) {
-            await this.saveEmbeddingsForMessages(options.persistence.threadId, options.persistence.resourceId, delta, options.executionCounter);
-        }
         const observationTasks = this.scheduleObservationLogJobs(options.persistence, options.executionCounter);
         this.scheduleEpisodicMemoryJob(options.persistence, observationTasks, options.executionCounter);
     }
@@ -1119,43 +1137,6 @@ class AgentRuntime {
             observationScopeId: persistence.threadId,
         };
     }
-    async saveEmbeddingsForMessages(threadId, resourceId, messages, executionCounter) {
-        const embeddable = [];
-        for (const msg of messages) {
-            if (!(0, message_1.isLlmMessage)(msg) || (msg.role !== 'user' && msg.role !== 'assistant'))
-                continue;
-            const text = msg.content
-                .filter((c) => c.type === 'text')
-                .map((c) => c.text)
-                .join('\n');
-            if (!text)
-                continue;
-            embeddable.push({ id: msg.id, text });
-        }
-        if (embeddable.length === 0)
-            return;
-        const embedder = this.config.semanticRecall?.embedder;
-        if (!embedder)
-            return;
-        const { embedMany } = getAiSdk();
-        const embeddingModel = (0, model_factory_1.createEmbeddingModel)(embedder, this.config.semanticRecall?.apiKey);
-        const { embeddings, usage } = await embedMany({
-            model: embeddingModel,
-            values: embeddable.map((e) => e.text),
-        });
-        (0, execution_counter_1.incrementTokenCountFromUsage)(executionCounter, usage);
-        await this.config.memory.saveEmbeddings({
-            scope: this.config.semanticRecall?.scope ?? 'resource',
-            threadId,
-            resourceId,
-            entries: embeddable.map((e, i) => ({
-                id: e.id,
-                vector: embeddings[i],
-                text: e.text,
-                model: embedder,
-            })),
-        });
-    }
     buildThinkingProviderOptions() {
         if (!this.config.thinking)
             return undefined;
@@ -1215,8 +1196,39 @@ class AgentRuntime {
         }
         return merged;
     }
+    isDelegateSubAgentCall(toolName) {
+        return toolName === delegate_sub_agent_tool_1.DELEGATE_SUB_AGENT_TOOL_NAME;
+    }
+    getToolCallBatchSize(toolName, toolMap) {
+        if (!this.isDelegateSubAgentCall(toolName))
+            return this.concurrency;
+        const tool = toolMap.get(toolName);
+        const delegateOptions = tool ? (0, delegate_sub_agent_tool_1.getInlineDelegateSubAgentToolOptions)(tool) : undefined;
+        return delegateOptions?.policy?.maxChildren ?? sub_agent_task_path_1.DEFAULT_SUB_AGENT_MAX_CHILDREN;
+    }
+    takeNextToolCallBatch(calls, start, toolMap) {
+        const first = calls[start];
+        if (!first) {
+            throw new Error('Unable to build tool-call batch');
+        }
+        const isDelegateBatch = this.isDelegateSubAgentCall(first.toolName);
+        const batchSize = this.getToolCallBatchSize(first.toolName, toolMap);
+        if (batchSize < 1 ||
+            Number.isNaN(batchSize) ||
+            (isDelegateBatch && !Number.isFinite(batchSize))) {
+            throw new Error(`Invalid tool-call batch size for ${first.toolName}: ${batchSize}`);
+        }
+        const batch = [];
+        for (let i = start; i < calls.length && batch.length < batchSize; i++) {
+            const candidate = calls[i];
+            if (this.isDelegateSubAgentCall(candidate.toolName) !== isDelegateBatch)
+                break;
+            batch.push(candidate);
+        }
+        return batch;
+    }
     async iterateToolCallsConcurrent(ctx) {
-        const { toolCalls, toolMap, list, runId, telemetry: resolvedTelemetry, executionCounter } = ctx;
+        const { toolCalls, toolMap, list, runId, telemetry: resolvedTelemetry, executionCounter, abortSignal, } = ctx;
         const executableCalls = toolCalls.filter((tc) => !tc.providerExecuted);
         const providerExecutedCount = toolCalls.length - executableCalls.length;
         for (let i = 0; i < providerExecutedCount; i++) {
@@ -1224,18 +1236,18 @@ class AgentRuntime {
         }
         const executableCallsById = new Map(executableCalls.map((tc) => [tc.toolCallId, tc]));
         const unexecutedIds = new Set(executableCalls.map((tc) => tc.toolCallId));
-        const batchSize = this.concurrency;
         const results = [];
         const suspensions = [];
         const errors = [];
         const pending = {};
-        for (let batchStart = 0; batchStart < executableCalls.length; batchStart += batchSize) {
-            if (this.eventBus.isAborted) {
+        for (let batchStart = 0; batchStart < executableCalls.length;) {
+            if (ctx.isAborted()) {
                 this.updateState({ status: 'cancelled' });
                 throw new Error('Agent run was aborted');
             }
-            const batch = executableCalls.slice(batchStart, batchStart + batchSize);
-            const settledResults = await Promise.allSettled(batch.map(async (tc) => await this.processToolCall(tc.toolCallId, tc.toolName, tc.input, toolMap, list, runId, ctx.persistence, undefined, resolvedTelemetry, executionCounter, true)));
+            const batch = this.takeNextToolCallBatch(executableCalls, batchStart, toolMap);
+            batchStart += batch.length;
+            const settledResults = await Promise.allSettled(batch.map(async (tc) => await this.processToolCall(tc.toolCallId, tc.toolName, tc.input, toolMap, list, runId, ctx.persistence, undefined, resolvedTelemetry, executionCounter, abortSignal, true)));
             for (const tc of batch) {
                 unexecutedIds.delete(tc.toolCallId);
             }
@@ -1279,7 +1291,6 @@ class AgentRuntime {
                         input: toolInput,
                         toolEntry: result.value.toolEntry,
                         modelOutput: result.value.modelOutput,
-                        subAgentUsage: result.value.subAgentUsage,
                         customMessage: result.value.customMessage,
                     });
                 }
@@ -1310,7 +1321,7 @@ class AgentRuntime {
         return { results, suspensions, errors, pending };
     }
     async iteratePendingToolCallsConcurrent(ctx) {
-        const { pendingResume, toolMap, list, runId, persistence, telemetry: resolvedTelemetry, executionCounter, } = ctx;
+        const { pendingResume, toolMap, list, runId, persistence, telemetry: resolvedTelemetry, executionCounter, abortSignal, } = ctx;
         const resumedId = pendingResume.resumeToolCallId;
         const resumedEntry = pendingResume.pendingToolCalls[resumedId];
         if (!resumedEntry) {
@@ -1321,7 +1332,14 @@ class AgentRuntime {
         const suspensions = [];
         const errors = [];
         const pending = {};
-        const processResult = await this.processToolCall(resumedEntry.toolCallId, resumedToolName, resumedEntry.input, toolMap, list, runId, persistence, pendingResume.resumeData, resolvedTelemetry, executionCounter, false);
+        let processResult;
+        try {
+            processResult = await this.processToolCall(resumedEntry.toolCallId, resumedToolName, resumedEntry.input, toolMap, list, runId, persistence, pendingResume.resumeData, resolvedTelemetry, executionCounter, abortSignal, false);
+        }
+        catch (error) {
+            processResult = { outcome: 'error', error };
+            list.setToolCallError(resumedEntry.toolCallId, error);
+        }
         if (processResult.outcome === 'suspended') {
             pending[resumedId] = {
                 ...resumedEntry,
@@ -1345,10 +1363,44 @@ class AgentRuntime {
                 input: resumedEntry.input,
                 toolEntry: processResult.toolEntry,
                 modelOutput: processResult.modelOutput,
-                subAgentUsage: processResult.subAgentUsage,
                 customMessage: processResult.customMessage,
             });
         }
+        else if (processResult.outcome === 'cancelled') {
+            results.push({
+                toolCallId: resumedEntry.toolCallId,
+                toolName: resumedToolName,
+                input: resumedEntry.input,
+                toolEntry: processResult.toolEntry,
+                modelOutput: processResult.modelOutput,
+            });
+            list.addInput([
+                { role: 'user', content: [{ type: 'text', text: processResult.userMessage }] },
+            ]);
+            for (const id of Object.keys(pendingResume.pendingToolCalls)) {
+                if (id !== resumedId) {
+                    const siblingEntry = pendingResume.pendingToolCalls[id];
+                    const modelOutput = '[Skipped: a sibling tool call was cancelled]';
+                    list.setToolCallResult(id, modelOutput, {
+                        canceled: true,
+                    });
+                    results.push({
+                        toolCallId: siblingEntry.toolCallId,
+                        toolName: siblingEntry.toolName,
+                        input: siblingEntry.input,
+                        toolEntry: {
+                            tool: siblingEntry.toolName,
+                            input: siblingEntry.input,
+                            output: modelOutput,
+                            transformed: false,
+                            canceled: true,
+                        },
+                        modelOutput,
+                    });
+                }
+            }
+            return { results, suspensions, errors, pending };
+        }
         else if (processResult.outcome === 'error') {
             errors.push({
                 toolCallId: resumedEntry.toolCallId,
@@ -1391,6 +1443,8 @@ class AgentRuntime {
                 persistence,
                 telemetry: resolvedTelemetry,
                 executionCounter,
+                abortSignal,
+                isAborted: ctx.isAborted,
             });
             results.push(...batch.results);
             suspensions.push(...batch.suspensions);
@@ -1399,14 +1453,8 @@ class AgentRuntime {
         }
         return { results, suspensions, errors, pending };
     }
-    async processToolCall(toolCallId, toolName, toolInput, toolMap, list, runId, persistence, resumeData, resolvedTelemetry, executionCounter, countToolCall = true) {
+    async processToolCall(toolCallId, toolName, toolInput, toolMap, list, runId, persistence, resumeData, resolvedTelemetry, executionCounter, abortSignal, countToolCall = true) {
         const builtTool = toolMap.get(toolName);
-        this.eventBus.emit({
-            type: "tool_execution_start",
-            toolCallId,
-            toolName,
-            args: toolInput,
-        });
         const makeToolError = (error) => {
             this.eventBus.emit({
                 type: "tool_execution_end",
@@ -1442,6 +1490,30 @@ class AgentRuntime {
             });
             return { outcome: 'noop' };
         }
+        if ((0, cancellation_1.isCancellation)(resumeData) && !builtTool.handleCancellation) {
+            const modelOutput = `[Tool call cancelled. User said: "${resumeData.message}"]`;
+            this.eventBus.emit({
+                type: "tool_execution_end",
+                toolCallId,
+                toolName,
+                result: modelOutput,
+                isError: false,
+            });
+            list.setToolCallResult(toolCallId, modelOutput, { canceled: true });
+            return {
+                outcome: 'cancelled',
+                toolEntry: {
+                    tool: toolName,
+                    input: toolInput,
+                    output: modelOutput,
+                    transformed: false,
+                    canceled: true,
+                },
+                modelOutput,
+                userMessage: resumeData.message,
+                canceled: true,
+            };
+        }
         if (countToolCall) {
             this.incrementToolCallCount(executionCounter);
         }
@@ -1452,11 +1524,22 @@ class AgentRuntime {
             }
             toolInput = result.data;
         }
+        if (shouldEmitToolExecutionStart(builtTool, resumeData)) {
+            this.eventBus.emit({
+                type: "tool_execution_start",
+                toolCallId,
+                toolName,
+                args: toolInput,
+            });
+        }
         let toolResult;
         try {
             toolResult = await this.withTelemetryToolSpan(toolCallId, toolName, toolInput, resolvedTelemetry, async () => await (0, tool_adapter_1.executeTool)(toolInput, builtTool, resumeData, resolvedTelemetry, toolCallId, {
                 runId,
                 persistence,
+                emitEvent: (event) => this.eventBus.emit(event),
+                abortSignal,
+                executionCounter,
             }));
         }
         catch (error) {
@@ -1474,9 +1557,7 @@ class AgentRuntime {
                 const error = new Error(`Tool ${toolName} has no resume schema`);
                 return makeToolError(error);
             }
-            const resumeSchema = (0, zod_1.isZodSchema)(builtTool.resumeSchema)
-                ? (0, zod_to_json_schema_1.zodToJsonSchema)(builtTool.resumeSchema)
-                : builtTool.resumeSchema;
+            const resumeSchema = getToolResumeJsonSchema(builtTool);
             if (!resumeSchema) {
                 return makeToolError(new Error('Invalid resume schema'));
             }
@@ -1486,24 +1567,22 @@ class AgentRuntime {
                 resumeSchema,
             };
         }
-        let actualResult = toolResult;
-        let extractedSubAgentUsage;
-        if ((0, tool_adapter_1.isAgentToolResult)(toolResult)) {
-            actualResult = toolResult.output;
-            extractedSubAgentUsage = toolResult.subAgentUsage;
+        let modelResult;
+        try {
+            modelResult = builtTool.toModelOutput ? builtTool.toModelOutput(toolResult) : toolResult;
+        }
+        catch (error) {
+            return makeToolError(error);
         }
         this.eventBus.emit({
             type: "tool_execution_end",
             toolCallId,
             toolName,
-            result: actualResult,
+            result: toolResult,
             isError: false,
         });
-        const modelResult = builtTool.toModelOutput
-            ? builtTool.toModelOutput(actualResult)
-            : actualResult;
         list.setToolCallResult(toolCallId, (0, json_value_1.toJsonValue)(modelResult));
-        const customMessage = builtTool?.toMessage?.(actualResult);
+        const customMessage = builtTool?.toMessage?.(toolResult);
         if (customMessage) {
             list.addResponse([customMessage]);
         }
@@ -1512,27 +1591,43 @@ class AgentRuntime {
             toolEntry: {
                 tool: toolName,
                 input: toolInput,
-                output: actualResult,
+                output: toolResult,
                 transformed: !!builtTool.toModelOutput,
             },
             modelOutput: modelResult,
-            subAgentUsage: extractedSubAgentUsage,
             customMessage,
         };
     }
     buildStaticLoopContext(execOptions) {
-        const { Output } = getAiSdk();
+        const { Output, jsonSchema } = getAiSdk();
         const aiProviderTools = (0, tool_adapter_1.toAiSdkProviderTools)(this.config.providerTools);
         const model = (0, model_factory_1.createModel)(this.config.model);
+        const outputSchema = this.config.structuredOutput;
+        const isRawJsonSchemaOutput = outputSchema !== undefined && !(0, zod_1.isZodSchema)(outputSchema);
+        const providerOptions = this.relaxStrictJsonSchemaIfNeeded(this.buildCallProviderOptions(execOptions?.providerOptions), isRawJsonSchemaOutput);
+        const outputSpec = outputSchema
+            ? Output.object({
+                schema: (0, zod_1.isZodSchema)(outputSchema)
+                    ? outputSchema
+                    : jsonSchema((0, json_schema_1.lockAdditionalProperties)(outputSchema)),
+            })
+            : undefined;
         return {
             model,
             aiProviderTools,
-            providerOptions: this.buildCallProviderOptions(execOptions?.providerOptions),
-            outputSpec: this.config.structuredOutput
-                ? Output.object({ schema: this.config.structuredOutput })
-                : undefined,
+            providerOptions,
+            outputSpec,
         };
     }
+    relaxStrictJsonSchemaIfNeeded(providerOptions, isRawJsonSchemaOutput) {
+        if (!isRawJsonSchemaOutput)
+            return providerOptions;
+        const result = { ...providerOptions };
+        for (const provider of ['openai', 'groq']) {
+            result[provider] = { strictJsonSchema: false, ...result[provider] };
+        }
+        return result;
+    }
     buildToolLoopContext(aiProviderTools, persistence, executionCounter) {
         const allUserTools = this.getCurrentTools(persistence, executionCounter);
         const aiTools = (0, tool_adapter_1.toAiSdkTools)(allUserTools);
@@ -1592,8 +1687,7 @@ class AgentRuntime {
         const block = `<built_in_rules>\n${fragments.map((f) => `- ${f}`).join('\n')}\n</built_in_rules>`;
         return userInstructions ? `${block}\n\n${userInstructions}` : block;
     }
-    async persistSuspension(pendingToolCalls, options, list, totalUsage, existingRunId, maxIterations, iterationCount) {
-        const runId = existingRunId ?? (0, run_state_1.generateRunId)();
+    async persistSuspension(pendingToolCalls, options, list, totalUsage, maxIterations, iterationCount) {
         const resolvedMaxIterations = maxIterations ?? options?.maxIterations;
         const resolvedIterationCount = iterationCount ?? options?.iterationCount;
         const executionOptions = resolvedMaxIterations !== undefined ? { maxIterations: resolvedMaxIterations } : undefined;
@@ -1606,14 +1700,12 @@ class AgentRuntime {
             executionOptions,
             ...(resolvedIterationCount !== undefined ? { iterationCount: resolvedIterationCount } : {}),
         };
-        await this.runState.suspend(runId, state);
+        await this.runState.suspend(this.runId, state);
         this.updateState({ status: 'suspended', pendingToolCalls, messageList: list.serialize() });
-        return runId;
+        return this.runId;
     }
-    async cleanupRun(runId) {
-        if (runId) {
-            await this.runState.complete(runId);
-        }
+    async cleanupRun() {
+        await this.runState.complete(this.runId);
     }
     emitTurnEnd(newMessages, toolResults) {
         const assistantMsg = newMessages.find((m) => 'role' in m && m.role === 'assistant');