@n8n/agents 0.5.2 → 0.6.0

package/dist/runtime/agent-runtime.d.ts

@@ -1,7 +1,9 @@
 import type { ProviderOptions } from '@ai-sdk/provider-utils';
 import type { z } from 'zod';
+import { type ModelCost } from '../sdk/catalog';
 import type { BuiltMemory, BuiltProviderTool, BuiltTelemetry, BuiltTool, CheckpointStore, GenerateResult, RunOptions, SemanticRecallConfig, SerializableAgentState, StreamResult, ThinkingConfig, TitleGenerationConfig } from '../types';
 import { AgentEventBus } from './event-bus';
+import { RunStateManager } from './run-state';
 import type { ExecutionOptions, ModelConfig } from '../types/sdk/agent';
 import type { AgentMessage } from '../types/sdk/message';
 export interface AgentRuntimeConfig {
@@ -28,6 +30,8 @@ export interface AgentRuntimeConfig {
     toolCallConcurrency?: number;
     titleGeneration?: TitleGenerationConfig;
     telemetry?: BuiltTelemetry;
+    modelCost?: ModelCost;
+    runState?: RunStateManager;
 }
 export declare class AgentRuntime {
     private config;
@@ -35,6 +39,8 @@ export declare class AgentRuntime {
     private eventBus;
     private currentState;
     private modelCost;
+    private runId;
+    private executionOptions;
     constructor(config: AgentRuntimeConfig);
     getState(): SerializableAgentState;
     abort(): void;
@@ -77,5 +83,6 @@ export declare class AgentRuntime {
     private ensureModelCost;
     private applyCost;
     private setListWorkingMemoryConfig;
+    private emitEvent;
     private resolveWorkingMemoryParams;
 }

package/dist/runtime/agent-runtime.js

@@ -65,9 +65,11 @@ const EMPTY_MESSAGE_LIST = {
 };
 class AgentRuntime {
     constructor(config) {
+        this.runId = '';
         this.config = config;
-        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',
@@ -82,43 +84,58 @@ class AgentRuntime {
         this.eventBus.abort();
     }
     async generate(input, options) {
-        const runId = (0, run_state_1.generateRunId)();
+        this.runId = (0, run_state_1.generateRunId)();
+        this.executionOptions = options;
+        this.updateState({ persistence: options?.persistence });
         let list = undefined;
         try {
-            list = await this.initRun(input, options);
-            const rawResult = await this.runGenerateLoop(list, options, undefined, runId);
-            return this.finalizeGenerate(rawResult, list, runId);
+            list = await this.initRun(input);
+            const rawResult = await this.runGenerateLoop(list);
+            return this.finalizeGenerate(rawResult, list);
         }
         catch (error) {
-            await this.flushTelemetry(options);
+            await this.flushTelemetry();
             const isAbort = this.eventBus.isAborted;
             this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
             if (!isAbort) {
-                this.eventBus.emit({ type: "error", message: String(error), error });
+                this.emitEvent({ 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(),
+            };
         }
     }
     async stream(input, options) {
-        const runId = (0, run_state_1.generateRunId)();
+        this.runId = (0, run_state_1.generateRunId)();
+        this.executionOptions = options;
+        this.updateState({ persistence: options?.persistence });
         let list;
         try {
-            list = await this.initRun(input, options);
+            list = await this.initRun(input);
         }
         catch (error) {
             const isAbort = this.eventBus.isAborted;
             this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
             if (!isAbort) {
-                this.eventBus.emit({ type: "error", message: String(error), error });
+                this.emitEvent({ type: "error", message: String(error), error });
             }
-            return { runId, stream: (0, runtime_helpers_1.makeErrorStream)(error) };
+            return { runId: this.runId, stream: (0, runtime_helpers_1.makeErrorStream)(error), getState: () => this.getState() };
         }
-        return { runId, stream: this.startStreamLoop(list, options, undefined, runId) };
+        return {
+            runId: this.runId,
+            stream: this.startStreamLoop(list),
+            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}`);
@@ -141,11 +158,9 @@ class AgentRuntime {
                 ...persisted,
                 ...callerExecOptions,
             };
-            const resumeOptions = {
-                persistence: state.persistence,
-                ...mergedExecOptions,
-            };
-            this.eventBus.resetAbort(resumeOptions.abortSignal);
+            this.executionOptions = mergedExecOptions;
+            this.updateState({ persistence: state.persistence });
+            this.eventBus.resetAbort(this.executionOptions?.abortSignal);
             const pendingResume = {
                 pendingToolCalls: state.pendingToolCalls,
                 resumeToolCallId: options.toolCallId,
@@ -155,48 +170,51 @@ class AgentRuntime {
             await this.ensureModelCost();
             await this.setListWorkingMemoryConfig(list, state.persistence);
             if (method === 'generate') {
-                const rawResult = await this.runGenerateLoop(list, resumeOptions, pendingResume, options.runId);
+                const rawResult = await this.runGenerateLoop(list, pendingResume);
                 if (!rawResult.pendingSuspend) {
-                    await this.cleanupRun(options.runId);
+                    await this.cleanupRun();
                 }
-                return this.finalizeGenerate(rawResult, list, options.runId);
+                return this.finalizeGenerate(rawResult, list);
             }
             return {
-                runId: options.runId,
-                stream: this.startStreamLoop(list, resumeOptions, pendingResume, options.runId),
+                runId: this.runId,
+                stream: this.startStreamLoop(list, pendingResume),
+                getState: () => this.getState(),
             };
         }
         catch (error) {
             const isAbort = this.eventBus.isAborted;
             this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
             if (!isAbort) {
-                this.eventBus.emit({ type: "error", message: String(error), error });
+                this.emitEvent({ 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) {
+    async buildMessageList(input) {
         const list = new message_list_1.AgentMessageList();
-        if (this.config.memory && options?.persistence?.threadId) {
-            const memMessages = await this.config.memory.getMessages(options.persistence.threadId, {
+        const persistence = this.currentState.persistence;
+        if (this.config.memory && persistence?.threadId) {
+            const memMessages = await this.config.memory.getMessages(persistence.threadId, {
                 limit: this.config.lastMessages ?? 10,
             });
             if (memMessages.length > 0) {
                 list.addHistory((0, strip_orphaned_tool_messages_1.stripOrphanedToolMessages)(memMessages));
             }
         }
-        if (this.config.semanticRecall && options?.persistence?.threadId) {
-            await this.performSemanticRecall(list, input, options.persistence.threadId, options.persistence.resourceId);
+        if (this.config.semanticRecall && persistence?.threadId) {
+            await this.performSemanticRecall(list, input, persistence.threadId, persistence.resourceId);
         }
-        await this.setListWorkingMemoryConfig(list, options?.persistence);
+        await this.setListWorkingMemoryConfig(list, persistence);
         list.addInput(input);
         return list;
     }
@@ -278,37 +296,34 @@ class AgentRuntime {
             return mid && expandedIds.has(mid);
         });
     }
-    async initRun(input, options) {
-        this.eventBus.resetAbort(options?.abortSignal);
-        this.updateState({
-            status: 'running',
-            persistence: options?.persistence,
-        });
-        this.eventBus.emit({ type: "agent_start" });
+    async initRun(input) {
+        this.eventBus.resetAbort(this.executionOptions?.abortSignal);
+        this.updateState({ status: 'running' });
+        this.emitEvent({ type: "agent_start" });
         await this.ensureModelCost();
         const normalizedInput = (0, runtime_helpers_1.normalizeInput)(input);
-        return await this.buildMessageList(normalizedInput, options);
+        return await this.buildMessageList(normalizedInput);
     }
-    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.emitEvent({ type: "agent_end", messages: finalized.messages });
+        return { ...finalized, getState: () => this.getState() };
     }
-    resolveTelemetry(options) {
+    resolveTelemetry() {
         if (this.config.telemetry)
             return this.config.telemetry;
-        const inherited = options?.telemetry;
+        const inherited = this.executionOptions?.telemetry;
         if (!inherited)
             return undefined;
         return { ...inherited, functionId: this.config.name };
     }
-    async flushTelemetry(options) {
+    async flushTelemetry() {
         try {
-            const resolved = this.resolveTelemetry(options);
+            const resolved = this.resolveTelemetry();
             if (resolved?.provider) {
                 await resolved.provider.forceFlush();
             }
@@ -316,8 +331,8 @@ class AgentRuntime {
         catch {
         }
     }
-    buildTelemetryOptions(options) {
-        const t = this.resolveTelemetry(options);
+    buildTelemetryOptions() {
+        const t = this.resolveTelemetry();
         if (!t?.enabled)
             return {};
         return {
@@ -332,14 +347,14 @@ class AgentRuntime {
             },
         };
     }
-    async runGenerateLoop(list, options, pendingResume, runId) {
-        const { model, toolMap, aiTools, providerOptions, hasTools, outputSpec } = this.buildLoopContext({ ...options, persistence: options?.persistence });
+    async runGenerateLoop(list, pendingResume) {
+        const { model, toolMap, aiTools, providerOptions, hasTools, outputSpec } = this.buildLoopContext();
         let totalUsage;
         let lastFinishReason = 'stop';
         let structuredOutput;
         const toolCallSummary = [];
         const collectedSubAgentUsage = [];
-        const runTelemetry = this.resolveTelemetry(options);
+        const runTelemetry = this.resolveTelemetry();
         if (pendingResume) {
             const batch = await this.iteratePendingToolCallsConcurrent(pendingResume, toolMap, list, runTelemetry);
             for (const r of batch.results) {
@@ -348,7 +363,7 @@ class AgentRuntime {
                     collectedSubAgentUsage.push(...r.subAgentUsage);
             }
             if (Object.keys(batch.pending).length > 0) {
-                const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, runId);
+                const suspendRunId = await this.persistSuspension(batch.pending, list, totalUsage);
                 return {
                     runId: suspendRunId,
                     messages: list.responseDelta(),
@@ -362,16 +377,17 @@ class AgentRuntime {
                         suspendPayload: s.payload,
                         resumeSchema: s.resumeSchema,
                     })),
+                    getState: () => this.getState(),
                 };
             }
         }
-        const maxIterations = options?.maxIterations ?? MAX_LOOP_ITERATIONS;
+        const maxIterations = this.executionOptions?.maxIterations ?? MAX_LOOP_ITERATIONS;
         for (let i = 0; i < maxIterations; i++) {
             if (this.eventBus.isAborted) {
                 this.updateState({ status: 'cancelled' });
                 throw new Error('Agent run was aborted');
             }
-            this.eventBus.emit({ type: "turn_start" });
+            this.emitEvent({ type: "turn_start" });
             const result = await (0, ai_1.generateText)({
                 model,
                 messages: list.forLlm(this.config.instructions, this.config.instructionProviderOptions),
@@ -381,7 +397,7 @@ class AgentRuntime {
                     ? { providerOptions: providerOptions }
                     : {}),
                 ...(outputSpec ? { output: outputSpec } : {}),
-                ...this.buildTelemetryOptions(options),
+                ...this.buildTelemetryOptions(),
             });
             const aiFinishReason = result.finishReason;
             lastFinishReason = (0, messages_1.fromAiFinishReason)(aiFinishReason);
@@ -403,7 +419,7 @@ class AgentRuntime {
                     collectedSubAgentUsage.push(...r.subAgentUsage);
             }
             if (Object.keys(batch.pending).length > 0) {
-                const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, runId);
+                const suspendRunId = await this.persistSuspension(batch.pending, list, totalUsage);
                 return {
                     runId: suspendRunId,
                     messages: list.responseDelta(),
@@ -417,6 +433,7 @@ class AgentRuntime {
                         suspendPayload: s.payload,
                         resumeSchema: s.resumeSchema,
                     })),
+                    getState: () => this.getState(),
                 };
             }
             this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractToolResults)(list.responseDelta()));
@@ -424,34 +441,36 @@ class AgentRuntime {
         if (lastFinishReason === 'tool-calls') {
             throw new Error(`Agent loop exceeded ${maxIterations} iterations without reaching a stop condition`);
         }
-        await this.saveToMemory(list, options);
-        await this.flushTelemetry(options);
-        if (this.config.titleGeneration && options?.persistence?.threadId && this.config.memory) {
+        await this.saveToMemory(list);
+        await this.flushTelemetry();
+        const persistence = this.currentState.persistence;
+        if (this.config.titleGeneration && persistence?.threadId && this.config.memory) {
             void (0, title_generation_1.generateThreadTitle)({
                 memory: this.config.memory,
-                threadId: options.persistence.threadId,
-                resourceId: options.persistence.resourceId,
+                threadId: persistence.threadId,
+                resourceId: persistence.resourceId,
                 titleConfig: this.config.titleGeneration,
                 agentModel: this.config.model,
                 turnDelta: list.turnDelta(),
             });
         }
         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(list, options, pendingResume, runId) {
+    startStreamLoop(list, pendingResume) {
         const { readable, writable } = new TransformStream();
         const writer = writable.getWriter();
-        this.runStreamLoop(list, options, writer, pendingResume, runId).catch(async (error) => {
-            await this.flushTelemetry(options);
-            await this.cleanupRun(runId);
+        this.runStreamLoop(list, writer, pendingResume).catch(async (error) => {
+            await this.flushTelemetry();
+            await this.cleanupRun();
             try {
                 await writer.write({ type: 'error', error });
                 await writer.write({ type: 'finish', finishReason: 'error' });
@@ -463,8 +482,8 @@ class AgentRuntime {
         });
         return readable;
     }
-    async runStreamLoop(list, options, writer, pendingResume, runId) {
-        const { model, toolMap, aiTools, providerOptions, hasTools, outputSpec } = this.buildLoopContext({ ...options, persistence: options?.persistence });
+    async runStreamLoop(list, writer, pendingResume) {
+        const { model, toolMap, aiTools, providerOptions, hasTools, outputSpec } = this.buildLoopContext();
         const writeChunk = async (chunk) => {
             await writer.write(chunk);
         };
@@ -472,9 +491,9 @@ class AgentRuntime {
         let lastFinishReason = 'stop';
         let structuredOutput;
         const collectedSubAgentUsage = [];
-        const maxIterations = options?.maxIterations ?? MAX_LOOP_ITERATIONS;
+        const maxIterations = this.executionOptions?.maxIterations ?? MAX_LOOP_ITERATIONS;
         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' });
@@ -486,7 +505,7 @@ class AgentRuntime {
             await closeStreamWithError(new Error('Agent run was aborted'), 'cancelled');
             return true;
         };
-        const runTelemetry = this.resolveTelemetry(options);
+        const runTelemetry = this.resolveTelemetry();
         if (pendingResume) {
             try {
                 const batch = await this.iteratePendingToolCallsConcurrent(pendingResume, toolMap, list, runTelemetry);
@@ -508,7 +527,7 @@ class AgentRuntime {
                     });
                 }
                 if (Object.keys(batch.pending).length > 0) {
-                    const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, runId);
+                    const suspendRunId = await this.persistSuspension(batch.pending, list, totalUsage);
                     for (const s of batch.suspensions) {
                         await writer.write({
                             type: 'tool-call-suspended',
@@ -526,7 +545,7 @@ class AgentRuntime {
                 }
             }
             catch (error) {
-                this.eventBus.emit({ type: "error", message: String(error), error });
+                this.emitEvent({ type: "error", message: String(error), error });
                 await closeStreamWithError(error, 'failed');
                 return;
             }
@@ -534,7 +553,7 @@ class AgentRuntime {
         for (let i = 0; i < maxIterations; i++) {
             if (await handleAbort())
                 return;
-            this.eventBus.emit({ type: "turn_start" });
+            this.emitEvent({ type: "turn_start" });
             const result = (0, ai_1.streamText)({
                 model,
                 messages: list.forLlm(this.config.instructions, this.config.instructionProviderOptions),
@@ -544,7 +563,7 @@ class AgentRuntime {
                     ? { providerOptions: providerOptions }
                     : {}),
                 ...(outputSpec ? { output: outputSpec } : {}),
-                ...this.buildTelemetryOptions(options),
+                ...this.buildTelemetryOptions(),
             });
             try {
                 for await (const chunk of result.fullStream) {
@@ -558,7 +577,7 @@ class AgentRuntime {
             catch (streamError) {
                 if (await handleAbort())
                     return;
-                this.eventBus.emit({
+                this.emitEvent({
                     type: "error",
                     message: String(streamError),
                     error: streamError,
@@ -606,7 +625,7 @@ class AgentRuntime {
                     });
                 }
                 if (Object.keys(batch.pending).length > 0) {
-                    const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, runId);
+                    const suspendRunId = await this.persistSuspension(batch.pending, list, totalUsage);
                     for (const s of batch.suspensions) {
                         await writer.write({
                             type: 'tool-call-suspended',
@@ -624,7 +643,7 @@ class AgentRuntime {
                 }
             }
             catch (error) {
-                this.eventBus.emit({ type: "error", message: String(error), error });
+                this.emitEvent({ type: "error", message: String(error), error });
                 await closeStreamWithError(error, 'failed');
                 return;
             }
@@ -645,35 +664,37 @@ class AgentRuntime {
             }),
         });
         try {
-            await this.saveToMemory(list, options);
-            if (this.config.titleGeneration && options?.persistence && this.config.memory) {
+            await this.saveToMemory(list);
+            const persistence = this.currentState.persistence;
+            if (this.config.titleGeneration && persistence && this.config.memory) {
                 void (0, title_generation_1.generateThreadTitle)({
                     memory: this.config.memory,
-                    threadId: options.persistence.threadId,
-                    resourceId: options.persistence.resourceId,
+                    threadId: persistence.threadId,
+                    resourceId: persistence.resourceId,
                     titleConfig: this.config.titleGeneration,
                     agentModel: this.config.model,
                     turnDelta: list.turnDelta(),
                 });
             }
-            await this.cleanupRun(runId);
-            await this.flushTelemetry(options);
+            await this.cleanupRun();
+            await this.flushTelemetry();
             this.updateState({ status: 'success', messageList: list.serialize() });
-            this.eventBus.emit({ type: "agent_end", messages: list.responseDelta() });
+            this.emitEvent({ type: "agent_end", messages: list.responseDelta() });
         }
         finally {
             await writer.close();
         }
     }
-    async saveToMemory(list, options) {
-        if (!this.config.memory || !options?.persistence)
+    async saveToMemory(list) {
+        const persistence = this.currentState.persistence;
+        if (!this.config.memory || !persistence)
             return;
         const delta = list.turnDelta();
         if (delta.length === 0)
             return;
-        await (0, memory_store_1.saveMessagesToThread)(this.config.memory, options.persistence.threadId, options.persistence.resourceId, delta);
+        await (0, memory_store_1.saveMessagesToThread)(this.config.memory, persistence.threadId, persistence.resourceId, delta);
         if (this.config.semanticRecall?.embedder && this.config.memory.saveEmbeddings) {
-            await this.saveEmbeddingsForMessages(options.persistence.threadId, options.persistence.resourceId, delta);
+            await this.saveEmbeddingsForMessages(persistence.threadId, persistence.resourceId, delta);
         }
     }
     async saveEmbeddingsForMessages(threadId, resourceId, messages) {
@@ -943,14 +964,14 @@ class AgentRuntime {
     }
     async processToolCall(toolCallId, toolName, toolInput, toolMap, list, resumeData, resolvedTelemetry) {
         const builtTool = toolMap.get(toolName);
-        this.eventBus.emit({
+        this.emitEvent({
             type: "tool_execution_start",
             toolCallId,
             toolName,
             args: toolInput,
         });
         const makeToolError = (error) => {
-            this.eventBus.emit({
+            this.emitEvent({
                 type: "tool_execution_end",
                 toolCallId,
                 toolName,
@@ -970,7 +991,7 @@ class AgentRuntime {
             .flatMap((m) => m.content.filter((content) => content.type === 'tool-result'));
         const existingToolResult = existingToolResults.find((r) => r.toolCallId === toolCallId);
         if (existingToolResult) {
-            this.eventBus.emit({
+            this.emitEvent({
                 type: "tool_execution_end",
                 toolCallId,
                 toolName,
@@ -1024,7 +1045,7 @@ class AgentRuntime {
             actualResult = toolResult.output;
             extractedSubAgentUsage = toolResult.subAgentUsage;
         }
-        this.eventBus.emit({
+        this.emitEvent({
             type: "tool_execution_end",
             toolCallId,
             toolName,
@@ -1053,8 +1074,8 @@ class AgentRuntime {
             message: toolResultMsg,
         };
     }
-    buildLoopContext(execOptions) {
-        const wmTool = this.buildWorkingMemoryToolForRun(execOptions?.persistence);
+    buildLoopContext() {
+        const wmTool = this.buildWorkingMemoryToolForRun(this.currentState.persistence);
         const allUserTools = wmTool
             ? [...(this.config.tools ?? []), wmTool]
             : (this.config.tools ?? []);
@@ -1065,7 +1086,7 @@ class AgentRuntime {
             model: (0, model_factory_1.createModel)(this.config.model),
             toolMap: (0, tool_adapter_1.buildToolMap)(allUserTools),
             aiTools: allTools,
-            providerOptions: this.buildCallProviderOptions(execOptions?.providerOptions),
+            providerOptions: this.buildCallProviderOptions(this.executionOptions?.providerOptions),
             hasTools: Object.keys(allTools).length > 0,
             outputSpec: this.config.structuredOutput
                 ? ai_1.Output.object({ schema: this.config.structuredOutput })
@@ -1082,30 +1103,31 @@ class AgentRuntime {
             persist: wmParams.persistFn,
         });
     }
-    async persistSuspension(pendingToolCalls, options, list, totalUsage, existingRunId) {
-        const runId = existingRunId ?? (0, run_state_1.generateRunId)();
-        const executionOptions = options?.maxIterations !== undefined ? { maxIterations: options.maxIterations } : undefined;
+    async persistSuspension(pendingToolCalls, list, totalUsage) {
+        const executionOptions = this.executionOptions?.maxIterations !== undefined
+            ? { maxIterations: this.executionOptions.maxIterations }
+            : undefined;
         const state = {
-            persistence: options?.persistence,
+            persistence: this.currentState.persistence,
             status: 'suspended',
             messageList: list.serialize(),
             pendingToolCalls,
             usage: totalUsage,
             executionOptions,
         };
-        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() {
+        if (this.runId) {
+            await this.runState.complete(this.runId);
         }
     }
     emitTurnEnd(newMessages, toolResults) {
         const assistantMsg = newMessages.find((m) => 'role' in m && m.role === 'assistant');
         if (assistantMsg) {
-            this.eventBus.emit({ type: "turn_end", message: assistantMsg, toolResults });
+            this.emitEvent({ type: "turn_end", message: assistantMsg, toolResults });
         }
     }
     updateState(patch) {
@@ -1153,6 +1175,9 @@ class AgentRuntime {
             ...(wmParams.instruction !== undefined && { instruction: wmParams.instruction }),
         };
     }
+    emitEvent(data) {
+        this.eventBus.emit({ ...data, runId: this.runId });
+    }
     resolveWorkingMemoryParams(options) {
         if (!options)
             return null;