@n8n/agents 0.12.0 → 0.13.0

package/dist/runtime/agent-runtime.js

@@ -1,1771 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentRuntime = void 0;
-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 delegate_sub_agent_tool_1 = require("./delegate-sub-agent-tool");
-const episodic_memory_1 = require("./episodic-memory");
-const event_bus_1 = require("./event-bus");
-const execution_counter_1 = require("./execution-counter");
-const fix_tool_call_1 = require("./fix-tool-call");
-const json_value_1 = require("./json-value");
-const lazy_ai_1 = require("./lazy-ai");
-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 sub_agent_task_path_1 = require("./sub-agent-task-path");
-const title_generation_1 = require("./title-generation");
-const tool_adapter_1 = require("./tool-adapter");
-const cancellation_1 = require("../sdk/cancellation");
-const telemetry_1 = require("../sdk/telemetry");
-const json_schema_1 = require("../utils/json-schema");
-const parse_1 = require("../utils/parse");
-const zod_1 = require("../utils/zod");
-function isActiveSpanTracer(value) {
-    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.approval ? { 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 isDeniedApprovalResumeData(value) {
-    return value !== null && typeof value === 'object' && Reflect.get(value, 'approved') === false;
-}
-function shouldEmitToolExecutionStart(tool, resumeData) {
-    if (!tool.approval)
-        return true;
-    if (!tool.approval.required && tool.approval.conditional !== true)
-        return true;
-    if (resumeData === undefined)
-        return false;
-    return !isDeniedApprovalResumeData(resumeData);
-}
-function getToolResumeJsonSchema(tool) {
-    if (!tool.resumeSchema)
-        return undefined;
-    return (0, zod_1.isZodSchema)(tool.resumeSchema) ? (0, zod_to_json_schema_1.zodToJsonSchema)(tool.resumeSchema) : tool.resumeSchema;
-}
-function buildAgentRootInputAttributes(config) {
-    const localTools = (config.tools ?? []).map(summarizeToolForTelemetry);
-    const providerTools = (config.providerTools ?? []).map(summarizeProviderToolForTelemetry);
-    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 = 30;
-const DEFAULT_MEMORY_TASK_LOCK_TTL_MS = 30_000;
-const logger = (0, logger_1.createFilteredLogger)();
-function getAiSdk() {
-    return (0, lazy_ai_1.loadAi)();
-}
-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, 'getMessagesForObservationScope') &&
-        hasFunctionProperty(memory, 'getCursor') &&
-        hasFunctionProperty(memory, 'setCursor'));
-}
-class AgentRuntime {
-    constructor(config) {
-        this.backgroundTasks = new background_task_tracker_1.BackgroundTaskTracker();
-        this.episodicMemoryTasksByResource = new Map();
-        this.config = config;
-        this.runId = config.runId ?? (0, run_state_1.generateRunId)();
-        if (config.deferredTools && config.deferredTools.length > 0) {
-            this.deferredToolManager = new deferred_tool_manager_1.DeferredToolManager(config.deferredTools, config.toolSearch);
-        }
-        this.runState = 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',
-            messageList: EMPTY_MESSAGE_LIST,
-            pendingToolCalls: {},
-        };
-    }
-    setTelemetry(telemetry) {
-        this.config.telemetry = telemetry;
-    }
-    async dispose() {
-        this.eventBus.dispose();
-        await this.backgroundTasks.flush();
-    }
-    getState() {
-        return { ...this.currentState };
-    }
-    abort() {
-        this.eventBus.abort();
-    }
-    async generate(input, options) {
-        const abortScope = this.eventBus.createAbortScope(options?.abortSignal);
-        let list = undefined;
-        try {
-            const initializedList = await this.initRun(input, options);
-            list = initializedList;
-            const rawResult = await this.withTelemetryRootSpan('generate', options, this.runId, async () => await this.runGenerateLoop({ list: initializedList, options, abortScope }));
-            return this.finalizeGenerate(rawResult, list);
-        }
-        catch (error) {
-            await this.flushTelemetry(options);
-            const isAbort = abortScope.isAborted;
-            this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
-            if (!isAbort) {
-                this.eventBus.emit({ type: "error", message: String(error), error });
-            }
-            return {
-                runId: this.runId,
-                messages: list?.responseDelta() ?? [],
-                finishReason: 'error',
-                error,
-                getState: () => this.getState(),
-            };
-        }
-        finally {
-            abortScope.dispose();
-        }
-    }
-    async stream(input, options) {
-        const abortScope = this.eventBus.createAbortScope(options?.abortSignal);
-        let list;
-        try {
-            list = await this.initRun(input, options);
-        }
-        catch (error) {
-            const isAbort = abortScope.isAborted;
-            this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
-            if (!isAbort) {
-                this.eventBus.emit({ type: "error", message: String(error), error });
-            }
-            abortScope.dispose();
-            return { runId: this.runId, stream: (0, runtime_helpers_1.makeErrorStream)(error), getState: () => this.getState() };
-        }
-        return {
-            runId: this.runId,
-            stream: this.startStreamLoop({ list, options, abortScope }),
-            getState: () => this.getState(),
-        };
-    }
-    async resume(method, data, options) {
-        this.runId = options.runId;
-        const state = await this.runState.resume(this.runId);
-        if (!state)
-            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}`);
-        const list = message_list_1.AgentMessageList.deserialize(state.messageList);
-        this.hydrateDeferredToolsFromList(list);
-        const toolForValidation = this.getCurrentTools(state.persistence).find((t) => t.name === toolCall.toolName);
-        if (!toolForValidation)
-            throw new Error(`Tool ${toolCall.toolName} not found`);
-        let resumeData = data;
-        let abortScope;
-        if (!(0, cancellation_1.isCancellation)(resumeData) && toolForValidation.resumeSchema) {
-            const parseResult = await (0, parse_1.parseWithSchema)(toolForValidation.resumeSchema, data);
-            if (!parseResult.success) {
-                throw new Error(`Invalid resume payload: ${parseResult.error}`);
-            }
-            resumeData = parseResult.data;
-        }
-        try {
-            const { runId: _rid, toolCallId: _tcid, ...callerExecOptions } = options;
-            const persisted = state.executionOptions ?? {};
-            const persistedMaxIterations = persisted.maxIterations;
-            const callerMaxIterations = callerExecOptions.maxIterations;
-            if (callerMaxIterations !== undefined &&
-                persistedMaxIterations !== undefined &&
-                callerMaxIterations < persistedMaxIterations) {
-                throw new Error(`Cannot decrease maxIterations when resuming a run. Expected >= ${persistedMaxIterations}, received ${callerMaxIterations}.`);
-            }
-            const mergedMaxIterations = callerMaxIterations ?? persistedMaxIterations;
-            const mergedExecOptions = {
-                ...callerExecOptions,
-                ...(mergedMaxIterations !== undefined ? { maxIterations: mergedMaxIterations } : {}),
-                ...(state.iterationCount !== undefined ? { iterationCount: state.iterationCount } : {}),
-            };
-            const tool = this.getCurrentTools(state.persistence, mergedExecOptions.executionCounter).find((t) => t.name === toolCall.toolName);
-            if (!tool)
-                throw new Error(`Tool ${toolCall.toolName} not found`);
-            const resumeOptions = {
-                persistence: state.persistence,
-                ...mergedExecOptions,
-            };
-            abortScope = this.eventBus.createAbortScope(resumeOptions.abortSignal);
-            const activeAbortScope = abortScope;
-            const pendingResume = {
-                pendingToolCalls: state.pendingToolCalls,
-                resumeToolCallId: options.toolCallId,
-                resumeData,
-                messages: state.messageList.messages,
-            };
-            await this.ensureModelCost();
-            await this.setListObservationLogMemory(list, state.persistence);
-            if (method === 'generate') {
-                const rawResult = await this.withTelemetryRootSpan('generate', resumeOptions, this.runId, async () => await this.runGenerateLoop({
-                    list,
-                    options: resumeOptions,
-                    abortScope: activeAbortScope,
-                    pendingResume,
-                }));
-                if (!rawResult.pendingSuspend) {
-                    await this.cleanupRun();
-                }
-                try {
-                    return this.finalizeGenerate(rawResult, list);
-                }
-                finally {
-                    abortScope.dispose();
-                }
-            }
-            return {
-                runId: this.runId,
-                stream: this.startStreamLoop({
-                    list,
-                    options: resumeOptions,
-                    abortScope: activeAbortScope,
-                    pendingResume,
-                }),
-                getState: () => this.getState(),
-            };
-        }
-        catch (error) {
-            const isAbort = abortScope?.isAborted ?? false;
-            abortScope?.dispose();
-            this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
-            if (!isAbort) {
-                this.eventBus.emit({ type: "error", message: String(error), error });
-            }
-            if (method === 'generate') {
-                return {
-                    runId: this.runId,
-                    messages: [],
-                    finishReason: 'error',
-                    error,
-                    getState: () => this.getState(),
-                };
-            }
-            return { runId: this.runId, stream: (0, runtime_helpers_1.makeErrorStream)(error), getState: () => this.getState() };
-        }
-    }
-    async buildMessageList(input, options) {
-        const list = new message_list_1.AgentMessageList();
-        if (this.config.memory && options?.persistence?.threadId) {
-            const memMessages = await this.loadHistoryMessages(options.persistence);
-            if (memMessages.length > 0) {
-                list.addHistory((0, strip_orphaned_tool_messages_1.stripOrphanedToolMessages)(memMessages));
-            }
-        }
-        await this.setListObservationLogMemory(list, options?.persistence);
-        list.addInput(input);
-        return list;
-    }
-    async loadHistoryMessages(persistence) {
-        const memory = this.config.memory;
-        if (!memory)
-            return [];
-        const { threadId, resourceId } = persistence;
-        if (this.config.observationalMemory && hasObservationLogObserverMemory(memory)) {
-            const cursor = await memory.getCursor(threadId);
-            if (cursor) {
-                return await memory.getMessagesForObservationScope(threadId, {
-                    since: {
-                        sinceCreatedAt: cursor.lastObservedAt,
-                        sinceMessageId: cursor.lastObservedMessageId,
-                    },
-                });
-            }
-        }
-        return await memory.getMessages(threadId, {
-            resourceId,
-        });
-    }
-    async initRun(input, options) {
-        this.updateState({
-            status: 'running',
-            persistence: options?.persistence,
-        });
-        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) {
-        result.runId = this.runId;
-        result.usage = this.applyCost(result.usage);
-        result.model = this.modelIdString;
-        this.updateState({ status: 'success', messageList: list.serialize() });
-        this.eventBus.emit({ type: "agent_end", messages: result.messages });
-        return { ...result, getState: () => this.getState() };
-    }
-    resolveTelemetry(options) {
-        if (this.config.telemetry)
-            return this.config.telemetry;
-        const inherited = options?.telemetry;
-        if (!inherited)
-            return undefined;
-        return { ...inherited, functionId: this.config.name };
-    }
-    async flushTelemetry(options) {
-        await telemetry_1.Telemetry.forceFlush(this.resolveTelemetry(options));
-    }
-    buildAiSdkOptions(toolMap, options) {
-        return {
-            ...this.buildTelemetryOptions(options),
-            experimental_repairToolCall: async (options) => {
-                return await (0, fix_tool_call_1.fixToolCall)({
-                    toolCall: options.toolCall,
-                    error: options.error,
-                }, toolMap);
-            },
-        };
-    }
-    buildSmoothStreamTransformOptions(options) {
-        if (options?.smoothStream === false)
-            return {};
-        const { smoothStream } = (0, lazy_ai_1.loadAi)();
-        return { experimental_transform: smoothStream(options?.smoothStream ?? {}) };
-    }
-    buildTelemetryOptions(options) {
-        const t = this.resolveTelemetry(options);
-        if (!t?.enabled)
-            return {};
-        return {
-            experimental_telemetry: {
-                isEnabled: true,
-                functionId: t.functionId ?? this.config.name,
-                metadata: t.metadata,
-                recordInputs: t.recordInputs,
-                recordOutputs: t.recordOutputs,
-                tracer: t.tracer,
-                integrations: t.integrations.length > 0 ? t.integrations : undefined,
-            },
-        };
-    }
-    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'),
-        };
-    }
-    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) {
-        (0, execution_counter_1.incrementTokenCountFromUsage)(counter, usage);
-    }
-    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, abortScope, pendingResume } = ctx;
-        this.hydrateDeferredToolsFromList(list);
-        let totalUsage;
-        let lastFinishReason = 'stop';
-        let structuredOutput;
-        const toolCallSummary = [];
-        const runTelemetry = this.resolveTelemetry(options);
-        const staticLoopContext = this.buildStaticLoopContext({
-            ...options,
-            persistence: options?.persistence,
-        });
-        const pendingLoopContext = this.buildToolLoopContext(staticLoopContext.aiProviderTools, options?.persistence, options?.executionCounter);
-        const pendingToolCtx = {
-            toolMap: pendingLoopContext.toolMap,
-            list,
-            runId: this.runId,
-            persistence: options?.persistence,
-            telemetry: runTelemetry,
-            executionCounter: options?.executionCounter,
-            abortSignal: abortScope.signal,
-            isAborted: () => abortScope.isAborted,
-        };
-        const maxIterations = options?.maxIterations ?? MAX_LOOP_ITERATIONS;
-        let iterationCount = options?.iterationCount ?? 0;
-        let reachedStopCondition = false;
-        if (pendingResume) {
-            const batch = await this.iteratePendingToolCallsConcurrent({
-                ...pendingToolCtx,
-                pendingResume,
-            });
-            for (const r of batch.results) {
-                toolCallSummary.push(r.toolEntry);
-            }
-            if (Object.keys(batch.pending).length > 0) {
-                const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, maxIterations, iterationCount);
-                return {
-                    runId: suspendRunId,
-                    messages: list.responseDelta(),
-                    finishReason: 'tool-calls',
-                    usage: totalUsage,
-                    pendingSuspend: batch.suspensions.map((s) => ({
-                        runId: suspendRunId,
-                        toolCallId: s.toolCallId,
-                        toolName: s.toolName,
-                        input: s.input,
-                        suspendPayload: s.payload,
-                        resumeSchema: s.resumeSchema,
-                    })),
-                    getState: () => this.getState(),
-                };
-            }
-        }
-        const { generateText } = (0, lazy_ai_1.loadAi)();
-        for (; iterationCount < maxIterations; iterationCount++) {
-            if (abortScope.isAborted) {
-                this.updateState({ status: 'cancelled' });
-                throw new Error('Agent run was aborted');
-            }
-            this.eventBus.emit({ type: "turn_start" });
-            const { toolMap, aiTools, hasTools, effectiveInstructions } = this.buildToolLoopContext(staticLoopContext.aiProviderTools, options?.persistence, options?.executionCounter);
-            const { system, messages } = list.forLlm(effectiveInstructions, this.config.instructionProviderOptions);
-            const result = await generateText({
-                model: staticLoopContext.model,
-                system,
-                messages,
-                abortSignal: abortScope.signal,
-                ...(hasTools ? { tools: aiTools } : {}),
-                ...(staticLoopContext.providerOptions
-                    ? { providerOptions: staticLoopContext.providerOptions }
-                    : {}),
-                ...(staticLoopContext.outputSpec ? { output: staticLoopContext.outputSpec } : {}),
-                ...this.buildAiSdkOptions(toolMap, 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 (staticLoopContext.outputSpec) {
-                    structuredOutput = result.output;
-                }
-                this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractSettledToolCalls)(newMessages));
-                reachedStopCondition = true;
-                break;
-            }
-            const batch = await this.iterateToolCallsConcurrent({
-                toolMap,
-                list,
-                runId: this.runId,
-                persistence: options?.persistence,
-                telemetry: runTelemetry,
-                executionCounter: options?.executionCounter,
-                abortSignal: abortScope.signal,
-                isAborted: () => abortScope.isAborted,
-                toolCalls: result.toolCalls,
-            });
-            for (const r of batch.results) {
-                toolCallSummary.push(r.toolEntry);
-            }
-            if (Object.keys(batch.pending).length > 0) {
-                const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, maxIterations, iterationCount + 1);
-                return {
-                    runId: suspendRunId,
-                    messages: list.responseDelta(),
-                    finishReason: 'tool-calls',
-                    usage: totalUsage,
-                    pendingSuspend: batch.suspensions.map((s) => ({
-                        runId: suspendRunId,
-                        toolCallId: s.toolCallId,
-                        toolName: s.toolName,
-                        input: s.input,
-                        suspendPayload: s.payload,
-                        resumeSchema: s.resumeSchema,
-                    })),
-                    getState: () => this.getState(),
-                };
-            }
-            this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractSettledToolCalls)(list.responseDelta()));
-        }
-        if (!reachedStopCondition && iterationCount >= maxIterations) {
-            lastFinishReason = 'max-iterations';
-        }
-        await this.saveToMemory(list, options);
-        await this.flushTelemetry(options);
-        if (this.config.titleGeneration && options?.persistence?.threadId && this.config.memory) {
-            const titlePromise = (0, title_generation_1.generateThreadTitle)({
-                memory: this.config.memory,
-                threadId: options.persistence.threadId,
-                resourceId: options.persistence.resourceId,
-                titleConfig: this.config.titleGeneration,
-                agentModel: this.config.model,
-                turnDelta: list.turnDelta(),
-                executionCounter: options.executionCounter,
-            });
-            this.backgroundTasks.track(titlePromise);
-            if (this.config.titleGeneration.sync) {
-                await titlePromise;
-            }
-        }
-        return {
-            runId: this.runId,
-            messages: list.responseDelta(),
-            finishReason: lastFinishReason,
-            usage: totalUsage,
-            ...(structuredOutput !== undefined && { structuredOutput }),
-            ...(toolCallSummary.length > 0 && { toolCalls: toolCallSummary }),
-            getState: () => this.getState(),
-        };
-    }
-    startStreamLoop(ctx) {
-        const { options } = ctx;
-        const { readable, writable } = new TransformStream();
-        const writer = writable.getWriter();
-        const writeEventChunk = (chunk) => {
-            writer.write(chunk).catch(() => { });
-        };
-        const onToolExecutionStart = (data) => {
-            if (data.type !== "tool_execution_start")
-                return;
-            writeEventChunk({
-                type: 'tool-execution-start',
-                toolCallId: data.toolCallId,
-                toolName: data.toolName,
-                startTime: Date.now(),
-            });
-        };
-        const onToolExecutionEnd = (data) => {
-            if (data.type !== "tool_execution_end")
-                return;
-            writeEventChunk({
-                type: 'tool-execution-end',
-                toolCallId: data.toolCallId,
-                toolName: data.toolName,
-                isError: data.isError,
-                endTime: Date.now(),
-            });
-        };
-        const onSubAgentStarted = (data) => {
-            if (data.type !== "subagent_started")
-                return;
-            const { type: _type, ...payload } = data;
-            writeEventChunk({ type: 'subagent-started', ...payload });
-        };
-        const onSubAgentCompleted = (data) => {
-            if (data.type !== "subagent_completed")
-                return;
-            const { type: _type, ...payload } = data;
-            writeEventChunk({ type: 'subagent-completed', ...payload });
-        };
-        this.eventBus.on("tool_execution_start", onToolExecutionStart);
-        this.eventBus.on("tool_execution_end", onToolExecutionEnd);
-        this.eventBus.on("subagent_started", onSubAgentStarted);
-        this.eventBus.on("subagent_completed", onSubAgentCompleted);
-        this.withTelemetryRootSpan('stream', options, this.runId, async () => await this.runStreamLoop({ ...ctx, writer }))
-            .catch(async (error) => {
-            await this.flushTelemetry(options);
-            await this.cleanupRun();
-            const isAbort = ctx.abortScope.isAborted;
-            this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
-            if (!isAbort) {
-                this.eventBus.emit({ type: "error", message: String(error), error });
-            }
-            try {
-                await writer.write({ type: 'error', error });
-                await writer.write({ type: 'finish', finishReason: 'error' });
-                await writer.close();
-            }
-            catch {
-                writer.abort(error).catch(() => { });
-            }
-        })
-            .finally(async () => {
-            await writer.close().catch(() => { });
-            this.eventBus.off("tool_execution_start", onToolExecutionStart);
-            this.eventBus.off("tool_execution_end", onToolExecutionEnd);
-            this.eventBus.off("subagent_started", onSubAgentStarted);
-            this.eventBus.off("subagent_completed", onSubAgentCompleted);
-            ctx.abortScope.dispose();
-        });
-        return readable;
-    }
-    async runStreamLoop(ctx) {
-        const { list, options, abortScope, pendingResume, writer } = ctx;
-        this.hydrateDeferredToolsFromList(list);
-        const writeChunk = async (chunk) => {
-            await writer.write(chunk);
-        };
-        let totalUsage;
-        let lastFinishReason = 'stop';
-        let structuredOutput;
-        const maxIterations = options?.maxIterations ?? MAX_LOOP_ITERATIONS;
-        let iterationCount = options?.iterationCount ?? 0;
-        let reachedStopCondition = false;
-        const { streamText } = (0, lazy_ai_1.loadAi)();
-        const closeStreamWithError = async (error, status) => {
-            await this.cleanupRun();
-            this.updateState({ status });
-            await writer.write({ type: 'error', error });
-            await writer.write({ type: 'finish', finishReason: 'error' });
-            await writer.close();
-        };
-        const handleAbort = async () => {
-            if (!abortScope.isAborted)
-                return false;
-            await closeStreamWithError(new Error('Agent run was aborted'), 'cancelled');
-            return true;
-        };
-        const runTelemetry = this.resolveTelemetry(options);
-        const staticLoopContext = this.buildStaticLoopContext({
-            ...options,
-            persistence: options?.persistence,
-        });
-        const pendingLoopContext = this.buildToolLoopContext(staticLoopContext.aiProviderTools, options?.persistence, options?.executionCounter);
-        const pendingToolCtx = {
-            toolMap: pendingLoopContext.toolMap,
-            list,
-            runId: this.runId,
-            persistence: options?.persistence,
-            telemetry: runTelemetry,
-            executionCounter: options?.executionCounter,
-            abortSignal: abortScope.signal,
-            isAborted: () => abortScope.isAborted,
-        };
-        if (pendingResume) {
-            try {
-                const batch = await this.iteratePendingToolCallsConcurrent({
-                    ...pendingToolCtx,
-                    pendingResume,
-                });
-                for (const r of batch.results) {
-                    await writer.write({
-                        type: 'tool-result',
-                        toolCallId: r.toolCallId,
-                        toolName: r.toolName,
-                        output: r.modelOutput,
-                        ...(r.toolEntry.canceled ? { canceled: true } : {}),
-                    });
-                    if (r.customMessage) {
-                        await writer.write({ type: 'message', message: r.customMessage });
-                    }
-                }
-                for (const e of batch.errors) {
-                    await writer.write({
-                        type: 'tool-result',
-                        toolCallId: e.toolCallId,
-                        toolName: e.toolName,
-                        output: e.error,
-                        isError: true,
-                    });
-                }
-                if (Object.keys(batch.pending).length > 0) {
-                    const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, maxIterations, iterationCount);
-                    for (const s of batch.suspensions) {
-                        await writer.write({
-                            type: 'tool-call-suspended',
-                            runId: suspendRunId,
-                            toolCallId: s.toolCallId,
-                            toolName: s.toolName,
-                            input: s.input,
-                            suspendPayload: s.payload,
-                            resumeSchema: s.resumeSchema,
-                        });
-                    }
-                    await writer.write({ type: 'finish', finishReason: 'tool-calls' });
-                    await writer.close();
-                    return;
-                }
-            }
-            catch (error) {
-                this.eventBus.emit({ type: "error", message: String(error), error });
-                await closeStreamWithError(error, 'failed');
-                return;
-            }
-        }
-        for (; iterationCount < maxIterations; iterationCount++) {
-            if (await handleAbort())
-                return;
-            this.eventBus.emit({ type: "turn_start" });
-            const { toolMap, aiTools, hasTools, effectiveInstructions } = this.buildToolLoopContext(staticLoopContext.aiProviderTools, options?.persistence, options?.executionCounter);
-            const { system, messages } = list.forLlm(effectiveInstructions, this.config.instructionProviderOptions);
-            const result = streamText({
-                model: staticLoopContext.model,
-                system,
-                messages,
-                abortSignal: abortScope.signal,
-                ...(hasTools ? { tools: aiTools } : {}),
-                ...(staticLoopContext.providerOptions
-                    ? { providerOptions: staticLoopContext.providerOptions }
-                    : {}),
-                ...(staticLoopContext.outputSpec ? { output: staticLoopContext.outputSpec } : {}),
-                ...this.buildAiSdkOptions(toolMap, options),
-                ...this.buildSmoothStreamTransformOptions(options),
-            });
-            try {
-                for await (const chunk of result.fullStream) {
-                    if (chunk.type === 'finish')
-                        continue;
-                    if ((chunk.type === 'tool-result' || chunk.type === 'tool-error') &&
-                        chunk.providerExecuted) {
-                        await writeChunk({
-                            type: 'tool-execution-end',
-                            toolCallId: chunk.toolCallId,
-                            toolName: chunk.toolName ?? '',
-                            isError: chunk.type === 'tool-error',
-                            endTime: Date.now(),
-                        });
-                    }
-                    const converted = (0, stream_1.convertChunk)(chunk);
-                    if (converted)
-                        await writeChunk(converted);
-                    if (chunk.type === 'tool-call' && chunk.providerExecuted) {
-                        await writeChunk({
-                            type: 'tool-execution-start',
-                            toolCallId: chunk.toolCallId,
-                            toolName: chunk.toolName ?? '',
-                            startTime: Date.now(),
-                        });
-                    }
-                }
-            }
-            catch (streamError) {
-                if (await handleAbort())
-                    return;
-                this.eventBus.emit({
-                    type: "error",
-                    message: String(streamError),
-                    error: streamError,
-                });
-                await closeStreamWithError(streamError, 'failed');
-                return;
-            }
-            if (await handleAbort())
-                return;
-            const aiFinishReason = await result.finishReason;
-            const usage = await result.usage;
-            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 (staticLoopContext.outputSpec) {
-                    structuredOutput = await result.output;
-                }
-                this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractSettledToolCalls)(newMessages));
-                reachedStopCondition = true;
-                break;
-            }
-            const toolCalls = await result.toolCalls;
-            try {
-                const batch = await this.iterateToolCallsConcurrent({
-                    toolMap,
-                    list,
-                    runId: this.runId,
-                    persistence: options?.persistence,
-                    telemetry: runTelemetry,
-                    executionCounter: options?.executionCounter,
-                    abortSignal: abortScope.signal,
-                    isAborted: () => abortScope.isAborted,
-                    toolCalls,
-                });
-                if (await handleAbort())
-                    return;
-                for (const r of batch.results) {
-                    await writer.write({
-                        type: 'tool-result',
-                        toolCallId: r.toolCallId,
-                        toolName: r.toolName,
-                        output: r.modelOutput,
-                        ...(r.toolEntry.canceled ? { canceled: true } : {}),
-                    });
-                    if (r.customMessage) {
-                        await writer.write({ type: 'message', message: r.customMessage });
-                    }
-                }
-                for (const e of batch.errors) {
-                    await writer.write({
-                        type: 'tool-result',
-                        toolCallId: e.toolCallId,
-                        toolName: e.toolName,
-                        output: e.error,
-                        isError: true,
-                    });
-                }
-                if (Object.keys(batch.pending).length > 0) {
-                    const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, maxIterations, iterationCount + 1);
-                    for (const s of batch.suspensions) {
-                        await writer.write({
-                            type: 'tool-call-suspended',
-                            runId: suspendRunId,
-                            toolCallId: s.toolCallId,
-                            toolName: s.toolName,
-                            input: s.input,
-                            suspendPayload: s.payload,
-                            resumeSchema: s.resumeSchema,
-                        });
-                    }
-                    await writer.write({ type: 'finish', finishReason: 'tool-calls' });
-                    await writer.close();
-                    return;
-                }
-            }
-            catch (error) {
-                this.eventBus.emit({ type: "error", message: String(error), error });
-                await closeStreamWithError(error, 'failed');
-                return;
-            }
-            this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractSettledToolCalls)(list.responseDelta()));
-        }
-        if (!reachedStopCondition && iterationCount >= maxIterations) {
-            lastFinishReason = 'max-iterations';
-        }
-        await this.saveToMemory(list, options);
-        if (this.config.titleGeneration && options?.persistence && this.config.memory) {
-            const titlePromise = (0, title_generation_1.generateThreadTitle)({
-                memory: this.config.memory,
-                threadId: options.persistence.threadId,
-                resourceId: options.persistence.resourceId,
-                titleConfig: this.config.titleGeneration,
-                agentModel: this.config.model,
-                turnDelta: list.turnDelta(),
-                executionCounter: options.executionCounter,
-            });
-            this.backgroundTasks.track(titlePromise);
-            if (this.config.titleGeneration.sync) {
-                await titlePromise;
-            }
-        }
-        await this.cleanupRun();
-        await this.flushTelemetry(options);
-        const costUsage = this.applyCost(totalUsage);
-        await writer.write({
-            type: 'finish',
-            finishReason: lastFinishReason,
-            ...(costUsage && { usage: costUsage }),
-            model: this.modelIdString,
-            ...(structuredOutput !== undefined && { structuredOutput }),
-        });
-        this.updateState({ status: 'success', messageList: list.serialize() });
-        this.eventBus.emit({ type: "agent_end", messages: list.responseDelta() });
-        await writer.close();
-    }
-    async saveToMemory(list, options) {
-        if (!this.config.memory || !options?.persistence)
-            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);
-        const observationTasks = this.scheduleObservationLogJobs(options.persistence, options.executionCounter);
-        this.scheduleEpisodicMemoryJob(options.persistence, observationTasks, options.executionCounter);
-    }
-    scheduleObservationLogJobs(persistence, executionCounter) {
-        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.lockTtlMs);
-        const observe = observationalMemory.observe;
-        const observerThresholdTokens = observationalMemory.observerThresholdTokens;
-        const tasks = [];
-        if (observe &&
-            observerThresholdTokens !== undefined &&
-            hasObservationLogObserverMemory(memory)) {
-            tasks.push(this.scheduleMemoryTask(runner, scope, 'observer', async () => await (0, observation_log_observer_1.runObservationLogObserver)({
-                memory,
-                ...scope,
-                observerThresholdTokens,
-                observationLogTailLimit: observationalMemory.observationLogTailLimit ?? 0,
-                observe,
-                executionCounter,
-            })));
-        }
-        const reflect = observationalMemory.reflect;
-        const reflectorThresholdTokens = observationalMemory.reflectorThresholdTokens;
-        if (reflect && reflectorThresholdTokens !== undefined) {
-            tasks.push(this.scheduleMemoryTask(runner, scope, 'reflector', async () => await (0, observation_log_reflector_1.runObservationLogReflector)({
-                memory,
-                ...scope,
-                reflectorThresholdTokens,
-                reflect,
-                executionCounter,
-            })));
-        }
-        return tasks;
-    }
-    scheduleEpisodicMemoryJob(persistence, observationTasks, executionCounter) {
-        const { memory, episodicMemory } = this.config;
-        if (!memory ||
-            !episodicMemory ||
-            !(0, episodic_memory_1.isEpisodicMemoryEnabled)(episodicMemory) ||
-            !(0, episodic_memory_1.hasEpisodicMemoryStore)(memory) ||
-            !(0, observation_log_store_1.hasObservationLogStore)(memory) ||
-            !episodicMemory.extract) {
-            return;
-        }
-        const scope = (0, episodic_memory_1.getEpisodicMemoryScope)(persistence);
-        if (!scope)
-            return;
-        const observationScope = this.getObservationLogScope(persistence);
-        this.scheduleEpisodicMemoryTask(memory, scope.resourceId, async () => {
-            await Promise.allSettled(observationTasks);
-            await (0, episodic_memory_1.runEpisodicMemoryIndexer)({
-                memory,
-                config: episodicMemory,
-                scope,
-                observationScope,
-                threadId: persistence.threadId,
-                executionCounter,
-            });
-        });
-    }
-    scheduleEpisodicMemoryTask(memory, resourceId, task) {
-        const id = crypto.randomUUID();
-        const previous = this.episodicMemoryTasksByResource.get(resourceId) ?? Promise.resolve();
-        const done = previous
-            .catch(() => undefined)
-            .then(async () => await this.runEpisodicMemoryTask(memory, resourceId, id, task));
-        const queued = done.finally(() => {
-            if (this.episodicMemoryTasksByResource.get(resourceId) === queued) {
-                this.episodicMemoryTasksByResource.delete(resourceId);
-            }
-        });
-        this.episodicMemoryTasksByResource.set(resourceId, queued);
-        this.backgroundTasks.track(queued);
-    }
-    async runEpisodicMemoryTask(memory, resourceId, holderId, task) {
-        const taskLock = memory.episodic?.taskLock;
-        let lock = null;
-        try {
-            if (taskLock) {
-                lock = await taskLock.acquire(resourceId, {
-                    holderId,
-                    ttlMs: this.config.observationalMemory?.lockTtlMs ?? DEFAULT_MEMORY_TASK_LOCK_TTL_MS,
-                });
-                if (!lock)
-                    return;
-            }
-            await task();
-        }
-        catch (error) {
-            const message = 'Episodic memory indexing task failed';
-            logger.warn(message, { error, resourceId });
-            this.eventBus.emit({ type: "error", message, error, source: 'episodic-memory' });
-        }
-        finally {
-            if (lock) {
-                await this.releaseEpisodicMemoryTaskLock(taskLock, lock, resourceId);
-            }
-        }
-    }
-    async releaseEpisodicMemoryTaskLock(taskLock, lock, resourceId) {
-        try {
-            await taskLock?.release(lock);
-        }
-        catch (error) {
-            logger.warn('Episodic memory indexing lock release failed', { error, resourceId });
-        }
-    }
-    async scheduleMemoryTask(runner, scope, taskKind, task) {
-        return await runner.schedule({ ...scope, taskKind }, task).done;
-    }
-    getMemoryTaskRunner(memory, lockTtlMs) {
-        this.memoryTasks ??= new scoped_memory_task_runner_1.ScopedMemoryTaskRunner({
-            tracker: this.backgroundTasks,
-            lockStore: (0, observation_log_store_1.hasObservationLogTaskLockStore)(memory) ? memory : undefined,
-            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,
-                    observationScopeId: event.task.observationScopeId,
-                });
-                this.eventBus.emit({ type: "error", message, error: event.error, source });
-            },
-        });
-        return this.memoryTasks;
-    }
-    getObservationLogScope(persistence) {
-        return {
-            observationScopeId: persistence.threadId,
-        };
-    }
-    buildThinkingProviderOptions() {
-        if (!this.config.thinking)
-            return undefined;
-        const provider = this.modelIdString.split('/')[0];
-        const thinking = this.config.thinking;
-        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 },
-                    },
-                };
-            }
-            case 'openai': {
-                const cfg = thinking;
-                return { openai: { reasoningEffort: cfg.reasoningEffort ?? 'medium' } };
-            }
-            case 'google': {
-                const cfg = thinking;
-                return {
-                    google: {
-                        thinkingConfig: {
-                            ...(cfg.thinkingBudget !== undefined && { thinkingBudget: cfg.thinkingBudget }),
-                            ...(cfg.thinkingLevel !== undefined && { thinkingLevel: cfg.thinkingLevel }),
-                        },
-                    },
-                };
-            }
-            case 'xai': {
-                const cfg = thinking;
-                return { xai: { reasoningEffort: cfg.reasoningEffort ?? 'high' } };
-            }
-            default:
-                return undefined;
-        }
-    }
-    buildCallProviderOptions(runProviderOptions) {
-        const thinkingOpts = this.buildThinkingProviderOptions();
-        if (!thinkingOpts && !runProviderOptions)
-            return undefined;
-        if (!thinkingOpts)
-            return runProviderOptions;
-        if (!runProviderOptions)
-            return thinkingOpts;
-        const merged = { ...thinkingOpts };
-        for (const [provider, opts] of Object.entries(runProviderOptions)) {
-            if (provider in merged) {
-                merged[provider] = { ...merged[provider], ...opts };
-            }
-            else {
-                merged[provider] = opts;
-            }
-        }
-        return merged;
-    }
-    isDelegateSubAgentCall(toolName) {
-        return toolName === delegate_sub_agent_tool_1.DELEGATE_SUB_AGENT_TOOL_NAME;
-    }
-    getToolCallBatchSize(toolName, toolMap) {
-        if (!this.isDelegateSubAgentCall(toolName))
-            return this.concurrency;
-        const tool = toolMap.get(toolName);
-        const delegateOptions = tool ? (0, delegate_sub_agent_tool_1.getInlineDelegateSubAgentToolOptions)(tool) : undefined;
-        return delegateOptions?.policy?.maxChildren ?? sub_agent_task_path_1.DEFAULT_SUB_AGENT_MAX_CHILDREN;
-    }
-    takeNextToolCallBatch(calls, start, toolMap) {
-        const first = calls[start];
-        if (!first) {
-            throw new Error('Unable to build tool-call batch');
-        }
-        const isDelegateBatch = this.isDelegateSubAgentCall(first.toolName);
-        const batchSize = this.getToolCallBatchSize(first.toolName, toolMap);
-        if (batchSize < 1 ||
-            Number.isNaN(batchSize) ||
-            (isDelegateBatch && !Number.isFinite(batchSize))) {
-            throw new Error(`Invalid tool-call batch size for ${first.toolName}: ${batchSize}`);
-        }
-        const batch = [];
-        for (let i = start; i < calls.length && batch.length < batchSize; i++) {
-            const candidate = calls[i];
-            if (this.isDelegateSubAgentCall(candidate.toolName) !== isDelegateBatch)
-                break;
-            batch.push(candidate);
-        }
-        return batch;
-    }
-    async iterateToolCallsConcurrent(ctx) {
-        const { toolCalls, toolMap, list, runId, telemetry: resolvedTelemetry, executionCounter, abortSignal, } = 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 results = [];
-        const suspensions = [];
-        const errors = [];
-        const pending = {};
-        for (let batchStart = 0; batchStart < executableCalls.length;) {
-            if (ctx.isAborted()) {
-                this.updateState({ status: 'cancelled' });
-                throw new Error('Agent run was aborted');
-            }
-            const batch = this.takeNextToolCallBatch(executableCalls, batchStart, toolMap);
-            batchStart += batch.length;
-            const settledResults = await Promise.allSettled(batch.map(async (tc) => await this.processToolCall(tc.toolCallId, tc.toolName, tc.input, toolMap, list, runId, ctx.persistence, undefined, resolvedTelemetry, executionCounter, abortSignal, true)));
-            for (const tc of batch) {
-                unexecutedIds.delete(tc.toolCallId);
-            }
-            let hasSuspension = false;
-            for (let i = 0; i < settledResults.length; i++) {
-                const result = settledResults[i];
-                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,
-                    });
-                }
-                else if (result.value.outcome === 'suspended') {
-                    hasSuspension = true;
-                    suspensions.push({
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: toolInput,
-                        payload: result.value.payload,
-                        resumeSchema: result.value.resumeSchema,
-                    });
-                    pending[tc.toolCallId] = {
-                        suspended: true,
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: toolInput,
-                        suspendPayload: result.value.payload,
-                        resumeSchema: result.value.resumeSchema,
-                        runId,
-                    };
-                }
-                else if (result.value.outcome === 'success') {
-                    results.push({
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: toolInput,
-                        toolEntry: result.value.toolEntry,
-                        modelOutput: result.value.modelOutput,
-                        customMessage: result.value.customMessage,
-                    });
-                }
-                else if (result.value.outcome === 'error') {
-                    errors.push({
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: toolInput,
-                        error: result.value.error,
-                    });
-                }
-                else if (result.value.outcome === 'noop') {
-                }
-            }
-            if (hasSuspension) {
-                for (const id of unexecutedIds) {
-                    const tc = executableCallsById.get(id);
-                    pending[tc.toolCallId] = {
-                        suspended: false,
-                        toolCallId: tc.toolCallId,
-                        toolName: tc.toolName,
-                        input: tc.input,
-                    };
-                }
-                break;
-            }
-        }
-        return { results, suspensions, errors, pending };
-    }
-    async iteratePendingToolCallsConcurrent(ctx) {
-        const { pendingResume, toolMap, list, runId, persistence, telemetry: resolvedTelemetry, executionCounter, abortSignal, } = ctx;
-        const resumedId = pendingResume.resumeToolCallId;
-        const resumedEntry = pendingResume.pendingToolCalls[resumedId];
-        if (!resumedEntry) {
-            throw new Error(`No pending tool call found for toolCallId: ${resumedId}`);
-        }
-        const resumedToolName = resumedEntry.toolName;
-        const results = [];
-        const suspensions = [];
-        const errors = [];
-        const pending = {};
-        let processResult;
-        try {
-            processResult = await this.processToolCall(resumedEntry.toolCallId, resumedToolName, resumedEntry.input, toolMap, list, runId, persistence, pendingResume.resumeData, resolvedTelemetry, executionCounter, abortSignal, false);
-        }
-        catch (error) {
-            processResult = { outcome: 'error', error };
-            list.setToolCallError(resumedEntry.toolCallId, error);
-        }
-        if (processResult.outcome === 'suspended') {
-            pending[resumedId] = {
-                ...resumedEntry,
-                suspended: true,
-                suspendPayload: processResult.payload,
-                resumeSchema: processResult.resumeSchema,
-                runId,
-            };
-            suspensions.push({
-                toolCallId: resumedId,
-                toolName: resumedToolName,
-                input: resumedEntry.input,
-                payload: processResult.payload,
-                resumeSchema: processResult.resumeSchema,
-            });
-        }
-        else if (processResult.outcome === 'success') {
-            results.push({
-                toolCallId: resumedEntry.toolCallId,
-                toolName: resumedToolName,
-                input: resumedEntry.input,
-                toolEntry: processResult.toolEntry,
-                modelOutput: processResult.modelOutput,
-                customMessage: processResult.customMessage,
-            });
-        }
-        else if (processResult.outcome === 'cancelled') {
-            results.push({
-                toolCallId: resumedEntry.toolCallId,
-                toolName: resumedToolName,
-                input: resumedEntry.input,
-                toolEntry: processResult.toolEntry,
-                modelOutput: processResult.modelOutput,
-            });
-            list.addInput([
-                { role: 'user', content: [{ type: 'text', text: processResult.userMessage }] },
-            ]);
-            for (const id of Object.keys(pendingResume.pendingToolCalls)) {
-                if (id !== resumedId) {
-                    const siblingEntry = pendingResume.pendingToolCalls[id];
-                    const modelOutput = '[Skipped: a sibling tool call was cancelled]';
-                    list.setToolCallResult(id, modelOutput, {
-                        canceled: true,
-                    });
-                    results.push({
-                        toolCallId: siblingEntry.toolCallId,
-                        toolName: siblingEntry.toolName,
-                        input: siblingEntry.input,
-                        toolEntry: {
-                            tool: siblingEntry.toolName,
-                            input: siblingEntry.input,
-                            output: modelOutput,
-                            transformed: false,
-                            canceled: true,
-                        },
-                        modelOutput,
-                    });
-                }
-            }
-            return { results, suspensions, errors, pending };
-        }
-        else if (processResult.outcome === 'error') {
-            errors.push({
-                toolCallId: resumedEntry.toolCallId,
-                toolName: resumedToolName,
-                input: resumedEntry.input,
-                error: processResult.error,
-            });
-        }
-        else if (processResult.outcome === 'noop') {
-        }
-        const unexecuted = [];
-        for (const [id, entry] of Object.entries(pendingResume.pendingToolCalls)) {
-            if (id === resumedId)
-                continue;
-            const entryToolName = entry.toolName;
-            if (entry.suspended) {
-                pending[id] = entry;
-                suspensions.push({
-                    toolCallId: id,
-                    toolName: entryToolName,
-                    input: entry.input,
-                    payload: entry.suspendPayload,
-                    resumeSchema: entry.resumeSchema,
-                });
-            }
-            else {
-                unexecuted.push({
-                    toolCallId: id,
-                    toolName: entryToolName,
-                    input: entry.input,
-                });
-            }
-        }
-        if (unexecuted.length > 0) {
-            const batch = await this.iterateToolCallsConcurrent({
-                toolCalls: unexecuted,
-                toolMap,
-                list,
-                runId,
-                persistence,
-                telemetry: resolvedTelemetry,
-                executionCounter,
-                abortSignal,
-                isAborted: ctx.isAborted,
-            });
-            results.push(...batch.results);
-            suspensions.push(...batch.suspensions);
-            errors.push(...batch.errors);
-            Object.assign(pending, batch.pending);
-        }
-        return { results, suspensions, errors, pending };
-    }
-    async processToolCall(toolCallId, toolName, toolInput, toolMap, list, runId, persistence, resumeData, resolvedTelemetry, executionCounter, abortSignal, countToolCall = true) {
-        const builtTool = toolMap.get(toolName);
-        const makeToolError = (error) => {
-            this.eventBus.emit({
-                type: "tool_execution_end",
-                toolCallId,
-                toolName,
-                result: error,
-                isError: true,
-            });
-            list.setToolCallError(toolCallId, error);
-            return { outcome: 'error', error };
-        };
-        if (!builtTool) {
-            return makeToolError(new Error(`Tool ${toolName} not found`));
-        }
-        const settledBlock = list
-            .responseDelta()
-            .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: settledResult,
-                isError: settledBlock.state === 'rejected',
-            });
-            return { outcome: 'noop' };
-        }
-        if ((0, cancellation_1.isCancellation)(resumeData) && !builtTool.handleCancellation) {
-            const modelOutput = `[Tool call cancelled. User said: "${resumeData.message}"]`;
-            this.eventBus.emit({
-                type: "tool_execution_end",
-                toolCallId,
-                toolName,
-                result: modelOutput,
-                isError: false,
-            });
-            list.setToolCallResult(toolCallId, modelOutput, { canceled: true });
-            return {
-                outcome: 'cancelled',
-                toolEntry: {
-                    tool: toolName,
-                    input: toolInput,
-                    output: modelOutput,
-                    transformed: false,
-                    canceled: true,
-                },
-                modelOutput,
-                userMessage: resumeData.message,
-                canceled: true,
-            };
-        }
-        if (countToolCall) {
-            this.incrementToolCallCount(executionCounter);
-        }
-        if (builtTool.inputSchema) {
-            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;
-        }
-        if (shouldEmitToolExecutionStart(builtTool, resumeData)) {
-            this.eventBus.emit({
-                type: "tool_execution_start",
-                toolCallId,
-                toolName,
-                args: toolInput,
-            });
-        }
-        let toolResult;
-        try {
-            toolResult = await this.withTelemetryToolSpan(toolCallId, toolName, toolInput, resolvedTelemetry, async () => await (0, tool_adapter_1.executeTool)(toolInput, builtTool, resumeData, resolvedTelemetry, toolCallId, {
-                runId,
-                persistence,
-                emitEvent: (event) => this.eventBus.emit(event),
-                abortSignal,
-                executionCounter,
-            }));
-        }
-        catch (error) {
-            return makeToolError(error);
-        }
-        if ((0, tool_adapter_1.isSuspendedToolResult)(toolResult)) {
-            if (builtTool?.suspendSchema) {
-                const parseResult = await (0, parse_1.parseWithSchema)(builtTool.suspendSchema, toolResult.payload);
-                if (!parseResult.success) {
-                    return makeToolError(new Error(`Invalid suspend payload: ${parseResult.error}`));
-                }
-                toolResult.payload = parseResult.data;
-            }
-            if (!builtTool?.resumeSchema) {
-                const error = new Error(`Tool ${toolName} has no resume schema`);
-                return makeToolError(error);
-            }
-            const resumeSchema = getToolResumeJsonSchema(builtTool);
-            if (!resumeSchema) {
-                return makeToolError(new Error('Invalid resume schema'));
-            }
-            return {
-                outcome: 'suspended',
-                payload: toolResult.payload,
-                resumeSchema,
-            };
-        }
-        let modelResult;
-        try {
-            modelResult = builtTool.toModelOutput ? builtTool.toModelOutput(toolResult) : toolResult;
-        }
-        catch (error) {
-            return makeToolError(error);
-        }
-        this.eventBus.emit({
-            type: "tool_execution_end",
-            toolCallId,
-            toolName,
-            result: toolResult,
-            isError: false,
-        });
-        list.setToolCallResult(toolCallId, (0, json_value_1.toJsonValue)(modelResult));
-        const customMessage = builtTool?.toMessage?.(toolResult);
-        if (customMessage) {
-            list.addResponse([customMessage]);
-        }
-        return {
-            outcome: 'success',
-            toolEntry: {
-                tool: toolName,
-                input: toolInput,
-                output: toolResult,
-                transformed: !!builtTool.toModelOutput,
-            },
-            modelOutput: modelResult,
-            customMessage,
-        };
-    }
-    buildStaticLoopContext(execOptions) {
-        const { Output, jsonSchema } = getAiSdk();
-        const aiProviderTools = (0, tool_adapter_1.toAiSdkProviderTools)(this.config.providerTools);
-        const model = (0, model_factory_1.createModel)(this.config.model);
-        const outputSchema = this.config.structuredOutput;
-        const isRawJsonSchemaOutput = outputSchema !== undefined && !(0, zod_1.isZodSchema)(outputSchema);
-        const providerOptions = this.relaxStrictJsonSchemaIfNeeded(this.buildCallProviderOptions(execOptions?.providerOptions), isRawJsonSchemaOutput);
-        const outputSpec = outputSchema
-            ? Output.object({
-                schema: (0, zod_1.isZodSchema)(outputSchema)
-                    ? outputSchema
-                    : jsonSchema((0, json_schema_1.lockAdditionalProperties)(outputSchema)),
-            })
-            : undefined;
-        return {
-            model,
-            aiProviderTools,
-            providerOptions,
-            outputSpec,
-        };
-    }
-    relaxStrictJsonSchemaIfNeeded(providerOptions, isRawJsonSchemaOutput) {
-        if (!isRawJsonSchemaOutput)
-            return providerOptions;
-        const result = { ...providerOptions };
-        for (const provider of ['openai', 'groq']) {
-            result[provider] = { strictJsonSchema: false, ...result[provider] };
-        }
-        return result;
-    }
-    buildToolLoopContext(aiProviderTools, persistence, executionCounter) {
-        const allUserTools = this.getCurrentTools(persistence, executionCounter);
-        const aiTools = (0, tool_adapter_1.toAiSdkTools)(allUserTools);
-        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(persistence, executionCounter) {
-        const baseTools = this.config.tools ?? [];
-        const tools = [
-            ...baseTools,
-            ...(this.deferredToolManager?.hasTools
-                ? [
-                    ...this.deferredToolManager.getControllerTools(),
-                    ...this.deferredToolManager.getLoadedTools(),
-                ]
-                : []),
-        ];
-        const recallTool = this.createRecallMemoryToolForRun(persistence, tools, executionCounter);
-        return recallTool ? [...tools, recallTool] : tools;
-    }
-    createRecallMemoryToolForRun(persistence, existingTools, executionCounter) {
-        const { memory, episodicMemory } = this.config;
-        if (!memory ||
-            !episodicMemory ||
-            !(0, episodic_memory_1.isEpisodicMemoryEnabled)(episodicMemory) ||
-            !(0, episodic_memory_1.hasEpisodicMemoryStore)(memory)) {
-            return undefined;
-        }
-        const scope = (0, episodic_memory_1.getEpisodicMemoryScope)(persistence);
-        if (!scope)
-            return undefined;
-        if (existingTools.some((tool) => tool.name === episodic_memory_1.RECALL_MEMORY_TOOL_NAME)) {
-            throw new Error(`Tool name "${episodic_memory_1.RECALL_MEMORY_TOOL_NAME}" is reserved while episodic memory is enabled.`);
-        }
-        return (0, episodic_memory_1.createRecallMemoryTool)({ memory, config: episodicMemory, scope, executionCounter });
-    }
-    hydrateDeferredToolsFromList(list) {
-        if (!this.deferredToolManager?.hasTools)
-            return;
-        this.deferredToolManager.hydrateLoadedToolsFromMessages(list.serialize().messages);
-    }
-    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;
-    }
-    async persistSuspension(pendingToolCalls, options, list, totalUsage, maxIterations, iterationCount) {
-        const resolvedMaxIterations = maxIterations ?? options?.maxIterations;
-        const resolvedIterationCount = iterationCount ?? options?.iterationCount;
-        const executionOptions = resolvedMaxIterations !== undefined ? { maxIterations: resolvedMaxIterations } : undefined;
-        const state = {
-            persistence: options?.persistence,
-            status: 'suspended',
-            messageList: list.serialize(),
-            pendingToolCalls,
-            usage: totalUsage,
-            executionOptions,
-            ...(resolvedIterationCount !== undefined ? { iterationCount: resolvedIterationCount } : {}),
-        };
-        await this.runState.suspend(this.runId, state);
-        this.updateState({ status: 'suspended', pendingToolCalls, messageList: list.serialize() });
-        return this.runId;
-    }
-    async cleanupRun() {
-        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 });
-        }
-    }
-    updateState(patch) {
-        this.currentState = { ...this.currentState, ...patch };
-    }
-    get modelIdString() {
-        const m = this.config.model;
-        if (typeof m === 'string')
-            return m;
-        if ('id' in m && typeof m.id === 'string')
-            return m.id;
-        if ('modelId' in m && typeof m.modelId === 'string') {
-            const provider = 'provider' in m ? String(m.provider) : 'unknown';
-            return `${provider}/${m.modelId}`;
-        }
-        return 'unknown';
-    }
-    get concurrency() {
-        return this.config.toolCallConcurrency ?? 1;
-    }
-    async ensureModelCost() {
-        if (this.modelCost)
-            return this.modelCost;
-        try {
-            this.modelCost = await (0, catalog_1.getModelCost)(this.modelIdString);
-        }
-        catch {
-        }
-        return this.modelCost;
-    }
-    applyCost(usage) {
-        if (!usage || !this.modelCost)
-            return usage;
-        return { ...usage, cost: (0, catalog_1.computeCost)(usage, this.modelCost) };
-    }
-    async setListObservationLogMemory(list, options) {
-        const memory = this.config.memory;
-        if (!memory || !options?.threadId || !(0, observation_log_store_1.hasObservationLogStore)(memory))
-            return;
-        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;
-        if (observations.length > 0) {
-            list.seedLastCreatedAt(observations[observations.length - 1].createdAt.getTime());
-        }
-    }
-    getConfiguredTelemetry() {
-        return this.config.telemetry;
-    }
-}
-exports.AgentRuntime = AgentRuntime;
-//# sourceMappingURL=agent-runtime.js.map