@n8n/agents 0.1.0

package/dist/runtime/agent-runtime.js

@@ -0,0 +1,1246 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        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 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 run_state_1 = require("./run-state");
+const runtime_helpers_1 = require("./runtime-helpers");
+const stream_1 = require("./stream");
+const strip_orphaned_tool_messages_1 = require("./strip-orphaned-tool-messages");
+const title_generation_1 = require("./title-generation");
+const tool_adapter_1 = require("./tool-adapter");
+const working_memory_1 = require("./working-memory");
+const zod_1 = require("../utils/zod");
+const logger = (0, logger_1.createFilteredLogger)();
+function isTextPart(part) {
+    return (typeof part === 'object' &&
+        part !== null &&
+        'type' in part &&
+        part.type === 'text' &&
+        'text' in part);
+}
+const MAX_LOOP_ITERATIONS = 20;
+const ajv = new ajv_1.default({ strict: false });
+const EMPTY_MESSAGE_LIST = {
+    messages: [],
+    historyIds: [],
+    inputIds: [],
+    responseIds: [],
+};
+class AgentRuntime {
+    constructor(config) {
+        this.config = config;
+        this.runState = new run_state_1.RunStateManager(config.checkpointStorage);
+        this.eventBus = config.eventBus ?? new event_bus_1.AgentEventBus();
+        this.currentState = {
+            persistence: undefined,
+            status: 'idle',
+            messageList: EMPTY_MESSAGE_LIST,
+            pendingToolCalls: {},
+        };
+    }
+    getState() {
+        return { ...this.currentState };
+    }
+    abort() {
+        this.eventBus.abort();
+    }
+    async generate(input, options) {
+        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);
+            return this.finalizeGenerate(rawResult, list, runId);
+        }
+        catch (error) {
+            await this.flushTelemetry(options);
+            const isAbort = this.eventBus.isAborted;
+            this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
+            if (!isAbort) {
+                this.eventBus.emit({ type: "error", message: String(error), error });
+            }
+            return { runId, messages: list?.responseDelta() ?? [], finishReason: 'error', error };
+        }
+    }
+    async stream(input, options) {
+        const runId = (0, run_state_1.generateRunId)();
+        let list;
+        try {
+            list = await this.initRun(input, options);
+        }
+        catch (error) {
+            const isAbort = this.eventBus.isAborted;
+            this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
+            if (!isAbort) {
+                this.eventBus.emit({ type: "error", message: String(error), error });
+            }
+            return { runId, stream: (0, runtime_helpers_1.makeErrorStream)(error) };
+        }
+        return { runId, stream: this.startStreamLoop(list, options, undefined, runId) };
+    }
+    async resume(method, data, options) {
+        const state = await this.runState.resume(options.runId);
+        if (!state)
+            throw new Error(`No suspended run found for runId: ${options.runId}`);
+        const toolCall = state.pendingToolCalls[options.toolCallId];
+        if (!toolCall)
+            throw new Error(`No tool call found for toolCallId: ${options.toolCallId}`);
+        const tool = this.config.tools?.find((t) => t.name === toolCall.toolName);
+        if (!tool)
+            throw new Error(`Tool ${toolCall.toolName} not found`);
+        let resumeData = data;
+        if (tool.resumeSchema) {
+            const parseResult = await tool.resumeSchema.safeParseAsync(data);
+            if (!parseResult.success) {
+                throw new Error(`Invalid resume payload: ${parseResult.error.message}`);
+            }
+            resumeData = parseResult.data;
+        }
+        try {
+            const list = message_list_1.AgentMessageList.deserialize(state.messageList);
+            const { runId: _rid, toolCallId: _tcid, ...callerExecOptions } = options;
+            const persisted = state.executionOptions ?? {};
+            const mergedExecOptions = {
+                ...persisted,
+                ...callerExecOptions,
+            };
+            const resumeOptions = {
+                persistence: state.persistence,
+                ...mergedExecOptions,
+            };
+            this.eventBus.resetAbort(resumeOptions.abortSignal);
+            const pendingResume = {
+                pendingToolCalls: state.pendingToolCalls,
+                resumeToolCallId: options.toolCallId,
+                resumeData,
+                messages: state.messageList.messages,
+            };
+            await this.ensureModelCost();
+            await this.setListWorkingMemoryConfig(list, state.persistence);
+            if (method === 'generate') {
+                const rawResult = await this.runGenerateLoop(list, resumeOptions, pendingResume, options.runId);
+                if (!rawResult.pendingSuspend) {
+                    await this.cleanupRun(options.runId);
+                }
+                return this.finalizeGenerate(rawResult, list, options.runId);
+            }
+            return {
+                runId: options.runId,
+                stream: this.startStreamLoop(list, resumeOptions, pendingResume, options.runId),
+            };
+        }
+        catch (error) {
+            const isAbort = this.eventBus.isAborted;
+            this.updateState({ status: isAbort ? 'cancelled' : 'failed' });
+            if (!isAbort) {
+                this.eventBus.emit({ type: "error", message: String(error), error });
+            }
+            if (method === 'generate') {
+                return {
+                    runId: options.runId,
+                    messages: [],
+                    finishReason: 'error',
+                    error,
+                };
+            }
+            return { runId: options.runId, stream: (0, runtime_helpers_1.makeErrorStream)(error) };
+        }
+    }
+    async buildMessageList(input, options) {
+        const list = new message_list_1.AgentMessageList();
+        if (this.config.memory && options?.persistence?.threadId) {
+            const memMessages = await this.config.memory.getMessages(options.persistence.threadId, {
+                limit: this.config.lastMessages ?? 10,
+            });
+            if (memMessages.length > 0) {
+                list.addHistory((0, strip_orphaned_tool_messages_1.stripOrphanedToolMessages)(memMessages.map(message_1.toDbMessage)));
+            }
+        }
+        if (this.config.semanticRecall && options?.persistence?.threadId) {
+            await this.performSemanticRecall(list, input, options.persistence.threadId, options.persistence.resourceId);
+        }
+        await this.setListWorkingMemoryConfig(list, options?.persistence);
+        list.addInput(input);
+        return list;
+    }
+    async performSemanticRecall(list, input, threadId, resourceId) {
+        if (!this.config.semanticRecall || !this.config.memory)
+            return;
+        const userText = input
+            .filter((m) => (0, message_1.isLlmMessage)(m) && m.role === 'user')
+            .flatMap((m) => ((0, message_1.isLlmMessage)(m) ? m.content : []))
+            .filter((c) => c.type === 'text')
+            .map((c) => c.text)
+            .join(' ');
+        if (!userText)
+            return;
+        let recalled = [];
+        if (this.config.memory.queryEmbeddings && this.config.semanticRecall.embedder) {
+            const { embed } = await Promise.resolve().then(() => __importStar(require('ai')));
+            const embeddingModel = (0, model_factory_1.createEmbeddingModel)(this.config.semanticRecall.embedder, this.config.semanticRecall.apiKey);
+            const { embedding } = await embed({ model: embeddingModel, value: userText });
+            const hits = await this.config.memory.queryEmbeddings({
+                scope: this.config.semanticRecall.scope ?? 'resource',
+                threadId,
+                resourceId,
+                vector: embedding,
+                topK: this.config.semanticRecall.topK,
+            });
+            if (hits.length > 0) {
+                const hitIds = new Set(hits.map((h) => h.id));
+                const allMsgs = await this.config.memory.getMessages(threadId);
+                if (this.config.semanticRecall.messageRange) {
+                    recalled = this.expandMessageRange(allMsgs, hitIds, this.config.semanticRecall.messageRange);
+                }
+                else {
+                    recalled = allMsgs.filter((m) => {
+                        const id = 'id' in m && typeof m.id === 'string' ? m.id : undefined;
+                        return id !== undefined && hitIds.has(id);
+                    });
+                }
+            }
+        }
+        else if (this.config.memory.search) {
+            recalled = await this.config.memory.search(userText, {
+                threadId,
+                resourceId,
+                topK: this.config.semanticRecall.topK,
+                messageRange: this.config.semanticRecall.messageRange,
+            });
+        }
+        if (recalled.length === 0)
+            return;
+        const { historyIds } = list.serialize();
+        const historyIdSet = new Set(historyIds);
+        const newRecalled = recalled
+            .filter((m) => {
+            const id = 'id' in m && typeof m.id === 'string' ? m.id : undefined;
+            return !id || !historyIdSet.has(id);
+        })
+            .map(message_1.toDbMessage);
+        if (newRecalled.length > 0) {
+            list.addHistory(newRecalled);
+        }
+    }
+    expandMessageRange(allMsgs, hitIds, range) {
+        const expandedIds = new Set();
+        for (const msg of allMsgs) {
+            const id = 'id' in msg && typeof msg.id === 'string' ? msg.id : undefined;
+            if (!id || !hitIds.has(id))
+                continue;
+            const idx = allMsgs.indexOf(msg);
+            const start = Math.max(0, idx - (range.before ?? 0));
+            const end = Math.min(allMsgs.length - 1, idx + (range.after ?? 0));
+            for (let i = start; i <= end; i++) {
+                const el = allMsgs[i];
+                const mid = 'id' in el && typeof el.id === 'string' ? el.id : undefined;
+                if (mid)
+                    expandedIds.add(mid);
+            }
+        }
+        return allMsgs.filter((m) => {
+            const mid = 'id' in m && typeof m.id === 'string' ? m.id : undefined;
+            return mid && expandedIds.has(mid);
+        });
+    }
+    async initRun(input, options) {
+        this.eventBus.resetAbort(options?.abortSignal);
+        this.updateState({
+            status: 'running',
+            persistence: options?.persistence,
+        });
+        this.eventBus.emit({ type: "agent_start" });
+        await this.ensureModelCost();
+        const normalizedInput = (0, runtime_helpers_1.normalizeInput)(input);
+        return await this.buildMessageList(normalizedInput, options);
+    }
+    finalizeGenerate(result, list, runId) {
+        result.runId = runId;
+        result.usage = this.applyCost(result.usage);
+        result.model = this.modelIdString;
+        const finalized = (0, runtime_helpers_1.applySubAgentUsage)(result);
+        this.updateState({ status: 'success', messageList: list.serialize() });
+        this.eventBus.emit({ type: "agent_end", messages: finalized.messages });
+        return finalized;
+    }
+    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) {
+        try {
+            const resolved = this.resolveTelemetry(options);
+            if (resolved?.provider) {
+                await resolved.provider.forceFlush();
+            }
+        }
+        catch {
+        }
+    }
+    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,
+            },
+        };
+    }
+    async runGenerateLoop(list, options, pendingResume, runId) {
+        const { model, toolMap, aiTools, providerOptions, hasTools, outputSpec } = this.buildLoopContext(options);
+        let totalUsage;
+        let lastFinishReason = 'stop';
+        let structuredOutput;
+        const toolCallSummary = [];
+        const collectedSubAgentUsage = [];
+        const runTelemetry = this.resolveTelemetry(options);
+        if (pendingResume) {
+            const batch = await this.iteratePendingToolCallsConcurrent(pendingResume, toolMap, list, runTelemetry);
+            for (const r of batch.results) {
+                toolCallSummary.push(r.toolEntry);
+                if (r.subAgentUsage)
+                    collectedSubAgentUsage.push(...r.subAgentUsage);
+            }
+            if (Object.keys(batch.pending).length > 0) {
+                const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, runId);
+                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,
+                    })),
+                };
+            }
+        }
+        const maxIterations = options?.maxIterations ?? MAX_LOOP_ITERATIONS;
+        for (let i = 0; i < maxIterations; i++) {
+            if (this.eventBus.isAborted) {
+                this.updateState({ status: 'cancelled' });
+                throw new Error('Agent run was aborted');
+            }
+            this.eventBus.emit({ type: "turn_start" });
+            const result = await (0, ai_1.generateText)({
+                model,
+                messages: list.forLlm(this.config.instructions, this.config.instructionProviderOptions),
+                abortSignal: this.eventBus.signal,
+                ...(hasTools ? { tools: aiTools } : {}),
+                ...(providerOptions
+                    ? { providerOptions: providerOptions }
+                    : {}),
+                ...(outputSpec ? { output: outputSpec } : {}),
+                ...this.buildTelemetryOptions(options),
+            });
+            const aiFinishReason = result.finishReason;
+            lastFinishReason = (0, messages_1.fromAiFinishReason)(aiFinishReason);
+            totalUsage = (0, runtime_helpers_1.accumulateUsage)(totalUsage, result.usage);
+            const responseMessages = result.response.messages;
+            const newMessages = (0, messages_1.fromAiMessages)(responseMessages);
+            list.addResponse(newMessages);
+            if (aiFinishReason !== 'tool-calls') {
+                if (outputSpec) {
+                    structuredOutput = result.output;
+                }
+                this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractToolResults)(newMessages));
+                break;
+            }
+            const batch = await this.iterateToolCallsConcurrent(result.toolCalls, toolMap, list, runTelemetry);
+            for (const r of batch.results) {
+                toolCallSummary.push(r.toolEntry);
+                if (r.subAgentUsage)
+                    collectedSubAgentUsage.push(...r.subAgentUsage);
+            }
+            if (Object.keys(batch.pending).length > 0) {
+                const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, runId);
+                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,
+                    })),
+                };
+            }
+            this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractToolResults)(list.responseDelta()));
+        }
+        if (lastFinishReason === 'tool-calls') {
+            throw new Error(`Agent loop exceeded ${maxIterations} iterations without reaching a stop condition`);
+        }
+        if (this.config.workingMemory &&
+            this.config.memory?.saveWorkingMemory &&
+            options?.persistence) {
+            this.extractAndPersistWorkingMemory(list, {
+                threadId: options.persistence.threadId,
+                resourceId: options.persistence.resourceId,
+                scope: this.config.workingMemory?.scope ?? 'resource',
+            });
+        }
+        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)({
+                memory: this.config.memory,
+                threadId: options.persistence.threadId,
+                resourceId: options.persistence.resourceId,
+                titleConfig: this.config.titleGeneration,
+                agentModel: this.config.model,
+                turnDelta: list.turnDelta(),
+            });
+        }
+        return {
+            runId: runId ?? '',
+            messages: list.responseDelta(),
+            finishReason: lastFinishReason,
+            usage: totalUsage,
+            ...(structuredOutput !== undefined && { structuredOutput }),
+            ...(toolCallSummary.length > 0 && { toolCalls: toolCallSummary }),
+            ...(collectedSubAgentUsage.length > 0 && { subAgentUsage: collectedSubAgentUsage }),
+        };
+    }
+    startStreamLoop(list, options, pendingResume, runId) {
+        const { readable, writable } = new TransformStream();
+        const writer = writable.getWriter();
+        this.runStreamLoop(list, options, writer, pendingResume, runId).catch(async (error) => {
+            await this.flushTelemetry(options);
+            await this.cleanupRun(runId);
+            try {
+                await writer.write({ type: 'error', error });
+                await writer.write({ type: 'finish', finishReason: 'error' });
+                await writer.close();
+            }
+            catch {
+                writer.abort(error).catch(() => { });
+            }
+        });
+        return readable;
+    }
+    async runStreamLoop(list, options, writer, pendingResume, runId) {
+        const { model, toolMap, aiTools, providerOptions, hasTools, outputSpec } = this.buildLoopContext(options);
+        const wmParamsStream = this.resolveWorkingMemoryParams(options?.persistence);
+        const wmFilter = wmParamsStream?.persistFn
+            ? new working_memory_1.WorkingMemoryStreamFilter(writer, async (content) => {
+                await wmParamsStream.persistFn(content);
+            })
+            : undefined;
+        const writeChunk = async (chunk) => {
+            if (wmFilter) {
+                await wmFilter.write(chunk);
+            }
+            else {
+                await writer.write(chunk);
+            }
+        };
+        let totalUsage;
+        let lastFinishReason = 'stop';
+        let structuredOutput;
+        const collectedSubAgentUsage = [];
+        const maxIterations = options?.maxIterations ?? MAX_LOOP_ITERATIONS;
+        const closeStreamWithError = async (error, status) => {
+            await this.cleanupRun(runId);
+            this.updateState({ status });
+            if (wmFilter)
+                await wmFilter.flush();
+            await writer.write({ type: 'error', error });
+            await writer.write({ type: 'finish', finishReason: 'error' });
+            await writer.close();
+        };
+        const handleAbort = async () => {
+            if (!this.eventBus.isAborted)
+                return false;
+            await closeStreamWithError(new Error('Agent run was aborted'), 'cancelled');
+            return true;
+        };
+        const runTelemetry = this.resolveTelemetry(options);
+        if (pendingResume) {
+            try {
+                const batch = await this.iteratePendingToolCallsConcurrent(pendingResume, toolMap, list, runTelemetry);
+                for (const r of batch.results) {
+                    if (r.subAgentUsage)
+                        collectedSubAgentUsage.push(...r.subAgentUsage);
+                    await writer.write({
+                        type: 'message',
+                        message: r.message,
+                    });
+                    if (r.customMessage) {
+                        await writer.write({ type: 'message', message: r.customMessage });
+                    }
+                }
+                for (const e of batch.errors) {
+                    await writer.write({
+                        type: 'message',
+                        message: e.message,
+                    });
+                }
+                if (Object.keys(batch.pending).length > 0) {
+                    const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, runId);
+                    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 (let i = 0; i < maxIterations; i++) {
+            if (await handleAbort())
+                return;
+            this.eventBus.emit({ type: "turn_start" });
+            const result = (0, ai_1.streamText)({
+                model,
+                messages: list.forLlm(this.config.instructions, this.config.instructionProviderOptions),
+                abortSignal: this.eventBus.signal,
+                ...(hasTools ? { tools: aiTools } : {}),
+                ...(providerOptions
+                    ? { providerOptions: providerOptions }
+                    : {}),
+                ...(outputSpec ? { output: outputSpec } : {}),
+                ...this.buildTelemetryOptions(options),
+            });
+            try {
+                for await (const chunk of result.fullStream) {
+                    if (chunk.type === 'finish' || chunk.type === 'finish-step')
+                        continue;
+                    const converted = (0, stream_1.convertChunk)(chunk);
+                    if (converted)
+                        await writeChunk(converted);
+                }
+            }
+            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);
+            const responseMessages = response.messages;
+            const newMessages = (0, messages_1.fromAiMessages)(responseMessages);
+            list.addResponse(newMessages);
+            if (aiFinishReason !== 'tool-calls') {
+                if (outputSpec) {
+                    structuredOutput = await result.output;
+                }
+                this.emitTurnEnd(newMessages, (0, runtime_helpers_1.extractToolResults)(newMessages));
+                break;
+            }
+            const toolCalls = await result.toolCalls;
+            try {
+                const batch = await this.iterateToolCallsConcurrent(toolCalls, toolMap, list, runTelemetry);
+                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,
+                    });
+                    if (r.customMessage) {
+                        await writer.write({ type: 'message', message: r.customMessage });
+                    }
+                }
+                for (const e of batch.errors) {
+                    await writer.write({
+                        type: 'message',
+                        message: e.message,
+                    });
+                }
+                if (Object.keys(batch.pending).length > 0) {
+                    const suspendRunId = await this.persistSuspension(batch.pending, options, list, totalUsage, runId);
+                    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.extractToolResults)(list.responseDelta()));
+        }
+        if (wmFilter)
+            await wmFilter.flush();
+        const costUsage = this.applyCost(totalUsage);
+        const parentCost = costUsage?.cost ?? 0;
+        const subCost = collectedSubAgentUsage.reduce((sum, s) => sum + (s.usage.cost ?? 0), 0);
+        await writer.write({
+            type: 'finish',
+            finishReason: lastFinishReason,
+            ...(costUsage && { usage: costUsage }),
+            model: this.modelIdString,
+            ...(structuredOutput !== undefined && { structuredOutput }),
+            ...(collectedSubAgentUsage.length > 0 && {
+                subAgentUsage: collectedSubAgentUsage,
+                totalCost: parentCost + subCost,
+            }),
+        });
+        try {
+            if (this.config.workingMemory &&
+                this.config.memory?.saveWorkingMemory &&
+                options?.persistence) {
+                this.extractAndPersistWorkingMemory(list, {
+                    threadId: options.persistence.threadId,
+                    resourceId: options.persistence.resourceId,
+                    scope: this.config.workingMemory?.scope ?? 'resource',
+                });
+            }
+            await this.saveToMemory(list, options);
+            if (this.config.titleGeneration && options?.persistence && this.config.memory) {
+                void (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(),
+                });
+            }
+            await this.cleanupRun(runId);
+            await this.flushTelemetry(options);
+            this.updateState({ status: 'success', messageList: list.serialize() });
+            this.eventBus.emit({ type: "agent_end", messages: list.responseDelta() });
+        }
+        finally {
+            await writer.close();
+        }
+    }
+    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);
+        if (this.config.semanticRecall?.embedder && this.config.memory.saveEmbeddings) {
+            await this.saveEmbeddingsForMessages(options.persistence.threadId, options.persistence.resourceId, delta);
+        }
+    }
+    async saveEmbeddingsForMessages(threadId, resourceId, messages) {
+        const embeddable = [];
+        for (const msg of messages) {
+            if (!(0, message_1.isLlmMessage)(msg) || (msg.role !== 'user' && msg.role !== 'assistant'))
+                continue;
+            const text = msg.content
+                .filter((c) => c.type === 'text')
+                .map((c) => c.text)
+                .join('\n');
+            if (!text)
+                continue;
+            embeddable.push({ id: msg.id, text });
+        }
+        if (embeddable.length === 0)
+            return;
+        const embedder = this.config.semanticRecall?.embedder;
+        if (!embedder)
+            return;
+        const { embedMany } = await Promise.resolve().then(() => __importStar(require('ai')));
+        const embeddingModel = (0, model_factory_1.createEmbeddingModel)(embedder, this.config.semanticRecall?.apiKey);
+        const { embeddings } = await embedMany({
+            model: embeddingModel,
+            values: embeddable.map((e) => e.text),
+        });
+        await this.config.memory.saveEmbeddings({
+            scope: this.config.semanticRecall?.scope ?? 'resource',
+            threadId,
+            resourceId,
+            entries: embeddable.map((e, i) => ({
+                id: e.id,
+                vector: embeddings[i],
+                text: e.text,
+                model: embedder,
+            })),
+        });
+    }
+    extractAndPersistWorkingMemory(list, params) {
+        const delta = list.responseDelta();
+        for (let i = delta.length - 1; i >= 0; i--) {
+            const msg = delta[i];
+            if (!(0, message_1.isLlmMessage)(msg) || msg.role !== 'assistant')
+                continue;
+            for (const part of msg.content) {
+                if (!isTextPart(part))
+                    continue;
+                const { cleanText, workingMemory } = (0, working_memory_1.parseWorkingMemory)(part.text);
+                if (workingMemory !== null) {
+                    if (this.config.workingMemory?.structured && this.config.workingMemory.schema) {
+                        try {
+                            this.config.workingMemory.schema.parse(JSON.parse(workingMemory));
+                        }
+                        catch {
+                            part.text = cleanText;
+                            return;
+                        }
+                    }
+                    part.text = cleanText;
+                    this.config.memory.saveWorkingMemory(params, workingMemory).catch((error) => {
+                        logger.warn('Failed to persist working memory', { error });
+                    });
+                }
+                return;
+            }
+        }
+    }
+    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;
+                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;
+    }
+    async iterateToolCallsConcurrent(toolCalls, toolMap, list, resolvedTelemetry) {
+        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));
+        const batchSize = this.concurrency;
+        const results = [];
+        const suspensions = [];
+        const errors = [];
+        const pending = {};
+        for (let batchStart = 0; batchStart < executableCalls.length; batchStart += batchSize) {
+            if (this.eventBus.isAborted) {
+                this.updateState({ status: 'cancelled' });
+                throw new Error('Agent run was aborted');
+            }
+            const batch = executableCalls.slice(batchStart, batchStart + batchSize);
+            const settledResults = await Promise.allSettled(batch.map(async (tc) => await this.processToolCall(tc.toolCallId, tc.toolName, tc.input, toolMap, list, undefined, resolvedTelemetry)));
+            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') {
+                    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') {
+                    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,
+                    };
+                }
+                else if (result.value.outcome === 'success') {
+                    results.push({
+                        toolCallId: tc.toolCallId,
+                        toolName: tc.toolName,
+                        input: toolInput,
+                        toolEntry: result.value.toolEntry,
+                        subAgentUsage: result.value.subAgentUsage,
+                        customMessage: result.value.customMessage,
+                        message: result.value.message,
+                    });
+                }
+                else if (result.value.outcome === 'error') {
+                    errors.push({
+                        toolCallId: tc.toolCallId,
+                        toolName: tc.toolName,
+                        input: toolInput,
+                        error: result.value.error,
+                        message: result.value.message,
+                    });
+                }
+                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(pendingResume, toolMap, list, resolvedTelemetry) {
+        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 = {};
+        const processResult = await this.processToolCall(resumedEntry.toolCallId, resumedToolName, resumedEntry.input, toolMap, list, pendingResume.resumeData, resolvedTelemetry);
+        if (processResult.outcome === 'suspended') {
+            pending[resumedId] = {
+                ...resumedEntry,
+                suspended: true,
+                suspendPayload: processResult.payload,
+                resumeSchema: processResult.resumeSchema,
+            };
+            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,
+                subAgentUsage: processResult.subAgentUsage,
+                customMessage: processResult.customMessage,
+                message: processResult.message,
+            });
+        }
+        else if (processResult.outcome === 'error') {
+            errors.push({
+                toolCallId: resumedEntry.toolCallId,
+                toolName: resumedToolName,
+                input: resumedEntry.input,
+                error: processResult.error,
+                message: processResult.message,
+            });
+        }
+        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(unexecuted, toolMap, list, resolvedTelemetry);
+            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, resumeData, resolvedTelemetry) {
+        const builtTool = toolMap.get(toolName);
+        this.eventBus.emit({
+            type: "tool_execution_start",
+            toolCallId,
+            toolName,
+            args: toolInput,
+        });
+        const makeToolError = (error) => {
+            this.eventBus.emit({
+                type: "tool_execution_end",
+                toolCallId,
+                toolName,
+                result: error,
+                isError: true,
+            });
+            const errorMsg = (0, runtime_helpers_1.makeErrorToolResultMessage)(toolCallId, toolName, error);
+            list.addResponse([errorMsg]);
+            return { outcome: 'error', error, message: errorMsg };
+        };
+        if (!builtTool) {
+            return makeToolError(new Error(`Tool ${toolName} not found`));
+        }
+        const existingToolResults = 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) {
+            this.eventBus.emit({
+                type: "tool_execution_end",
+                toolCallId,
+                toolName,
+                result: existingToolResult.result,
+                isError: !!existingToolResult.isError,
+            });
+            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}`));
+                }
+            }
+        }
+        let toolResult;
+        try {
+            toolResult = await (0, tool_adapter_1.executeTool)(toolInput, builtTool, resumeData, resolvedTelemetry);
+        }
+        catch (error) {
+            return makeToolError(error);
+        }
+        if ((0, tool_adapter_1.isSuspendedToolResult)(toolResult)) {
+            if (builtTool?.suspendSchema) {
+                const parseResult = await builtTool.suspendSchema.safeParseAsync(toolResult.payload);
+                if (!parseResult.success) {
+                    return makeToolError(new Error(`Invalid suspend payload: ${parseResult.error.message}`));
+                }
+                toolResult.payload = parseResult.data;
+            }
+            if (!builtTool?.resumeSchema) {
+                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 };
+        }
+        let actualResult = toolResult;
+        let extractedSubAgentUsage;
+        if ((0, tool_adapter_1.isAgentToolResult)(toolResult)) {
+            actualResult = toolResult.output;
+            extractedSubAgentUsage = toolResult.subAgentUsage;
+        }
+        this.eventBus.emit({
+            type: "tool_execution_end",
+            toolCallId,
+            toolName,
+            result: actualResult,
+            isError: false,
+        });
+        const modelResult = builtTool.toModelOutput
+            ? builtTool.toModelOutput(actualResult)
+            : actualResult;
+        const toolResultMsg = (0, runtime_helpers_1.makeToolResultMessage)(toolCallId, toolName, modelResult);
+        list.addResponse([toolResultMsg]);
+        const customToolMessage = builtTool?.toMessage?.(actualResult);
+        let customMessage;
+        if (customToolMessage) {
+            customMessage = (0, message_1.toDbMessage)(customToolMessage);
+            list.addResponse([customMessage]);
+        }
+        return {
+            outcome: 'success',
+            toolEntry: {
+                tool: toolName,
+                input: toolInput,
+                output: actualResult,
+                transformed: !!builtTool.toModelOutput,
+            },
+            subAgentUsage: extractedSubAgentUsage,
+            customMessage,
+            message: toolResultMsg,
+        };
+    }
+    buildLoopContext(execOptions) {
+        const aiTools = (0, tool_adapter_1.toAiSdkTools)(this.config.tools);
+        const aiProviderTools = (0, tool_adapter_1.toAiSdkProviderTools)(this.config.providerTools);
+        const allTools = { ...aiTools, ...aiProviderTools };
+        return {
+            model: (0, model_factory_1.createModel)(this.config.model),
+            toolMap: (0, tool_adapter_1.buildToolMap)(this.config.tools),
+            aiTools: allTools,
+            providerOptions: this.buildCallProviderOptions(execOptions?.providerOptions),
+            hasTools: Object.keys(allTools).length > 0,
+            outputSpec: this.config.structuredOutput
+                ? ai_1.Output.object({ schema: this.config.structuredOutput })
+                : undefined,
+        };
+    }
+    async persistSuspension(pendingToolCalls, options, list, totalUsage, existingRunId) {
+        const runId = existingRunId ?? (0, run_state_1.generateRunId)();
+        const executionOptions = options?.maxIterations !== undefined ? { maxIterations: options.maxIterations } : undefined;
+        const state = {
+            persistence: options?.persistence,
+            status: 'suspended',
+            messageList: list.serialize(),
+            pendingToolCalls,
+            usage: totalUsage,
+            executionOptions,
+        };
+        await this.runState.suspend(runId, state);
+        this.updateState({ status: 'suspended', pendingToolCalls, messageList: list.serialize() });
+        return runId;
+    }
+    async cleanupRun(runId) {
+        if (runId) {
+            await this.runState.complete(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 setListWorkingMemoryConfig(list, options) {
+        const wmParams = this.resolveWorkingMemoryParams(options);
+        if (!wmParams || !this.config.memory?.getWorkingMemory)
+            return;
+        const wmState = await this.config.memory.getWorkingMemory(wmParams.memoryParams);
+        list.workingMemory = {
+            template: wmParams.template,
+            structured: wmParams.structured,
+            state: wmState,
+        };
+    }
+    resolveWorkingMemoryParams(options) {
+        if (!options)
+            return null;
+        if (!this.config.workingMemory)
+            return null;
+        const scope = this.config.workingMemory?.scope ?? 'resource';
+        if (scope === 'resource' && !options.resourceId) {
+            throw new Error('Working memory scope is "resource" but no resourceId was provided. ' +
+                'Pass a resourceId in RunOptions or change the scope to "thread".');
+        }
+        if (!options)
+            return null;
+        const memoryParams = { ...options, scope };
+        const persistFn = this.config.workingMemory && this.config.memory?.saveWorkingMemory && options
+            ? async (content) => {
+                await this.config.memory.saveWorkingMemory(memoryParams, content);
+            }
+            : undefined;
+        if (!persistFn)
+            return null;
+        return {
+            persistFn,
+            memoryParams,
+            template: this.config.workingMemory.template,
+            structured: this.config.workingMemory.structured,
+            schema: this.config.workingMemory.schema,
+        };
+    }
+}
+exports.AgentRuntime = AgentRuntime;
+//# sourceMappingURL=agent-runtime.js.map