@n8n/agents 0.7.1 → 0.8.1

package/dist/runtime/agent-runtime.js

@@ -38,19 +38,27 @@ const ai_1 = require("ai");
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 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 event_bus_1 = require("./event-bus");
 const json_value_1 = require("./json-value");
+const logger_1 = require("./logger");
 const memory_store_1 = require("./memory-store");
 const message_list_1 = require("./message-list");
 const messages_1 = require("./messages");
 const model_factory_1 = require("./model-factory");
+const observation_log_observer_1 = require("./observation-log-observer");
+const observation_log_reflector_1 = require("./observation-log-reflector");
+const observation_log_renderer_1 = require("./observation-log-renderer");
+const observation_log_store_1 = require("./observation-log-store");
 const run_state_1 = require("./run-state");
 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 title_generation_1 = require("./title-generation");
 const tool_adapter_1 = require("./tool-adapter");
-const working_memory_1 = require("./working-memory");
+const observation_log_1 = require("../types/sdk/observation-log");
 const parse_1 = require("../utils/parse");
 const zod_1 = require("../utils/zod");
 function isActiveSpanTracer(value) {
@@ -112,15 +120,29 @@ function buildAgentRootInputAttributes(config) {
     };
 }
 const MAX_LOOP_ITERATIONS = 20;
+const logger = (0, logger_1.createFilteredLogger)();
 const EMPTY_MESSAGE_LIST = {
     messages: [],
     historyIds: [],
     inputIds: [],
     responseIds: [],
 };
+function hasFunctionProperty(value, property) {
+    return property in value && typeof Reflect.get(value, property) === 'function';
+}
+function hasObservationLogObserverMemory(memory) {
+    return ((0, observation_log_store_1.hasObservationLogStore)(memory) &&
+        hasFunctionProperty(memory, 'getMessagesForScope') &&
+        hasFunctionProperty(memory, 'getCursor') &&
+        hasFunctionProperty(memory, 'setCursor'));
+}
 class AgentRuntime {
     constructor(config) {
+        this.backgroundTasks = new background_task_tracker_1.BackgroundTaskTracker();
         this.config = config;
+        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.eventBus = config.eventBus ?? new event_bus_1.AgentEventBus();
         this.currentState = {
@@ -130,6 +152,9 @@ class AgentRuntime {
             pendingToolCalls: {},
         };
     }
+    async dispose() {
+        await this.backgroundTasks.flush();
+    }
     getState() {
         return { ...this.currentState };
     }
@@ -178,7 +203,9 @@ class AgentRuntime {
         const toolCall = state.pendingToolCalls[options.toolCallId];
         if (!toolCall)
             throw new Error(`No tool call found for toolCallId: ${options.toolCallId}`);
-        const tool = this.config.tools?.find((t) => t.name === toolCall.toolName);
+        const list = message_list_1.AgentMessageList.deserialize(state.messageList);
+        this.hydrateDeferredToolsFromList(list);
+        const tool = this.getCurrentTools().find((t) => t.name === toolCall.toolName);
         if (!tool)
             throw new Error(`Tool ${toolCall.toolName} not found`);
         let resumeData = data;
@@ -190,7 +217,6 @@ class AgentRuntime {
             resumeData = parseResult.data;
         }
         try {
-            const list = message_list_1.AgentMessageList.deserialize(state.messageList);
             const { runId: _rid, toolCallId: _tcid, ...callerExecOptions } = options;
             const persisted = state.executionOptions ?? {};
             const mergedExecOptions = {
@@ -209,7 +235,7 @@ class AgentRuntime {
                 messages: state.messageList.messages,
             };
             await this.ensureModelCost();
-            await this.setListWorkingMemoryConfig(list, state.persistence);
+            await this.setListObservationLogMemory(list, state.persistence);
             if (method === 'generate') {
                 const rawResult = await this.withTelemetryRootSpan('generate', resumeOptions, options.runId, async () => await this.runGenerateLoop({
                     list,
@@ -254,6 +280,7 @@ class AgentRuntime {
         if (this.config.memory && options?.persistence?.threadId) {
             const memMessages = await this.config.memory.getMessages(options.persistence.threadId, {
                 limit: this.config.lastMessages ?? 10,
+                resourceId: options.persistence.resourceId,
             });
             if (memMessages.length > 0) {
                 list.addHistory((0, strip_orphaned_tool_messages_1.stripOrphanedToolMessages)(memMessages));
@@ -262,7 +289,7 @@ class AgentRuntime {
         if (this.config.semanticRecall && options?.persistence?.threadId) {
             await this.performSemanticRecall(list, input, options.persistence.threadId, options.persistence.resourceId);
         }
-        await this.setListWorkingMemoryConfig(list, options?.persistence);
+        await this.setListObservationLogMemory(list, options?.persistence);
         list.addInput(input);
         return list;
     }
@@ -353,6 +380,7 @@ class AgentRuntime {
         this.eventBus.emit({ type: "agent_start" });
         await this.ensureModelCost();
         const normalizedInput = (0, runtime_helpers_1.normalizeInput)(input);
+        this.incrementMessageCount(options?.executionCounter);
         return await this.buildMessageList(normalizedInput, options);
     }
     finalizeGenerate(result, list, runId) {
@@ -423,6 +451,31 @@ class AgentRuntime {
             ...this.buildTelemetryMetadataAttributes(t, 'ai.telemetry.metadata'),
         };
     }
+    recordExecutionCounter(fn) {
+        try {
+            fn();
+        }
+        catch {
+        }
+    }
+    incrementMessageCount(counter) {
+        if (!counter)
+            return;
+        this.recordExecutionCounter(() => counter.incrementMessageCount());
+    }
+    incrementToolCallCount(counter) {
+        if (!counter)
+            return;
+        this.recordExecutionCounter(() => counter.incrementToolCallCount());
+    }
+    incrementTokenCount(counter, usage) {
+        if (!counter || !usage)
+            return;
+        const tokenCount = usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
+        if (tokenCount <= 0)
+            return;
+        this.recordExecutionCounter(() => counter.incrementTokenCount(tokenCount));
+    }
     async withTelemetryRootSpan(operation, options, runId, fn) {
         const t = this.resolveTelemetry(options);
         if (!t?.enabled || t.runtimeRootSpanEnabled === false || !isActiveSpanTracer(t.tracer)) {
@@ -478,16 +531,30 @@ class AgentRuntime {
     }
     async runGenerateLoop(ctx) {
         const { list, options, runId, pendingResume } = ctx;
-        const { model, toolMap, aiTools, providerOptions, hasTools, outputSpec, effectiveInstructions, } = this.buildLoopContext({ ...options, persistence: options?.persistence });
+        this.hydrateDeferredToolsFromList(list);
         let totalUsage;
         let lastFinishReason = 'stop';
         let structuredOutput;
         const toolCallSummary = [];
         const collectedSubAgentUsage = [];
         const runTelemetry = this.resolveTelemetry(options);
-        const toolCtx = { toolMap, list, runId, telemetry: runTelemetry };
+        const staticLoopContext = this.buildStaticLoopContext({
+            ...options,
+            persistence: options?.persistence,
+        });
+        const pendingLoopContext = this.buildToolLoopContext(staticLoopContext.aiProviderTools);
+        const pendingToolCtx = {
+            toolMap: pendingLoopContext.toolMap,
+            list,
+            runId,
+            telemetry: runTelemetry,
+            executionCounter: options?.executionCounter,
+        };
         if (pendingResume) {
-            const batch = await this.iteratePendingToolCallsConcurrent({ ...toolCtx, pendingResume });
+            const batch = await this.iteratePendingToolCallsConcurrent({
+                ...pendingToolCtx,
+                pendingResume,
+            });
             for (const r of batch.results) {
                 toolCallSummary.push(r.toolEntry);
                 if (r.subAgentUsage)
@@ -518,32 +585,38 @@ class AgentRuntime {
                 throw new Error('Agent run was aborted');
             }
             this.eventBus.emit({ type: "turn_start" });
+            const { toolMap, aiTools, hasTools, effectiveInstructions } = this.buildToolLoopContext(staticLoopContext.aiProviderTools);
             const result = await (0, ai_1.generateText)({
-                model,
+                model: staticLoopContext.model,
                 messages: list.forLlm(effectiveInstructions, this.config.instructionProviderOptions),
                 abortSignal: this.eventBus.signal,
                 ...(hasTools ? { tools: aiTools } : {}),
-                ...(providerOptions
-                    ? { providerOptions: providerOptions }
+                ...(staticLoopContext.providerOptions
+                    ? { providerOptions: staticLoopContext.providerOptions }
                     : {}),
-                ...(outputSpec ? { output: outputSpec } : {}),
+                ...(staticLoopContext.outputSpec ? { output: staticLoopContext.outputSpec } : {}),
                 ...this.buildTelemetryOptions(options),
             });
             const aiFinishReason = result.finishReason;
             lastFinishReason = (0, messages_1.fromAiFinishReason)(aiFinishReason);
             totalUsage = (0, runtime_helpers_1.accumulateUsage)(totalUsage, result.usage);
+            this.incrementTokenCount(options?.executionCounter, result.usage);
             const responseMessages = result.response.messages;
             const newMessages = (0, messages_1.fromAiMessages)(responseMessages);
             list.addResponse(newMessages);
             if (aiFinishReason !== 'tool-calls') {
-                if (outputSpec) {
+                if (staticLoopContext.outputSpec) {
                     structuredOutput = result.output;
                 }
                 this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractSettledToolCalls)(newMessages));
                 break;
             }
             const batch = await this.iterateToolCallsConcurrent({
-                ...toolCtx,
+                toolMap,
+                list,
+                runId,
+                telemetry: runTelemetry,
+                executionCounter: options?.executionCounter,
                 toolCalls: result.toolCalls,
             });
             for (const r of batch.results) {
@@ -584,6 +657,7 @@ class AgentRuntime {
                 agentModel: this.config.model,
                 turnDelta: list.turnDelta(),
             });
+            this.backgroundTasks.track(titlePromise);
             if (this.config.titleGeneration.sync) {
                 await titlePromise;
             }
@@ -634,7 +708,7 @@ class AgentRuntime {
     }
     async runStreamLoop(ctx) {
         const { list, options, runId, pendingResume, writer } = ctx;
-        const { model, toolMap, aiTools, providerOptions, hasTools, outputSpec, effectiveInstructions, } = this.buildLoopContext({ ...options, persistence: options?.persistence });
+        this.hydrateDeferredToolsFromList(list);
         const writeChunk = async (chunk) => {
             await writer.write(chunk);
         };
@@ -657,11 +731,22 @@ class AgentRuntime {
             return true;
         };
         const runTelemetry = this.resolveTelemetry(options);
-        const toolCtx = { toolMap, list, runId, telemetry: runTelemetry };
+        const staticLoopContext = this.buildStaticLoopContext({
+            ...options,
+            persistence: options?.persistence,
+        });
+        const pendingLoopContext = this.buildToolLoopContext(staticLoopContext.aiProviderTools);
+        const pendingToolCtx = {
+            toolMap: pendingLoopContext.toolMap,
+            list,
+            runId,
+            telemetry: runTelemetry,
+            executionCounter: options?.executionCounter,
+        };
         if (pendingResume) {
             try {
                 const batch = await this.iteratePendingToolCallsConcurrent({
-                    ...toolCtx,
+                    ...pendingToolCtx,
                     pendingResume,
                 });
                 for (const r of batch.results) {
@@ -714,16 +799,17 @@ class AgentRuntime {
             if (await handleAbort())
                 return;
             this.eventBus.emit({ type: "turn_start" });
+            const { toolMap, aiTools, hasTools, effectiveInstructions } = this.buildToolLoopContext(staticLoopContext.aiProviderTools);
             const messages = list.forLlm(effectiveInstructions, this.config.instructionProviderOptions);
             const result = (0, ai_1.streamText)({
-                model,
+                model: staticLoopContext.model,
                 messages,
                 abortSignal: this.eventBus.signal,
                 ...(hasTools ? { tools: aiTools } : {}),
-                ...(providerOptions
-                    ? { providerOptions: providerOptions }
+                ...(staticLoopContext.providerOptions
+                    ? { providerOptions: staticLoopContext.providerOptions }
                     : {}),
-                ...(outputSpec ? { output: outputSpec } : {}),
+                ...(staticLoopContext.outputSpec ? { output: staticLoopContext.outputSpec } : {}),
                 ...this.buildTelemetryOptions(options),
             });
             try {
@@ -753,11 +839,12 @@ class AgentRuntime {
             const response = await result.response;
             lastFinishReason = (0, messages_1.fromAiFinishReason)(aiFinishReason);
             totalUsage = (0, runtime_helpers_1.accumulateUsage)(totalUsage, usage);
+            this.incrementTokenCount(options?.executionCounter, usage);
             const responseMessages = response.messages;
             const newMessages = (0, messages_1.fromAiMessages)(responseMessages);
             list.addResponse(newMessages);
             if (aiFinishReason !== 'tool-calls') {
-                if (outputSpec) {
+                if (staticLoopContext.outputSpec) {
                     structuredOutput = await result.output;
                 }
                 this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractSettledToolCalls)(newMessages));
@@ -765,7 +852,14 @@ class AgentRuntime {
             }
             const toolCalls = await result.toolCalls;
             try {
-                const batch = await this.iterateToolCallsConcurrent({ ...toolCtx, toolCalls });
+                const batch = await this.iterateToolCallsConcurrent({
+                    toolMap,
+                    list,
+                    runId,
+                    telemetry: runTelemetry,
+                    executionCounter: options?.executionCounter,
+                    toolCalls,
+                });
                 if (await handleAbort())
                     return;
                 for (const r of batch.results) {
@@ -840,6 +934,7 @@ class AgentRuntime {
                     agentModel: this.config.model,
                     turnDelta: list.turnDelta(),
                 });
+                this.backgroundTasks.track(titlePromise);
                 if (this.config.titleGeneration.sync) {
                     await titlePromise;
                 }
@@ -863,6 +958,67 @@ class AgentRuntime {
         if (this.config.semanticRecall?.embedder && this.config.memory.saveEmbeddings) {
             await this.saveEmbeddingsForMessages(options.persistence.threadId, options.persistence.resourceId, delta);
         }
+        this.scheduleObservationLogJobs(options.persistence);
+    }
+    scheduleObservationLogJobs(persistence) {
+        const { memory, observationalMemory } = this.config;
+        if (!memory || !observationalMemory || !(0, observation_log_store_1.hasObservationLogStore)(memory))
+            return;
+        const scope = this.getObservationLogScope(persistence);
+        const runner = this.getMemoryTaskRunner(memory, observationalMemory);
+        const observe = observationalMemory.observe;
+        const observerThresholdTokens = observationalMemory.observerThresholdTokens;
+        if (observe &&
+            observerThresholdTokens !== undefined &&
+            hasObservationLogObserverMemory(memory)) {
+            runner.schedule({ ...scope, taskKind: 'observer' }, async () => await (0, observation_log_observer_1.runObservationLogObserver)({
+                memory,
+                ...scope,
+                observerThresholdTokens,
+                observationLogTailLimit: observationalMemory.observationLogTailLimit ?? 0,
+                observe,
+                messageSource: {
+                    threadId: persistence.threadId,
+                    resourceId: persistence.resourceId,
+                },
+            }));
+        }
+        const reflect = observationalMemory.reflect;
+        const reflectorThresholdTokens = observationalMemory.reflectorThresholdTokens;
+        if (reflect && reflectorThresholdTokens !== undefined) {
+            runner.schedule({ ...scope, taskKind: 'reflector' }, async () => await (0, observation_log_reflector_1.runObservationLogReflector)({
+                memory,
+                ...scope,
+                reflectorThresholdTokens,
+                reflect,
+            }));
+        }
+    }
+    getMemoryTaskRunner(memory, observationalMemory) {
+        this.memoryTasks ??= new scoped_memory_task_runner_1.ScopedMemoryTaskRunner({
+            tracker: this.backgroundTasks,
+            lockStore: (0, observation_log_store_1.hasObservationLogTaskLockStore)(memory) ? memory : undefined,
+            lockTtlMs: observationalMemory.lockTtlMs,
+            onEvent: (event) => {
+                if (event.type !== 'failed')
+                    return;
+                const source = event.task.taskKind;
+                const message = `Observation log ${source} task failed`;
+                logger.warn(message, {
+                    error: event.error,
+                    scopeKind: event.task.scopeKind,
+                    scopeId: event.task.scopeId,
+                });
+                this.eventBus.emit({ type: "error", message, error: event.error, source });
+            },
+        });
+        return this.memoryTasks;
+    }
+    getObservationLogScope(persistence) {
+        return {
+            scopeKind: 'thread',
+            scopeId: (0, observation_log_1.createObservationLogThreadScopeId)(persistence.threadId, persistence.resourceId),
+        };
     }
     async saveEmbeddingsForMessages(threadId, resourceId, messages) {
         const embeddable = [];
@@ -908,12 +1064,12 @@ class AgentRuntime {
         switch (provider) {
             case 'anthropic': {
                 const cfg = thinking;
+                if (cfg.mode === 'adaptive') {
+                    return { anthropic: { thinking: { type: 'adaptive' } } };
+                }
                 return {
                     anthropic: {
-                        thinking: {
-                            type: 'enabled',
-                            budgetTokens: cfg.budgetTokens ?? 10000,
-                        },
+                        thinking: { type: 'enabled', budgetTokens: cfg.budgetTokens ?? 10000 },
                     },
                 };
             }
@@ -960,8 +1116,12 @@ class AgentRuntime {
         return merged;
     }
     async iterateToolCallsConcurrent(ctx) {
-        const { toolCalls, toolMap, list, runId, telemetry: resolvedTelemetry } = ctx;
+        const { toolCalls, toolMap, list, runId, telemetry: resolvedTelemetry, executionCounter } = ctx;
         const executableCalls = toolCalls.filter((tc) => !tc.providerExecuted);
+        const providerExecutedCount = toolCalls.length - executableCalls.length;
+        for (let i = 0; i < providerExecutedCount; i++) {
+            this.incrementToolCallCount(executionCounter);
+        }
         const executableCallsById = new Map(executableCalls.map((tc) => [tc.toolCallId, tc]));
         const unexecutedIds = new Set(executableCalls.map((tc) => tc.toolCallId));
         const batchSize = this.concurrency;
@@ -975,7 +1135,7 @@ class AgentRuntime {
                 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, undefined, resolvedTelemetry)));
+            const settledResults = await Promise.allSettled(batch.map(async (tc) => await this.processToolCall(tc.toolCallId, tc.toolName, tc.input, toolMap, list, undefined, resolvedTelemetry, executionCounter, true)));
             for (const tc of batch) {
                 unexecutedIds.delete(tc.toolCallId);
             }
@@ -1050,7 +1210,7 @@ class AgentRuntime {
         return { results, suspensions, errors, pending };
     }
     async iteratePendingToolCallsConcurrent(ctx) {
-        const { pendingResume, toolMap, list, runId, telemetry: resolvedTelemetry } = ctx;
+        const { pendingResume, toolMap, list, runId, telemetry: resolvedTelemetry, executionCounter, } = ctx;
         const resumedId = pendingResume.resumeToolCallId;
         const resumedEntry = pendingResume.pendingToolCalls[resumedId];
         if (!resumedEntry) {
@@ -1061,7 +1221,7 @@ class AgentRuntime {
         const suspensions = [];
         const errors = [];
         const pending = {};
-        const processResult = await this.processToolCall(resumedEntry.toolCallId, resumedToolName, resumedEntry.input, toolMap, list, pendingResume.resumeData, resolvedTelemetry);
+        const processResult = await this.processToolCall(resumedEntry.toolCallId, resumedToolName, resumedEntry.input, toolMap, list, pendingResume.resumeData, resolvedTelemetry, executionCounter, false);
         if (processResult.outcome === 'suspended') {
             pending[resumedId] = {
                 ...resumedEntry,
@@ -1129,6 +1289,7 @@ class AgentRuntime {
                 list,
                 runId,
                 telemetry: resolvedTelemetry,
+                executionCounter,
             });
             results.push(...batch.results);
             suspensions.push(...batch.suspensions);
@@ -1137,7 +1298,7 @@ class AgentRuntime {
         }
         return { results, suspensions, errors, pending };
     }
-    async processToolCall(toolCallId, toolName, toolInput, toolMap, list, resumeData, resolvedTelemetry) {
+    async processToolCall(toolCallId, toolName, toolInput, toolMap, list, resumeData, resolvedTelemetry, executionCounter, countToolCall = true) {
         const builtTool = toolMap.get(toolName);
         this.eventBus.emit({
             type: "tool_execution_start",
@@ -1180,6 +1341,9 @@ class AgentRuntime {
             });
             return { outcome: 'noop' };
         }
+        if (countToolCall) {
+            this.incrementToolCallCount(executionCounter);
+        }
         if (builtTool.inputSchema) {
             const result = await (0, parse_1.parseWithSchema)(builtTool.inputSchema, toolInput);
             if (!result.success) {
@@ -1252,27 +1416,47 @@ class AgentRuntime {
             customMessage,
         };
     }
-    buildLoopContext(execOptions) {
-        const wmTool = this.buildWorkingMemoryToolForRun(execOptions?.persistence);
-        const allUserTools = wmTool
-            ? [...(this.config.tools ?? []), wmTool]
-            : (this.config.tools ?? []);
-        const aiTools = (0, tool_adapter_1.toAiSdkTools)(allUserTools);
+    buildStaticLoopContext(execOptions) {
         const aiProviderTools = (0, tool_adapter_1.toAiSdkProviderTools)(this.config.providerTools);
-        const allTools = { ...aiTools, ...aiProviderTools };
         const model = (0, model_factory_1.createModel)(this.config.model);
         return {
             model,
-            toolMap: (0, tool_adapter_1.buildToolMap)(allUserTools),
-            aiTools: allTools,
+            aiProviderTools,
             providerOptions: this.buildCallProviderOptions(execOptions?.providerOptions),
-            hasTools: Object.keys(allTools).length > 0,
             outputSpec: this.config.structuredOutput
                 ? ai_1.Output.object({ schema: this.config.structuredOutput })
                 : undefined,
-            effectiveInstructions: this.composeEffectiveInstructions(allUserTools),
         };
     }
+    buildToolLoopContext(aiProviderTools) {
+        const allUserTools = this.getCurrentTools();
+        const aiTools = (0, tool_adapter_1.toAiSdkTools)(allUserTools);
+        const allTools = { ...aiTools, ...aiProviderTools };
+        const aiToolCount = Object.keys(allTools).length;
+        const toolMap = (0, tool_adapter_1.buildToolMap)(allUserTools);
+        const effectiveInstructions = this.composeEffectiveInstructions(allUserTools);
+        return {
+            toolMap,
+            aiTools: allTools,
+            hasTools: aiToolCount > 0,
+            effectiveInstructions,
+        };
+    }
+    getCurrentTools() {
+        const baseTools = this.config.tools ?? [];
+        if (!this.deferredToolManager?.hasTools)
+            return baseTools;
+        return [
+            ...baseTools,
+            ...this.deferredToolManager.getControllerTools(),
+            ...this.deferredToolManager.getLoadedTools(),
+        ];
+    }
+    hydrateDeferredToolsFromList(list) {
+        if (!this.deferredToolManager?.hasTools)
+            return;
+        this.deferredToolManager.hydrateLoadedToolsFromMessages(list.serialize().messages);
+    }
     composeEffectiveInstructions(tools) {
         const fragments = tools
             .map((t) => t.systemInstruction)
@@ -1283,16 +1467,6 @@ 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;
     }
-    buildWorkingMemoryToolForRun(persistence) {
-        const wmParams = this.resolveWorkingMemoryParams(persistence);
-        if (!wmParams)
-            return undefined;
-        return (0, working_memory_1.buildWorkingMemoryTool)({
-            structured: wmParams.structured,
-            schema: wmParams.schema,
-            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;
@@ -1352,46 +1526,22 @@ class AgentRuntime {
             return usage;
         return { ...usage, cost: (0, catalog_1.computeCost)(usage, this.modelCost) };
     }
-    async setListWorkingMemoryConfig(list, options) {
-        const wmParams = this.resolveWorkingMemoryParams(options);
-        if (!wmParams || !this.config.memory?.getWorkingMemory)
+    async setListObservationLogMemory(list, options) {
+        const memory = this.config.memory;
+        if (!memory || !options?.threadId || !(0, observation_log_store_1.hasObservationLogStore)(memory))
             return;
-        const wmState = await this.config.memory.getWorkingMemory(wmParams.memoryParams);
-        list.workingMemory = {
-            template: wmParams.template,
-            structured: wmParams.structured,
-            state: wmState,
-            ...(wmParams.instruction !== undefined && { instruction: wmParams.instruction }),
-        };
+        const scope = this.getObservationLogScope(options);
+        const observations = await memory.getActiveObservationLog({
+            ...scope,
+            order: 'asc',
+        });
+        list.observationLogMemory =
+            (0, observation_log_renderer_1.renderObservationLog)(observations, {
+                renderTokenBudget: this.config.observationLog?.renderTokenBudget,
+            }) ?? undefined;
     }
-    resolveWorkingMemoryParams(options) {
-        if (!options)
-            return null;
-        if (!this.config.workingMemory)
-            return null;
-        const scope = this.config.workingMemory?.scope ?? 'resource';
-        if (scope === 'resource' && !options.resourceId) {
-            throw new Error('Working memory scope is "resource" but no resourceId was provided. ' +
-                'Pass a resourceId in RunOptions or change the scope to "thread".');
-        }
-        if (!options)
-            return null;
-        const memoryParams = { ...options, scope };
-        const persistFn = this.config.workingMemory && this.config.memory?.saveWorkingMemory && options
-            ? async (content) => {
-                await this.config.memory.saveWorkingMemory(memoryParams, content);
-            }
-            : undefined;
-        if (!persistFn)
-            return null;
-        return {
-            persistFn,
-            memoryParams,
-            template: this.config.workingMemory.template,
-            structured: this.config.workingMemory.structured,
-            schema: this.config.workingMemory.schema,
-            instruction: this.config.workingMemory.instruction,
-        };
+    getConfiguredTelemetry() {
+        return this.config.telemetry;
     }
 }
 exports.AgentRuntime = AgentRuntime;