@n8n/agents 0.5.2 → 0.7.0

package/dist/runtime/agent-runtime.js

@@ -32,17 +32,14 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentRuntime = void 0;
 const ai_1 = require("ai");
-const ajv_1 = __importDefault(require("ajv"));
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 const catalog_1 = require("../sdk/catalog");
 const message_1 = require("../sdk/message");
 const event_bus_1 = require("./event-bus");
+const json_value_1 = require("./json-value");
 const memory_store_1 = require("./memory-store");
 const message_list_1 = require("./message-list");
 const messages_1 = require("./messages");
@@ -54,9 +51,67 @@ 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 parse_1 = require("../utils/parse");
 const zod_1 = require("../utils/zod");
+function isActiveSpanTracer(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        typeof Reflect.get(value, 'startActiveSpan') === 'function');
+}
+function stringifyTelemetryValue(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function getToolInputSchema(tool) {
+    if (!tool.inputSchema) {
+        return undefined;
+    }
+    return (0, zod_1.isZodSchema)(tool.inputSchema) ? (0, zod_to_json_schema_1.zodToJsonSchema)(tool.inputSchema) : tool.inputSchema;
+}
+function summarizeToolForTelemetry(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        type: tool.mcpTool ? 'mcp' : 'local',
+        ...(tool.mcpServerName ? { mcp_server: tool.mcpServerName } : {}),
+        ...(tool.suspendSchema || tool.resumeSchema || tool.withDefaultApproval
+            ? { approval: true }
+            : {}),
+        ...(tool.inputSchema ? { input_schema: getToolInputSchema(tool) } : {}),
+    };
+}
+function summarizeProviderToolForTelemetry(tool) {
+    const [provider] = tool.name.split('.');
+    return {
+        name: tool.name,
+        provider,
+        type: 'provider',
+        args: tool.args,
+        ...(tool.inputSchema ? { input_schema: getToolInputSchema(tool) } : {}),
+    };
+}
+function buildAgentRootInputAttributes(config) {
+    const localTools = (config.tools ?? []).map(summarizeToolForTelemetry);
+    const providerTools = (config.providerTools ?? []).map(summarizeProviderToolForTelemetry);
+    const tools = [...localTools, ...providerTools];
+    const toolNames = tools
+        .map((tool) => (typeof tool.name === 'string' ? tool.name : undefined))
+        .filter((name) => name !== undefined);
+    const serialized = stringifyTelemetryValue({
+        agent: config.name,
+        tool_count: tools.length,
+        tools,
+    });
+    return {
+        ...(toolNames.length > 0 ? { 'langsmith.metadata.available_tools': toolNames } : {}),
+        ...(serialized ? { 'gen_ai.prompt': serialized } : {}),
+    };
+}
 const MAX_LOOP_ITERATIONS = 20;
-const ajv = new ajv_1.default({ strict: false });
 const EMPTY_MESSAGE_LIST = {
     messages: [],
     historyIds: [],
@@ -85,8 +140,9 @@ class AgentRuntime {
         const runId = (0, run_state_1.generateRunId)();
         let list = undefined;
         try {
-            list = await this.initRun(input, options);
-            const rawResult = await this.runGenerateLoop(list, options, undefined, runId);
+            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);
         }
         catch (error) {
@@ -113,7 +169,7 @@ class AgentRuntime {
             }
             return { runId, stream: (0, runtime_helpers_1.makeErrorStream)(error) };
         }
-        return { runId, stream: this.startStreamLoop(list, options, undefined, runId) };
+        return { runId, stream: this.startStreamLoop({ list, options, runId }) };
     }
     async resume(method, data, options) {
         const state = await this.runState.resume(options.runId);
@@ -127,9 +183,9 @@ class AgentRuntime {
             throw new Error(`Tool ${toolCall.toolName} not found`);
         let resumeData = data;
         if (tool.resumeSchema) {
-            const parseResult = await tool.resumeSchema.safeParseAsync(data);
+            const parseResult = await (0, parse_1.parseWithSchema)(tool.resumeSchema, data);
             if (!parseResult.success) {
-                throw new Error(`Invalid resume payload: ${parseResult.error.message}`);
+                throw new Error(`Invalid resume payload: ${parseResult.error}`);
             }
             resumeData = parseResult.data;
         }
@@ -155,7 +211,12 @@ 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.withTelemetryRootSpan('generate', resumeOptions, options.runId, async () => await this.runGenerateLoop({
+                    list,
+                    options: resumeOptions,
+                    runId: options.runId,
+                    pendingResume,
+                }));
                 if (!rawResult.pendingSuspend) {
                     await this.cleanupRun(options.runId);
                 }
@@ -163,7 +224,12 @@ class AgentRuntime {
             }
             return {
                 runId: options.runId,
-                stream: this.startStreamLoop(list, resumeOptions, pendingResume, options.runId),
+                stream: this.startStreamLoop({
+                    list,
+                    options: resumeOptions,
+                    runId: options.runId,
+                    pendingResume,
+                }),
             };
         }
         catch (error) {
@@ -332,16 +398,96 @@ class AgentRuntime {
             },
         };
     }
-    async runGenerateLoop(list, options, pendingResume, runId) {
-        const { model, toolMap, aiTools, providerOptions, hasTools, outputSpec } = this.buildLoopContext({ ...options, persistence: options?.persistence });
+    buildTelemetryRootAttributes(t, spanName, runId) {
+        const metadataAttributes = this.buildTelemetryMetadataAttributes(t, 'langsmith.metadata');
+        return {
+            'langsmith.traceable': 'true',
+            'langsmith.trace.name': spanName,
+            'langsmith.span.kind': 'chain',
+            'langsmith.metadata.agent_name': this.config.name,
+            'langsmith.metadata.agent_run_id': runId,
+            ...metadataAttributes,
+            ...buildAgentRootInputAttributes(this.config),
+        };
+    }
+    buildTelemetryMetadataAttributes(t, prefix) {
+        return Object.fromEntries(Object.entries(t.metadata ?? {}).map(([key, value]) => [`${prefix}.${key}`, value]));
+    }
+    buildAiSdkOperationAttributes(operationId, t) {
+        const functionId = t.functionId ?? this.config.name;
+        return {
+            'operation.name': `${operationId} ${functionId}`,
+            'resource.name': functionId,
+            'ai.operationId': operationId,
+            'ai.telemetry.functionId': functionId,
+            ...this.buildTelemetryMetadataAttributes(t, 'ai.telemetry.metadata'),
+        };
+    }
+    async withTelemetryRootSpan(operation, options, runId, fn) {
+        const t = this.resolveTelemetry(options);
+        if (!t?.enabled || t.runtimeRootSpanEnabled === false || !isActiveSpanTracer(t.tracer)) {
+            return await fn();
+        }
+        const spanName = `${t.functionId ?? this.config.name}.${operation}`;
+        return await t.tracer.startActiveSpan(spanName, { attributes: this.buildTelemetryRootAttributes(t, spanName, runId) }, async (span) => {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                span.recordException?.(error);
+                span.setStatus?.({ code: 2, message: String(error) });
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    async withTelemetryToolSpan(toolCallId, toolName, input, t, fn) {
+        if (!t?.enabled || !isActiveSpanTracer(t.tracer)) {
+            return await fn();
+        }
+        const shouldRecordInputs = t.recordInputs ?? true;
+        const inputValue = shouldRecordInputs ? stringifyTelemetryValue(input) : undefined;
+        return await t.tracer.startActiveSpan('ai.toolCall', {
+            attributes: {
+                ...this.buildAiSdkOperationAttributes('ai.toolCall', t),
+                'ai.toolCall.name': toolName,
+                'ai.toolCall.id': toolCallId,
+                ...(inputValue !== undefined ? { 'ai.toolCall.args': inputValue } : {}),
+            },
+        }, async (span) => {
+            try {
+                const result = await fn();
+                const shouldRecordOutputs = t.recordOutputs ?? true;
+                const outputValue = shouldRecordOutputs ? stringifyTelemetryValue(result) : undefined;
+                if (outputValue !== undefined) {
+                    span.setAttributes?.({ 'ai.toolCall.result': outputValue });
+                }
+                return result;
+            }
+            catch (error) {
+                span.recordException?.(error);
+                span.setStatus?.({ code: 2, message: String(error) });
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    async runGenerateLoop(ctx) {
+        const { list, options, runId, pendingResume } = ctx;
+        const { model, toolMap, aiTools, providerOptions, hasTools, outputSpec, effectiveInstructions, } = this.buildLoopContext({ ...options, persistence: options?.persistence });
         let totalUsage;
         let lastFinishReason = 'stop';
         let structuredOutput;
         const toolCallSummary = [];
         const collectedSubAgentUsage = [];
         const runTelemetry = this.resolveTelemetry(options);
+        const toolCtx = { toolMap, list, runId, telemetry: runTelemetry };
         if (pendingResume) {
-            const batch = await this.iteratePendingToolCallsConcurrent(pendingResume, toolMap, list, runTelemetry);
+            const batch = await this.iteratePendingToolCallsConcurrent({ ...toolCtx, pendingResume });
             for (const r of batch.results) {
                 toolCallSummary.push(r.toolEntry);
                 if (r.subAgentUsage)
@@ -374,7 +520,7 @@ class AgentRuntime {
             this.eventBus.emit({ type: "turn_start" });
             const result = await (0, ai_1.generateText)({
                 model,
-                messages: list.forLlm(this.config.instructions, this.config.instructionProviderOptions),
+                messages: list.forLlm(effectiveInstructions, this.config.instructionProviderOptions),
                 abortSignal: this.eventBus.signal,
                 ...(hasTools ? { tools: aiTools } : {}),
                 ...(providerOptions
@@ -393,10 +539,13 @@ class AgentRuntime {
                 if (outputSpec) {
                     structuredOutput = result.output;
                 }
-                this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractToolResults)(newMessages));
+                this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractSettledToolCalls)(newMessages));
                 break;
             }
-            const batch = await this.iterateToolCallsConcurrent(result.toolCalls, toolMap, list, runTelemetry);
+            const batch = await this.iterateToolCallsConcurrent({
+                ...toolCtx,
+                toolCalls: result.toolCalls,
+            });
             for (const r of batch.results) {
                 toolCallSummary.push(r.toolEntry);
                 if (r.subAgentUsage)
@@ -419,7 +568,7 @@ class AgentRuntime {
                     })),
                 };
             }
-            this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractToolResults)(list.responseDelta()));
+            this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractSettledToolCalls)(list.responseDelta()));
         }
         if (lastFinishReason === 'tool-calls') {
             throw new Error(`Agent loop exceeded ${maxIterations} iterations without reaching a stop condition`);
@@ -427,7 +576,7 @@ class AgentRuntime {
         await this.saveToMemory(list, options);
         await this.flushTelemetry(options);
         if (this.config.titleGeneration && options?.persistence?.threadId && this.config.memory) {
-            void (0, title_generation_1.generateThreadTitle)({
+            const titlePromise = (0, title_generation_1.generateThreadTitle)({
                 memory: this.config.memory,
                 threadId: options.persistence.threadId,
                 resourceId: options.persistence.resourceId,
@@ -435,6 +584,9 @@ class AgentRuntime {
                 agentModel: this.config.model,
                 turnDelta: list.turnDelta(),
             });
+            if (this.config.titleGeneration.sync) {
+                await titlePromise;
+            }
         }
         return {
             runId: runId ?? '',
@@ -446,10 +598,24 @@ class AgentRuntime {
             ...(collectedSubAgentUsage.length > 0 && { subAgentUsage: collectedSubAgentUsage }),
         };
     }
-    startStreamLoop(list, options, pendingResume, runId) {
+    startStreamLoop(ctx) {
+        const { options, runId } = ctx;
         const { readable, writable } = new TransformStream();
         const writer = writable.getWriter();
-        this.runStreamLoop(list, options, writer, pendingResume, runId).catch(async (error) => {
+        const onToolExecutionStart = (data) => {
+            if (data.type !== "tool_execution_start")
+                return;
+            writer
+                .write({
+                type: 'tool-execution-start',
+                toolCallId: data.toolCallId,
+                toolName: data.toolName,
+            })
+                .catch(() => { });
+        };
+        this.eventBus.on("tool_execution_start", onToolExecutionStart);
+        this.withTelemetryRootSpan('stream', options, runId, async () => await this.runStreamLoop({ ...ctx, writer }))
+            .catch(async (error) => {
             await this.flushTelemetry(options);
             await this.cleanupRun(runId);
             try {
@@ -460,11 +626,15 @@ class AgentRuntime {
             catch {
                 writer.abort(error).catch(() => { });
             }
+        })
+            .finally(() => {
+            this.eventBus.off("tool_execution_start", onToolExecutionStart);
         });
         return readable;
     }
-    async runStreamLoop(list, options, writer, pendingResume, runId) {
-        const { model, toolMap, aiTools, providerOptions, hasTools, outputSpec } = this.buildLoopContext({ ...options, persistence: options?.persistence });
+    async runStreamLoop(ctx) {
+        const { list, options, runId, pendingResume, writer } = ctx;
+        const { model, toolMap, aiTools, providerOptions, hasTools, outputSpec, effectiveInstructions, } = this.buildLoopContext({ ...options, persistence: options?.persistence });
         const writeChunk = async (chunk) => {
             await writer.write(chunk);
         };
@@ -487,15 +657,21 @@ class AgentRuntime {
             return true;
         };
         const runTelemetry = this.resolveTelemetry(options);
+        const toolCtx = { toolMap, list, runId, telemetry: runTelemetry };
         if (pendingResume) {
             try {
-                const batch = await this.iteratePendingToolCallsConcurrent(pendingResume, toolMap, list, runTelemetry);
+                const batch = await this.iteratePendingToolCallsConcurrent({
+                    ...toolCtx,
+                    pendingResume,
+                });
                 for (const r of batch.results) {
                     if (r.subAgentUsage)
                         collectedSubAgentUsage.push(...r.subAgentUsage);
                     await writer.write({
-                        type: 'message',
-                        message: r.message,
+                        type: 'tool-result',
+                        toolCallId: r.toolCallId,
+                        toolName: r.toolName,
+                        output: r.modelOutput,
                     });
                     if (r.customMessage) {
                         await writer.write({ type: 'message', message: r.customMessage });
@@ -503,8 +679,11 @@ class AgentRuntime {
                 }
                 for (const e of batch.errors) {
                     await writer.write({
-                        type: 'message',
-                        message: e.message,
+                        type: 'tool-result',
+                        toolCallId: e.toolCallId,
+                        toolName: e.toolName,
+                        output: e.error,
+                        isError: true,
                     });
                 }
                 if (Object.keys(batch.pending).length > 0) {
@@ -535,9 +714,10 @@ class AgentRuntime {
             if (await handleAbort())
                 return;
             this.eventBus.emit({ type: "turn_start" });
+            const messages = list.forLlm(effectiveInstructions, this.config.instructionProviderOptions);
             const result = (0, ai_1.streamText)({
                 model,
-                messages: list.forLlm(this.config.instructions, this.config.instructionProviderOptions),
+                messages,
                 abortSignal: this.eventBus.signal,
                 ...(hasTools ? { tools: aiTools } : {}),
                 ...(providerOptions
@@ -548,7 +728,7 @@ class AgentRuntime {
             });
             try {
                 for await (const chunk of result.fullStream) {
-                    if (chunk.type === 'finish' || chunk.type === 'finish-step')
+                    if (chunk.type === 'finish')
                         continue;
                     const converted = (0, stream_1.convertChunk)(chunk);
                     if (converted)
@@ -580,20 +760,22 @@ class AgentRuntime {
                 if (outputSpec) {
                     structuredOutput = await result.output;
                 }
-                this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractToolResults)(newMessages));
+                this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractSettledToolCalls)(newMessages));
                 break;
             }
             const toolCalls = await result.toolCalls;
             try {
-                const batch = await this.iterateToolCallsConcurrent(toolCalls, toolMap, list, runTelemetry);
+                const batch = await this.iterateToolCallsConcurrent({ ...toolCtx, toolCalls });
                 if (await handleAbort())
                     return;
                 for (const r of batch.results) {
                     if (r.subAgentUsage)
                         collectedSubAgentUsage.push(...r.subAgentUsage);
                     await writer.write({
-                        type: 'message',
-                        message: r.message,
+                        type: 'tool-result',
+                        toolCallId: r.toolCallId,
+                        toolName: r.toolName,
+                        output: r.modelOutput,
                     });
                     if (r.customMessage) {
                         await writer.write({ type: 'message', message: r.customMessage });
@@ -601,8 +783,11 @@ class AgentRuntime {
                 }
                 for (const e of batch.errors) {
                     await writer.write({
-                        type: 'message',
-                        message: e.message,
+                        type: 'tool-result',
+                        toolCallId: e.toolCallId,
+                        toolName: e.toolName,
+                        output: e.error,
+                        isError: true,
                     });
                 }
                 if (Object.keys(batch.pending).length > 0) {
@@ -628,7 +813,7 @@ class AgentRuntime {
                 await closeStreamWithError(error, 'failed');
                 return;
             }
-            this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractToolResults)(list.responseDelta()));
+            this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractSettledToolCalls)(list.responseDelta()));
         }
         const costUsage = this.applyCost(totalUsage);
         const parentCost = costUsage?.cost ?? 0;
@@ -647,7 +832,7 @@ class AgentRuntime {
         try {
             await this.saveToMemory(list, options);
             if (this.config.titleGeneration && options?.persistence && this.config.memory) {
-                void (0, title_generation_1.generateThreadTitle)({
+                const titlePromise = (0, title_generation_1.generateThreadTitle)({
                     memory: this.config.memory,
                     threadId: options.persistence.threadId,
                     resourceId: options.persistence.resourceId,
@@ -655,6 +840,9 @@ class AgentRuntime {
                     agentModel: this.config.model,
                     turnDelta: list.turnDelta(),
                 });
+                if (this.config.titleGeneration.sync) {
+                    await titlePromise;
+                }
             }
             await this.cleanupRun(runId);
             await this.flushTelemetry(options);
@@ -771,7 +959,8 @@ class AgentRuntime {
         }
         return merged;
     }
-    async iterateToolCallsConcurrent(toolCalls, toolMap, list, resolvedTelemetry) {
+    async iterateToolCallsConcurrent(ctx) {
+        const { toolCalls, toolMap, list, runId, telemetry: resolvedTelemetry } = ctx;
         const executableCalls = toolCalls.filter((tc) => !tc.providerExecuted);
         const executableCallsById = new Map(executableCalls.map((tc) => [tc.toolCallId, tc]));
         const unexecutedIds = new Set(executableCalls.map((tc) => tc.toolCallId));
@@ -796,12 +985,12 @@ class AgentRuntime {
                 const tc = batch[i];
                 const toolInput = tc.input;
                 if (result.status === 'rejected') {
+                    list.setToolCallError(tc.toolCallId, result.reason);
                     errors.push({
                         toolCallId: tc.toolCallId,
                         toolName: tc.toolName,
                         input: toolInput,
                         error: result.reason,
-                        message: (0, runtime_helpers_1.makeErrorToolResultMessage)(tc.toolCallId, tc.toolName, result.reason),
                     });
                 }
                 else if (result.value.outcome === 'suspended') {
@@ -820,6 +1009,7 @@ class AgentRuntime {
                         input: toolInput,
                         suspendPayload: result.value.payload,
                         resumeSchema: result.value.resumeSchema,
+                        runId,
                     };
                 }
                 else if (result.value.outcome === 'success') {
@@ -828,9 +1018,9 @@ class AgentRuntime {
                         toolName: tc.toolName,
                         input: toolInput,
                         toolEntry: result.value.toolEntry,
+                        modelOutput: result.value.modelOutput,
                         subAgentUsage: result.value.subAgentUsage,
                         customMessage: result.value.customMessage,
-                        message: result.value.message,
                     });
                 }
                 else if (result.value.outcome === 'error') {
@@ -839,7 +1029,6 @@ class AgentRuntime {
                         toolName: tc.toolName,
                         input: toolInput,
                         error: result.value.error,
-                        message: result.value.message,
                     });
                 }
                 else if (result.value.outcome === 'noop') {
@@ -860,7 +1049,8 @@ class AgentRuntime {
         }
         return { results, suspensions, errors, pending };
     }
-    async iteratePendingToolCallsConcurrent(pendingResume, toolMap, list, resolvedTelemetry) {
+    async iteratePendingToolCallsConcurrent(ctx) {
+        const { pendingResume, toolMap, list, runId, telemetry: resolvedTelemetry } = ctx;
         const resumedId = pendingResume.resumeToolCallId;
         const resumedEntry = pendingResume.pendingToolCalls[resumedId];
         if (!resumedEntry) {
@@ -878,6 +1068,7 @@ class AgentRuntime {
                 suspended: true,
                 suspendPayload: processResult.payload,
                 resumeSchema: processResult.resumeSchema,
+                runId,
             };
             suspensions.push({
                 toolCallId: resumedId,
@@ -893,9 +1084,9 @@ class AgentRuntime {
                 toolName: resumedToolName,
                 input: resumedEntry.input,
                 toolEntry: processResult.toolEntry,
+                modelOutput: processResult.modelOutput,
                 subAgentUsage: processResult.subAgentUsage,
                 customMessage: processResult.customMessage,
-                message: processResult.message,
             });
         }
         else if (processResult.outcome === 'error') {
@@ -904,7 +1095,6 @@ class AgentRuntime {
                 toolName: resumedToolName,
                 input: resumedEntry.input,
                 error: processResult.error,
-                message: processResult.message,
             });
         }
         else if (processResult.outcome === 'noop') {
@@ -933,7 +1123,13 @@ class AgentRuntime {
             }
         }
         if (unexecuted.length > 0) {
-            const batch = await this.iterateToolCallsConcurrent(unexecuted, toolMap, list, resolvedTelemetry);
+            const batch = await this.iterateToolCallsConcurrent({
+                toolCalls: unexecuted,
+                toolMap,
+                list,
+                runId,
+                telemetry: resolvedTelemetry,
+            });
             results.push(...batch.results);
             suspensions.push(...batch.suspensions);
             errors.push(...batch.errors);
@@ -957,57 +1153,52 @@ class AgentRuntime {
                 result: error,
                 isError: true,
             });
-            const errorMsg = (0, runtime_helpers_1.makeErrorToolResultMessage)(toolCallId, toolName, error);
-            list.addResponse([errorMsg]);
-            return { outcome: 'error', error, message: errorMsg };
+            list.setToolCallError(toolCallId, error);
+            return { outcome: 'error', error };
         };
         if (!builtTool) {
             return makeToolError(new Error(`Tool ${toolName} not found`));
         }
-        const existingToolResults = list
+        const settledBlock = list
             .responseDelta()
-            .filter((m) => (0, message_1.isLlmMessage)(m) && m.role === 'tool')
-            .flatMap((m) => m.content.filter((content) => content.type === 'tool-result'));
-        const existingToolResult = existingToolResults.find((r) => r.toolCallId === toolCallId);
-        if (existingToolResult) {
+            .flatMap((m) => ((0, message_1.isLlmMessage)(m) && 'content' in m ? m.content : []))
+            .find((c) => c.type === 'tool-call' && c.toolCallId === toolCallId && c.state !== 'pending');
+        if (settledBlock) {
+            let settledResult;
+            if (settledBlock.state === 'resolved') {
+                settledResult = settledBlock.output;
+            }
+            else {
+                settledResult = settledBlock.error;
+            }
             this.eventBus.emit({
                 type: "tool_execution_end",
                 toolCallId,
                 toolName,
-                result: existingToolResult.result,
-                isError: !!existingToolResult.isError,
+                result: settledResult,
+                isError: settledBlock.state === 'rejected',
             });
             return { outcome: 'noop' };
         }
         if (builtTool.inputSchema) {
-            if ((0, zod_1.isZodSchema)(builtTool.inputSchema)) {
-                const result = await builtTool.inputSchema.safeParseAsync(toolInput);
-                if (!result.success) {
-                    return makeToolError(new Error(`Invalid tool input: ${result.error.message}`));
-                }
-                toolInput = result.data;
-            }
-            else {
-                const validate = ajv.compile(builtTool.inputSchema);
-                const valid = validate(toolInput);
-                if (!valid) {
-                    const message = ajv.errorsText(validate.errors);
-                    return makeToolError(new Error(`Invalid tool input: ${message}`));
-                }
+            const result = await (0, parse_1.parseWithSchema)(builtTool.inputSchema, toolInput);
+            if (!result.success) {
+                return makeToolError(new Error(`Invalid tool input: ${result.error}`));
             }
+            toolInput = result.data;
         }
         let toolResult;
         try {
-            toolResult = await (0, tool_adapter_1.executeTool)(toolInput, builtTool, resumeData, resolvedTelemetry);
+            toolResult = await this.withTelemetryToolSpan(toolCallId, toolName, toolInput, resolvedTelemetry, async () => await (0, tool_adapter_1.executeTool)(toolInput, builtTool, resumeData, resolvedTelemetry, toolCallId));
         }
         catch (error) {
             return makeToolError(error);
         }
         if ((0, tool_adapter_1.isSuspendedToolResult)(toolResult)) {
             if (builtTool?.suspendSchema) {
-                const parseResult = await builtTool.suspendSchema.safeParseAsync(toolResult.payload);
+                const parseResult = await (0, parse_1.parseWithSchema)(builtTool.suspendSchema, toolResult.payload);
                 if (!parseResult.success) {
-                    return makeToolError(new Error(`Invalid suspend payload: ${parseResult.error.message}`));
+                    return makeToolError(new Error(`Invalid suspend payload: ${parseResult.error}`));
                 }
                 toolResult.payload = parseResult.data;
             }
@@ -1015,8 +1206,17 @@ class AgentRuntime {
                 const error = new Error(`Tool ${toolName} has no resume schema`);
                 return makeToolError(error);
             }
-            const resumeSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(builtTool.resumeSchema);
-            return { outcome: 'suspended', payload: toolResult.payload, resumeSchema };
+            const resumeSchema = (0, zod_1.isZodSchema)(builtTool.resumeSchema)
+                ? (0, zod_to_json_schema_1.zodToJsonSchema)(builtTool.resumeSchema)
+                : builtTool.resumeSchema;
+            if (!resumeSchema) {
+                return makeToolError(new Error('Invalid resume schema'));
+            }
+            return {
+                outcome: 'suspended',
+                payload: toolResult.payload,
+                resumeSchema,
+            };
         }
         let actualResult = toolResult;
         let extractedSubAgentUsage;
@@ -1034,8 +1234,7 @@ class AgentRuntime {
         const modelResult = builtTool.toModelOutput
             ? builtTool.toModelOutput(actualResult)
             : actualResult;
-        const toolResultMsg = (0, runtime_helpers_1.makeToolResultMessage)(toolCallId, toolName, modelResult);
-        list.addResponse([toolResultMsg]);
+        list.setToolCallResult(toolCallId, (0, json_value_1.toJsonValue)(modelResult));
         const customMessage = builtTool?.toMessage?.(actualResult);
         if (customMessage) {
             list.addResponse([customMessage]);
@@ -1048,9 +1247,9 @@ class AgentRuntime {
                 output: actualResult,
                 transformed: !!builtTool.toModelOutput,
             },
+            modelOutput: modelResult,
             subAgentUsage: extractedSubAgentUsage,
             customMessage,
-            message: toolResultMsg,
         };
     }
     buildLoopContext(execOptions) {
@@ -1061,8 +1260,9 @@ class AgentRuntime {
         const aiTools = (0, tool_adapter_1.toAiSdkTools)(allUserTools);
         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: (0, model_factory_1.createModel)(this.config.model),
+            model,
             toolMap: (0, tool_adapter_1.buildToolMap)(allUserTools),
             aiTools: allTools,
             providerOptions: this.buildCallProviderOptions(execOptions?.providerOptions),
@@ -1070,8 +1270,19 @@ class AgentRuntime {
             outputSpec: this.config.structuredOutput
                 ? ai_1.Output.object({ schema: this.config.structuredOutput })
                 : undefined,
+            effectiveInstructions: this.composeEffectiveInstructions(allUserTools),
         };
     }
+    composeEffectiveInstructions(tools) {
+        const fragments = tools
+            .map((t) => t.systemInstruction)
+            .filter((s) => typeof s === 'string' && s.trim().length > 0);
+        const userInstructions = this.config.instructions;
+        if (fragments.length === 0)
+            return userInstructions;
+        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)