@tessar/core 0.1.0-alpha.0 → 0.1.0

package/dist/agent.js

@@ -1,23 +1,17 @@
-import { loop } from "./loop.js";
-import { providerCall, streamModel } from "./models/stream.js";
+import { stream as streamHooks } from "./events/type.js";
 import { createDelivery, } from "./engine/delivery.js";
-import { TessarError, errorInfo, errorFromInfo, fail, requireId, } from "./errors.js";
+import { errorInfo, errorFromInfo, fail, requireId, } from "./errors.js";
 import { immutable, randomIds, systemClock, } from "./json.js";
 import { normalizeInstruction, } from "./instructions/instruction.js";
-import { AgentEvents, } from "./events/catalog.js";
-import {} from "./events/definition.js";
 import { MessageCodec } from "./messages/codec.js";
-import { ToolMessage } from "./messages/message.js";
-import { PluginHost } from "./plugins/host.js";
-import { CommitCoordinator } from "./state/commit.js";
-import { PluginStateAccess, } from "./state/plugin-state.js";
-import { aggregateUsage, normalizeUsage } from "./trace/usage.js";
-import { Suspension } from "./engine/interrupt.js";
-import { phaseForEvent, validateManifest, validateResume, } from "./engine/resume.js";
-import { canonicalJson } from "./state/commit.js";
-import { RecoveryService } from "./engine/recovery.js";
-import { EffectService, childStateDefinition, } from "./engine/tracked-effects.js";
-import { resolveChildAdmission, summarizeStreamUsage, } from "./engine/lineage.js";
+import { Tool } from "./tools/tool.js";
+import { execute, cancel } from "./engine/execution.js";
+import { hook } from "./engine/hooks.js";
+import { put, rows, commit, updateUsage, prepareMessage, appendMessage, finish, } from "./engine/checkpoint.js";
+import { services } from "./engine/services.js";
+import { callAgent, modelRef, readOutcome } from "./engine/call.js";
+import { isModelAdapter } from "./models/stream.js";
+import { reserveId } from "./identity.js";
 export function inputMessages(input) {
     const values = Array.isArray(input) ? input : [input];
     return values.map((value) => MessageCodec.encode(MessageCodec.decode(MessageCodec.encode(value))));
@@ -29,6 +23,8 @@ function validateLimits(limits) {
 }
 export class Agent {
     id;
+    tools;
+    /** @internal */ toolConcurrency;
     model;
     controller;
     /** @internal */ attachController(controller) {
@@ -52,14 +48,31 @@ export class Agent {
     limits;
     instructions;
     jobs = new Set();
+    outcomes = new WeakMap();
     active = new Map();
+    pendingModels = new Map();
     closed = false;
+    releaseId;
     resumeAdmissions = new Map();
     constructor(options) {
         this.id = requireId(options.id, "agent id");
-        this.model = options.model
-            ? immutable("ref" in options.model ? options.model.ref : options.model)
-            : undefined;
+        if (!options.model)
+            fail("MissingModel", "Agent requires a default model");
+        const { concurrency, ...tools } = options.tools ?? {};
+        if (concurrency !== undefined &&
+            (!Number.isInteger(concurrency) || concurrency < 1))
+            fail("InvalidConfiguration", "Tool concurrency must be a positive integer");
+        const values = Object.values(tools);
+        if (values.some((tool) => !(tool instanceof Tool)))
+            fail("InvalidConfiguration", "Agent tools must be Tool instances");
+        this.tools = Object.freeze(values);
+        if (new Set(this.tools.map((tool) => tool.name)).size !== this.tools.length)
+            fail("RegistrationConflict", "Tool name already registered");
+        this.toolConcurrency = concurrency ?? Infinity;
+        this.model = ("ref" in options.model ? options.model : immutable(options.model));
+        const ref = modelRef(this.model);
+        requireId(ref.providerId, "provider id");
+        requireId(ref.modelId, "model id");
         this.ids = randomIds;
         this.clock = systemClock;
         this.instructions = normalizeInstruction(options.instructions);
@@ -70,1135 +83,107 @@ export class Agent {
             ...options.limits,
         });
         validateLimits(this.limits);
+        this.releaseId = reserveId("Agent", this.id, this);
     }
-    stream(options) {
-        const controller = this.runtime();
-        controller.requireReady();
-        const model = controller.resolveModel(options.model ?? this.model).ref;
-        const threadId = this.ids.next("thread"), input = inputMessages(options.input);
-        return this.admit({
-            kind: "input",
-            threadId,
-            input,
-            model,
-            context: options.context,
-            limits: options.limits,
-            signal: options.signal,
-        }, { kind: "iterator" }, () => controller
-            .prepareThread({ scope: options.scope }, threadId)
-            .then(() => { }));
+    stream(input, options = {}) {
+        return callAgent(this, input, options, this.controller);
     }
-    async generate(options) {
-        const stream = this.stream(options);
+    async generate(input, options = {}) {
+        const stream = this.stream(input, options);
         for await (const event of stream)
-            if (event.is(AgentEvents.StreamError))
+            if (event.is(streamHooks.error))
                 throw errorFromInfo(event.payload.error);
-        if (!stream.id)
-            fail("AdmissionFailed", "Execution was not admitted");
-        const record = await this.runtime().queries.getStream(stream.threadId, stream.id);
-        if (!record)
-            fail("StorageUnavailable", "Committed execution missing");
-        const cp = await this.runtime().queries.snapshot(stream.threadId), pending = cp.execution?.pendingInterruptId;
-        return {
-            threadId: stream.threadId,
-            streamId: record.id,
-            status: record.status,
-            output: cp.state.messages.filter((m) => record.outputMessageIds.includes(m.id)),
-            usage: record.directUsage,
-            interrupt: pending
-                ? await this.runtime().queries.getInterrupt(stream.threadId, pending)
-                : null,
-            error: record.error,
-        };
+        return this.outcomes.get(stream);
     }
     /** @internal Shared admission for Thread, Session and testing. */
-    admit(request, target = { kind: "iterator" }, prepare) {
-        this.runtime().requireReady();
+    admit(request, target = { kind: "iterator" }, prepare, runtime, cleanup) {
+        const environment = runtime ?? this.runtime();
+        if (environment === this.controller)
+            this.controller.requireReady();
         if (this.closed)
             fail("Disposed", "Agent closed");
         if (request.kind === "input")
             validateLimits({ ...this.limits, ...request.limits });
-        const sink = createDelivery(request.threadId, this.ids, target, request.signal, this.runtime().report), registry = this.registry.capture();
-        const job = Promise.resolve()
-            .then(async () => {
+        if (!request.adapter &&
+            isModelAdapter(this.model) &&
+            request.model?.providerId === this.model.ref.providerId &&
+            request.model.connectionId === this.model.ref.connectionId) {
+            request = {
+                ...request,
+                adapter: request.model.modelId === this.model.ref.modelId
+                    ? this.model
+                    : this.model.withModel?.(request.model.modelId),
+            };
+        }
+        const sink = createDelivery(request.threadId, this.ids, target, request.signal, environment.report);
+        const registry = environment.hooks.capture();
+        const outcome = (async () => {
+            let entered = false;
             try {
                 await prepare?.();
                 if (this.closed)
                     fail("Disposed", "Agent closed");
+                entered = true;
+                const failure = await execute(this.executionContext(environment), request, sink, registry);
+                if (failure !== undefined && errorInfo(failure).source === "provider")
+                    throw failure;
+                return await readOutcome(environment, sink.stream);
             }
             catch (error) {
-                await registry.release();
+                if (!entered)
+                    await registry.release();
+                environment.report(errorInfo(error));
+                sink.emit(streamHooks.error, {
+                    error: errorInfo(error),
+                    lastKnownCheckpointId: null,
+                    persistedStatus: null,
+                }, {});
+                sink.rejected(errorInfo(error));
+                sink.close();
                 throw error;
             }
-            await this.execute(request, sink, registry);
-        })
-            .catch((error) => {
-            this.runtime().report(errorInfo(error));
-            sink.emit(AgentEvents.StreamError, {
-                error: errorInfo(error),
-                lastKnownCheckpointId: null,
-                persistedStatus: null,
-            }, {});
-            sink.rejected(errorInfo(error));
-            sink.close();
-        });
+            finally {
+                await cleanup?.();
+            }
+        })();
+        this.outcomes.set(sink.stream, outcome);
+        const job = outcome.then(() => { }, () => { });
         this.jobs.add(job);
         void job.then(() => this.jobs.delete(job));
         return sink.stream;
     }
-    async execute(request, sink, registry) {
-        let frame;
-        let pendingLease;
-        try {
-            if (sink.controller.signal.aborted)
-                fail("Cancelled", "Execution cancelled before admission");
-            if (request.kind === "resume") {
-                frame = await this.prepareResume(request, sink, registry);
-                this.active.set(frame.stream.id, frame);
-                this.watchLease(frame);
-                sink.admitted();
-                await this.hook(frame, AgentEvents.StreamResumed, {
-                    checkpointId: frame.cp.id,
-                    interruptId: request.interruptId,
-                    reason: "response",
-                });
-                const cursor = frame.cp.execution.handlerCursor;
-                if (cursor?.eventId === AgentEvents.BeforeStream) {
-                    const result = await this.hook(frame, AgentEvents.BeforeStream, cursor.payload);
-                    if (result?.decision === "deny" || result?.decision === "stop") {
-                        await this.finish(frame, "stopped", result.reason ?? "PolicyStopped");
-                        return;
-                    }
-                }
-                if (cursor?.eventId === AgentEvents.ModelRecover) {
-                    const result = await this.hook(frame, AgentEvents.ModelRecover, cursor.payload);
-                    if (result?.decision !== "retry")
-                        fail("ProviderError", "Recovery policy declined retry");
-                    frame.cp.execution.phase = "BeforeModel";
-                    await this.commit(frame, "ExecutionTransition");
-                }
-                await this.loop(frame);
-                return;
-            }
-            if (request.kind === "recover") {
-                frame = await this.prepareRecovery(request, sink, registry);
-                this.active.set(frame.stream.id, frame);
-                this.watchLease(frame);
-                sink.admitted();
-                if (frame.cp.execution?.pendingInterruptId) {
-                    const interrupt = await this.backend.executions.get("interrupts", frame.cp.execution.pendingInterruptId, { threadId: request.threadId });
-                    await this.hook(frame, AgentEvents.StreamSuspended, {
-                        checkpointId: frame.cp.id,
-                        interrupt: interrupt,
-                    });
-                    return;
-                }
-                await this.hook(frame, AgentEvents.StreamResumed, {
-                    checkpointId: frame.cp.id,
-                    interruptId: null,
-                    reason: "recovery",
-                });
-                await this.loop(frame);
-                return;
-            }
-            const head = await this.backend.threads.get(request.threadId);
-            if (!head)
-                fail("ThreadNotFound", "Thread not found");
-            if (head.activeStreamId)
-                fail("ThreadBusy", "Thread already has unfinished execution");
-            const lease = await this.backend.ownership.acquire({
-                threadId: request.threadId,
-                ownerToken: this.ids.next("owner"),
-                ttlMs: 30000,
-            });
-            pendingLease = lease;
-            const cp = structuredClone((await this.backend.checkpoints.get(head.currentCheckpointId)));
-            const streamId = request.origin
-                ? await resolveChildAdmission(this.backend, request.origin, request.threadId)
-                : this.ids.next("stream"), usage = aggregateUsage([]);
-            const stream = {
-                id: streamId,
-                threadId: request.threadId,
-                scope: head.scope,
-                parentStreamId: request.origin?.parentStreamId ?? null,
-                parentToolExecutionId: request.origin?.parentToolExecutionId ?? null,
-                triggerMessageId: null,
-                status: "running",
-                stopReason: null,
-                startedAt: this.clock.now(),
-                endedAt: null,
-                durationMs: null,
-                error: null,
-                directUsage: usage,
-                inclusiveUsage: usage,
-                outputMessageIds: [],
-            };
-            const records = new Map();
-            for (const kind of [
-                "streams",
-                "turns",
-                "model_attempts",
-                "tool_executions",
-                "interrupts",
-                "plugin_states",
-            ])
-                for (const row of await this.backend.executions.listRecords(kind, request.threadId))
-                    records.set(kind + ":" + ("id" in row ? row.id : ""), {
-                        kind,
-                        id: "id" in row ? row.id : "",
-                        threadId: request.threadId,
-                        data: structuredClone(row),
-                    });
-            const state = new PluginStateAccess([
-                childStateDefinition,
-                ...registry.list("state"),
-            ], { type: "thread", id: request.threadId }, cp.state.pluginStates, async () => {
-                await this.commit(frame, "PluginStateCommitted");
-                return frame.cp.id;
-            }, undefined, this.backend.ownedState);
-            frame = {
-                request,
-                sink,
-                registry,
-                lease,
-                cp,
-                stream,
-                records,
-                state,
-                admitted: false,
-                sequence: 0,
-            };
-            this.put(frame, "streams", stream);
-            sink.setId(streamId);
-            this.active.set(streamId, frame);
-            this.watchLease(frame);
-            cp.execution = {
-                streamId,
-                turnId: null,
-                phase: "BeforeTurn",
-                modelRef: request.model,
-                baseInstructions: this.instructions,
-                pendingToolExecutionIds: [],
-                pendingInterruptId: null,
-                handlerCursor: null,
-                budgets: {
-                    turns: 0,
-                    modelAttempts: 0,
-                    toolCalls: 0,
-                    limits: { ...this.limits, ...request.limits },
-                },
-                registryManifest: [
-                    ...registry.values.map((r) => ({
-                        pluginId: r.pluginId,
-                        kind: r.kind,
-                        id: r.id,
-                        version: r.version,
-                        pluginVersion: r.pluginVersion,
-                        configurationId: r.configurationId,
-                        requiredForContinuation: true,
-                    })),
-                    ...registry.handlers.map((r) => ({
-                        pluginId: r.pluginId,
-                        kind: "handler",
-                        id: r.id,
-                        version: r.version,
-                        pluginVersion: r.pluginVersion,
-                        configurationId: r.configurationId,
-                        requiredForContinuation: r.kind !== "notification",
-                    })),
-                ],
-                recordRevision: cp.revision,
-            };
-            const input = await this.hook(frame, AgentEvents.InputPrepare, {
-                messages: request.input,
-            });
-            if (input.rejected)
-                throw errorFromInfo(input.rejected);
-            for (const message of input.messages)
-                cp.state = {
-                    ...cp.state,
-                    messages: [
-                        ...cp.state.messages,
-                        await this.prepareMessage(frame, message),
-                    ],
-                };
-            stream.triggerMessageId = input.messages[0]?.id ?? null;
-            await this.commit(frame, "InputCommitted");
-            frame.admitted = true;
-            sink.admitted();
-            await this.hook(frame, AgentEvents.StreamStarted, {
-                modelRef: request.model,
-                checkpointId: frame.cp.id,
-            });
-            await this.hook(frame, AgentEvents.InputReceived, {
-                messages: input.messages,
-            });
-            if (input.handled) {
-                for (const message of input.handled.output)
-                    await this.appendMessage(frame, message);
-                await this.finish(frame, "completed", null);
-                return;
-            }
-            const before = await this.hook(frame, AgentEvents.BeforeStream, {
-                input: input.messages,
-            });
-            if (before?.decision === "deny" || before?.decision === "stop") {
-                await this.finish(frame, "stopped", before.reason ?? "PolicyStopped");
-                return;
-            }
-            await this.loop(frame);
-        }
-        catch (error) {
-            if (error instanceof Suspension)
-                return;
-            if (frame?.ownershipError)
-                error = new TessarError("OwnershipLost", "Execution ownership was lost");
-            const info = errorInfo(error);
-            if (frame?.admitted &&
-                info.source !== "storage" &&
-                ![
-                    "StorageUnavailable",
-                    "CommitConflict",
-                    "OwnershipLost",
-                    "RecoveryRequired",
-                ].includes(info.code)) {
-                try {
-                    await this.finish(frame, sink.controller.signal.aborted ? "cancelled" : "failed", info.code, info);
-                    return;
-                }
-                catch (finalizeError) {
-                    error = finalizeError;
-                }
-            }
-            const finalError = errorInfo(error);
-            this.runtime().report(finalError, this.eventContext(frame));
-            sink.emit(AgentEvents.StreamError, {
-                error: finalError,
-                lastKnownCheckpointId: frame?.cp.id ?? null,
-                persistedStatus: frame?.stream.status ?? null,
-            }, this.eventContext(frame));
-            sink.rejected(finalError);
-        }
-        finally {
-            if (frame) {
-                if (frame.heartbeat)
-                    clearInterval(frame.heartbeat);
-                this.active.delete(frame.stream.id);
-                try {
-                    await this.backend.ownership.release(frame.lease);
-                }
-                catch {
-                    /* recovery uses lease expiry */
-                }
-            }
-            else if (pendingLease) {
-                try {
-                    await this.backend.ownership.release(pendingLease);
-                }
-                catch {
-                    /* lease expiry remains authoritative */
-                }
-            }
-            await registry.release();
-            sink.close();
-        }
-    }
-    eventContext(frame) {
-        return {
-            agentId: this.id,
-            controllerId: this.runtime().id,
-            ...(frame
-                ? {
-                    scope: frame.cp.state.scope,
-                    streamId: frame.stream.id,
-                    threadId: frame.cp.threadId,
-                    sequence: ++frame.sequence,
-                    timestamp: this.clock.now(),
-                }
-                : {}),
-        };
-    }
-    watchLease(frame) {
-        if (frame.heartbeat)
-            return;
-        frame.heartbeat = setInterval(() => {
-            void this.backend.ownership.renew(frame.lease, 30000).then((lease) => {
-                frame.lease = lease;
-            }, (error) => {
-                frame.ownershipError = errorInfo(error, {
-                    source: "storage",
-                    backendId: this.backend.id,
-                });
-                frame.sink.controller.abort("OwnershipLost");
-            });
-        }, 10000);
-    }
-    async hook(frame, definition, payload) {
-        const cursor = frame.cp.execution?.handlerCursor?.eventId === definition
-            ? frame.cp.execution.handlerCursor
-            : null;
-        const decisions = cursor?.decisions.slice() ?? [];
-        const kind = this.registry.kind(definition);
-        const mutable = kind === "transformation" || kind === "decision";
-        const context = {
-            ...this.eventContext(frame),
-            ...(mutable
-                ? {
-                    ...this.services(frame, frame.currentToolExecutionId),
-                    state: frame.state,
-                }
-                : {}),
-            signal: frame.sink.controller.signal,
-            context: frame.request.kind === "input" ? frame.request.context : undefined,
-            turnId: frame.cp.execution?.turnId,
-            streamId: frame.stream.id,
-            threadId: frame.cp.threadId,
-            startIndex: cursor?.nextIndex ?? 0,
-            initialDecision: decisions.at(-1) ?? undefined,
-            allowedHandlerIds: frame.cp.execution?.registryManifest
-                .filter((r) => r.kind === "handler")
-                .map((r) => r.id),
-            suspend: kind === "decision"
-                ? (def, data) => {
-                    phaseForEvent(definition);
-                    const binding = frame.registry.find("interruption", def.id);
-                    if (!binding || binding.definition.version !== def.version)
-                        fail("ResumeIncompatible", "Interruption definition is not registered");
-                    return {
-                        decision: "suspend",
-                        definitionId: def.id,
-                        definitionVersion: def.version,
-                        pluginId: binding.pluginId,
-                        payload: immutable(def.payload ? def.payload.parse(data) : data),
-                    };
-                }
-                : undefined,
-            onDecision: this.registry.kind(definition) === "decision"
-                ? async (entry) => {
-                    const value = entry.decision;
-                    decisions.push(value ? immutable(value) : null);
-                    frame.cp.execution.handlerCursor = {
-                        eventId: definition,
-                        handlerId: entry.handlerId,
-                        nextIndex: entry.index + 1,
-                        payload: immutable(cursor?.payload ?? payload),
-                        decisions,
-                    };
-                    if (value?.decision !== "suspend")
-                        await this.commit(frame, "ExecutionTransition");
-                }
-                : undefined,
-        };
-        const value = await this.registry.dispatch(definition, payload, context, frame.registry);
-        if (this.registry.kind(definition) === "decision") {
-            if (value?.decision === "suspend")
-                await this.suspend(frame, value);
-            if (frame.cp.execution?.handlerCursor?.eventId === definition)
-                frame.cp.execution.handlerCursor = null;
-        }
-        if (this.registry.kind(definition) === "notification")
-            frame.sink.emit(definition, payload, context);
-        return value;
-    }
-    put(frame, kind, data) {
-        frame.records.set(kind + ":" + data.id, {
-            kind,
-            id: data.id,
-            threadId: frame.cp.threadId,
-            data,
-        });
-    }
-    rows(frame, kind) {
-        return [...frame.records.values()]
-            .filter((r) => r.kind === kind)
-            .map((r) => r.data);
-    }
-    services(frame, toolExecutionId) {
-        const state = frame.state.withOwner({
-            type: "stream",
-            id: frame.stream.id,
-        });
-        frame.effectLocks ??= new Map();
-        const effects = new EffectService((id) => frame.registry.find("effect", id), state, () => this.commit(frame, "PluginStateCommitted"), {
-            signal: frame.sink.controller.signal,
-            threadId: frame.cp.threadId,
-            streamId: frame.stream.id,
-            turnId: frame.cp.execution?.turnId ?? null,
-            ...(toolExecutionId ? { toolExecutionId } : {}),
-        }, () => this.ids.next("effect"), frame.effectLocks);
-        const guard = () => {
-            if (!frame.admitted || !frame.cp.execution)
-                fail("UnsupportedBoundary", "Tracked execution requires admitted active work");
-        };
-        return {
-            models: {
-                stream: (options) => {
-                    guard();
-                    return this.auxiliary(frame, toolExecutionId, options);
-                },
-            },
-            effects: {
-                execute: (definition, input, options) => {
-                    guard();
-                    return effects.execute(definition, input, options);
-                },
-            },
-            executions: {
-                reserveChild: async (options) => {
-                    guard();
-                    if (options.threadId === frame.cp.threadId)
-                        fail("InvalidLineage", "Child requires a separate Thread");
-                    if (!(await this.backend.threads.get(options.threadId)))
-                        fail("ThreadNotFound", "Child Thread not found");
-                    const previous = state.get(childStateDefinition), old = previous[options.dispatchKey];
-                    if (old) {
-                        if (old.threadId !== options.threadId)
-                            fail("CommitConflict", "Dispatch key is bound to another Thread");
-                        await this.commit(frame, "PluginStateCommitted");
-                        return old;
-                    }
-                    const reservation = {
-                        threadId: options.threadId,
-                        streamId: this.ids.next("stream"),
-                        origin: {
-                            parentStreamId: frame.stream.id,
-                            ...(toolExecutionId
-                                ? { parentToolExecutionId: toolExecutionId }
-                                : {}),
-                            dispatchId: this.ids.next("dispatch"),
-                        },
-                    };
-                    state.update(childStateDefinition, {
-                        ...previous,
-                        [options.dispatchKey]: reservation,
-                    });
-                    await this.commit(frame, "PluginStateCommitted");
-                    return immutable(reservation);
-                },
-            },
-            events: {
-                emit: async (definition, payload) => {
-                    if (this.registry.kind(definition) !== "notification")
-                        fail("InvalidEvent", "Custom progress must be notification events");
-                    await this.hook(frame, definition, payload);
-                },
-            },
-        };
-    }
-    async *auxiliary(frame, toolExecutionId, options) {
-        const position = frame.cp.execution;
-        if (!position.turnId)
-            fail("UnsupportedBoundary", "Auxiliary calls require an active turn");
-        if (position.budgets.modelAttempts >= position.budgets.limits.maxModelAttempts)
-            fail("StreamLimit", "Model attempt budget exhausted");
-        const provider = frame.registry.find("provider", options.model.providerId);
-        if (!provider)
-            fail("MissingProvider", "Auxiliary provider is missing");
-        const adapter = providerCall(options.model, () => provider.create(options.model.modelId)), request = await this.hook(frame, AgentEvents.ModelRequest, immutable(options.request));
-        providerCall(options.model, () => adapter.validate(request));
-        const attempt = {
-            id: this.ids.next("attempt"),
-            turnId: position.turnId,
-            streamId: frame.stream.id,
-            scope: frame.cp.state.scope,
-            callId: this.ids.next("call"),
-            attemptIndex: 0,
-            purpose: "auxiliary",
-            parentToolExecutionId: toolExecutionId ?? null,
-            providerId: options.model.providerId,
-            modelId: options.model.modelId,
-            providerRequestId: null,
-            responseMessageId: null,
-            contextRevision: frame.cp.revision,
-            requestSnapshotRef: null,
-            startedAt: this.clock.now(),
-            firstOutputAt: null,
-            endedAt: null,
-            durationMs: null,
-            timeToFirstOutputMs: null,
-            status: "running",
-            finishReason: null,
-            error: null,
-            usage: normalizeUsage({}),
-        };
-        position.budgets.modelAttempts++;
-        this.put(frame, "model_attempts", attempt);
-        await this.commit(frame, "ExecutionTransition");
-        try {
-            for await (const chunk of streamModel(adapter, request, {
-                signal: frame.sink.controller.signal,
-            })) {
-                if (chunk.type === "usage")
-                    attempt.usage = chunk.usage;
-                if (chunk.type === "response") {
-                    attempt.usage = chunk.response.usage ?? attempt.usage;
-                    attempt.status = "succeeded";
-                    attempt.finishReason = chunk.response.finishReason ?? null;
-                    attempt.providerRequestId = chunk.response.providerRequestId ?? null;
-                }
-                yield chunk;
-            }
-        }
-        catch (error) {
-            attempt.status = "failed";
-            attempt.error = errorInfo(error);
-            throw error;
-        }
-        finally {
-            if (attempt.status === "running")
-                attempt.status = "interrupted";
-            attempt.endedAt = this.clock.now();
-            await this.commit(frame, "ExecutionTransition");
-        }
-    }
-    async updateUsage(frame) {
-        const attempts = this.rows(frame, "model_attempts");
-        const summary = await summarizeStreamUsage(this.backend, frame.stream.id, {
-            threadId: frame.cp.threadId,
-            attempts,
-            states: frame.state.snapshots(),
-        });
-        frame.stream.directUsage = summary.direct;
-        frame.stream.inclusiveUsage = summary.inclusive;
-        for (const turn of this.rows(frame, "turns"))
-            turn.usage = aggregateUsage(attempts.filter((a) => a.turnId === turn.id));
-    }
-    async commit(frame, cause) {
-        const queued = (frame.commitQueue ?? Promise.resolve()).then(() => this.commitNow(frame, cause));
-        frame.commitQueue = queued.catch(() => { });
-        return queued;
-    }
-    async commitNow(frame, cause) {
-        await this.updateUsage(frame);
-        const cp = {
-            ...frame.cp,
-            id: this.ids.next("checkpoint"),
-            parentCheckpointId: frame.cp.id,
-            revision: frame.cp.revision + 1,
-            createdAt: this.clock.now(),
-            cause,
-            state: { ...frame.cp.state, pluginStates: frame.state.snapshots() },
-            execution: frame.cp.execution
-                ? { ...frame.cp.execution, recordRevision: frame.cp.revision + 1 }
-                : null,
-        };
-        if (cause === "Suspended" && cp.execution?.pendingInterruptId) {
-            const record = frame.records.get("interrupts:" + cp.execution.pendingInterruptId);
-            if (record.kind === "interrupts") {
-                record.data.checkpointId = cp.id;
-                record.data.revision = cp.revision;
-            }
-        }
-        await new CommitCoordinator(this.backend).commit({
-            commitId: this.ids.next("commit"),
-            threadId: cp.threadId,
-            expectedRevision: frame.cp.revision,
-            checkpoint: cp,
-            records: [...frame.records.values()],
-        }, frame.lease);
-        frame.cp = { ...structuredClone(cp), execution: frame.cp.execution };
-        if (frame.cp.execution)
-            frame.cp.execution.recordRevision = cp.revision;
-        await this.hook(frame, AgentEvents.CheckpointCommitted, {
-            checkpointId: cp.id,
-            revision: cp.revision,
-        });
-        await this.hook(frame, AgentEvents.ThreadUpdated, {
-            checkpointId: cp.id,
-            revision: cp.revision,
-        });
-    }
-    async prepareMessage(frame, message) {
-        const value = await this.hook(frame, AgentEvents.MessagePrepare, immutable(message));
-        if (value.id !== message.id ||
-            value.role !== message.role ||
-            value.toolCallId !== message.toolCallId)
-            fail("InvalidMessage", "Message transform changed identity/role/correlation");
-        const validated = MessageCodec.encode(MessageCodec.decode(value));
-        await this.hook(frame, AgentEvents.MessageBeforeCommit, {
-            message: validated,
-        });
-        return validated;
-    }
-    async appendMessage(frame, message) {
-        const value = await this.prepareMessage(frame, message);
-        frame.cp.state = {
-            ...frame.cp.state,
-            messages: [...frame.cp.state.messages, value],
-        };
-        if (value.role === "assistant" || value.role === "tool")
-            frame.stream.outputMessageIds = [
-                ...frame.stream.outputMessageIds,
-                value.id,
-            ];
-        await this.commit(frame, "MessageCommitted");
-        await this.hook(frame, AgentEvents.MessageCommitted, {
-            message: value,
-            checkpointId: frame.cp.id,
-        });
-    }
-    loop(frame) {
-        return loop(frame, {
+    executionContext(runtime = this.runtime()) {
+        const execution = {
+            agent: this,
+            runtime,
+            active: this.active,
+            pendingModels: this.pendingModels,
+            resumeAdmissions: this.resumeAdmissions,
             ids: this.ids,
             clock: this.clock,
-            hook: this.hook.bind(this),
-            put: this.put.bind(this),
-            rows: this.rows.bind(this),
-            commit: this.commit.bind(this),
-            updateUsage: this.updateUsage.bind(this),
-            appendMessage: this.appendMessage.bind(this),
-            services: this.services.bind(this),
-            finish: this.finish.bind(this),
-        });
-    }
-    async restoreFrame(request, sink, registry, checkManifest = true) {
-        const head = await this.backend.threads.get(request.threadId);
-        if (!head)
-            fail("ThreadNotFound", "Thread not found");
-        const stored = await this.backend.executions.get("streams", request.streamId, { threadId: request.threadId });
-        if (!stored)
-            fail("StreamNotFound", "Execution not found");
-        if (["completed", "failed", "stopped", "cancelled"].includes(stored.status))
-            fail("AlreadyTerminal", "Execution already ended");
-        const cp = structuredClone((await this.backend.checkpoints.get(head.currentCheckpointId)));
-        if (cp.execution?.streamId !== request.streamId)
-            fail("InvalidTransition", "Execution is not current thread work");
-        if (checkManifest)
-            validateManifest(cp.execution.registryManifest, registry, request.model);
-        const lease = await this.backend.ownership.acquire({
-            threadId: request.threadId,
-            ownerToken: this.ids.next("owner"),
-            ttlMs: 30000,
-        });
-        try {
-            const records = new Map();
-            for (const kind of [
-                "streams",
-                "turns",
-                "model_attempts",
-                "tool_executions",
-                "interrupts",
-                "plugin_states",
-            ])
-                for (const row of await this.backend.executions.listRecords(kind, request.threadId))
-                    records.set(kind + ":" + ("id" in row ? row.id : ""), {
-                        kind,
-                        id: "id" in row ? row.id : "",
-                        threadId: request.threadId,
-                        data: structuredClone(row),
-                    });
-            const stream = records.get("streams:" + request.streamId).data;
-            let frame;
-            const state = new PluginStateAccess([
-                childStateDefinition,
-                ...registry.list("state"),
-            ], { type: "thread", id: request.threadId }, cp.state.pluginStates, async () => {
-                await this.commit(frame, "PluginStateCommitted");
-                return frame.cp.id;
-            }, undefined, this.backend.ownedState);
-            frame = {
-                request,
-                sink,
-                registry,
-                lease,
-                cp,
-                stream,
-                records,
-                state,
-                admitted: true,
-                sequence: 0,
-            };
-            sink.setId(stream.id);
-            if (request.model)
-                cp.execution.modelRef = request.model;
-            return frame;
-        }
-        catch (error) {
-            await this.backend.ownership.release(lease);
-            throw error;
-        }
-    }
-    async prepareRecovery(request, sink, registry) {
-        const frame = await this.restoreFrame(request, sink, registry);
-        try {
-            const plan = new RecoveryService().plan(frame.cp, this.rows(frame, "model_attempts"), this.rows(frame, "tool_executions"));
-            if (plan.kind === "pending-interrupt")
-                return frame;
-            frame.stream.status = "interrupted";
-            if (plan.kind === "incompatible")
-                fail("ResumeIncompatible", "Invalid recovery cursor");
-            if (plan.kind === "model") {
-                plan.attempt.status = "interrupted";
-                plan.attempt.endedAt = this.clock.now();
-                plan.attempt.error = {
-                    source: "tessar",
-                    name: "TessarError",
-                    code: "InterruptedModelCall",
-                    message: "Provider outcome was not committed",
-                    retryable: true,
-                };
-                await this.commit(frame, "ExecutionTransition");
-                const decision = await this.hook(frame, AgentEvents.ModelRecover, {
-                    attemptId: plan.attempt.id,
-                    error: plan.attempt.error,
-                });
-                if (decision?.decision !== "retry")
-                    fail("RecoveryRequired", "Model retry requires an explicit recovery policy");
-                frame.cp.execution.phase = "BeforeModel";
-            }
-            if (plan.kind === "tool") {
-                const record = plan.tool;
-                record.status = "interrupted";
-                await this.commit(frame, "ExecutionTransition");
-                const tool = registry.find("tool", record.toolName);
-                const result = tool?.recovery && record.idempotencyKey
-                    ? await tool.recovery.reconcile({
-                        id: record.id,
-                        input: tool.input.parse(record.arguments),
-                        key: record.idempotencyKey,
-                    })
-                    : { status: "unknown" };
-                if (result.status === "unknown")
-                    fail("RecoveryRequired", "Tool dispatch outcome is unknown");
-                if (result.status === "safeToRetry") {
-                    record.status = "pending";
-                    frame.cp.execution.phase = "BeforeTool";
-                }
-                if (result.status === "completed") {
-                    const transformed = await this.hook(frame, AgentEvents.ToolResult, result.result), message = MessageCodec.encode(new ToolMessage({
-                        toolCallId: record.toolCallId,
-                        content: transformed.content,
-                        metadata: transformed.metadata,
-                    }));
-                    record.status = "succeeded";
-                    record.result = transformed;
-                    record.resultMessageId = message.id;
-                    record.endedAt = this.clock.now();
-                    frame.cp.execution.pendingToolExecutionIds =
-                        frame.cp.execution.pendingToolExecutionIds.filter((id) => id !== record.id);
-                    frame.cp.execution.phase = frame.cp.execution
-                        .pendingToolExecutionIds.length
-                        ? "BeforeTool"
-                        : "TurnBoundary";
-                    await this.appendMessage(frame, message);
-                }
-            }
-            frame.stream.status = "running";
-            await this.commit(frame, "Resumed");
-            return frame;
-        }
-        catch (error) {
-            await this.backend.ownership.release(frame.lease);
-            throw error;
-        }
-    }
-    async suspend(frame, decision) {
-        if (decision.decision !== "suspend")
-            fail("InvalidTransition", "Expected suspension decision");
-        const binding = frame.registry.find("interruption", decision.definitionId);
-        const position = frame.cp.execution, id = this.ids.next("interrupt");
-        const tool = position.pendingToolExecutionIds[0]
-            ? this.rows(frame, "tool_executions").find((t) => t.id === position.pendingToolExecutionIds[0])
-            : null;
-        const interrupt = {
-            id,
-            threadId: frame.cp.threadId,
-            streamId: frame.stream.id,
-            checkpointId: frame.cp.id,
-            definitionId: decision.definitionId,
-            definitionVersion: decision.definitionVersion,
-            pluginId: decision.pluginId,
-            payload: decision.payload,
-            responseSchema: binding.definition.response.jsonSchema,
-            actionRef: tool
-                ? {
-                    toolExecutionId: tool.id,
-                    toolName: tool.toolName,
-                    argumentsDigest: canonicalJson(tool.arguments),
-                }
-                : null,
-            status: "pending",
-            response: null,
-            resolvedDecision: null,
-            createdAt: this.clock.now(),
-            resolvedAt: null,
-            revision: frame.cp.revision,
+            toolConcurrency: this.toolConcurrency,
+            hook: (frame, definition, payload, toolExecutionId) => hook(execution, frame, definition, payload, toolExecutionId),
+            put,
+            rows,
+            commit: (frame, cause) => commit(execution, frame, cause),
+            updateUsage: (frame) => updateUsage(execution, frame),
+            prepareMessage: (frame, message) => prepareMessage(execution, frame, message),
+            appendMessage: (frame, message) => appendMessage(execution, frame, message),
+            services: (frame, toolExecutionId) => services(execution, frame, toolExecutionId),
+            finish: (frame, status, reason, error) => finish(execution, frame, status, reason, error),
         };
-        this.put(frame, "interrupts", interrupt);
-        position.pendingInterruptId = id;
-        position.phase = "Suspended";
-        frame.stream.status = "suspended";
-        await this.commit(frame, "Suspended");
-        await this.hook(frame, AgentEvents.StreamSuspended, {
-            checkpointId: frame.cp.id,
-            interrupt,
-        });
-        throw new Suspension();
-    }
-    async prepareResume(request, sink, registry) {
-        const existing = this.resumeAdmissions.get(request.interruptId);
-        if (existing) {
-            await existing;
-            fail("AlreadyResumed", "Another response was already committed");
-        }
-        const pending = this.prepareResumeFrame(request, sink, registry);
-        this.resumeAdmissions.set(request.interruptId, pending);
-        try {
-            return await pending;
-        }
-        finally {
-            this.resumeAdmissions.delete(request.interruptId);
-        }
+        return execution;
     }
-    async prepareResumeFrame(request, sink, registry) {
-        await validateResume(this.backend, registry, request.threadId, request.interruptId, request.value);
-        const head = await this.backend.threads.get(request.threadId);
-        if (!head)
-            fail("ThreadNotFound", "Thread not found");
-        const stored = (await this.backend.checkpoints.get(head.currentCheckpointId));
-        if (!stored.execution ||
-            stored.execution.pendingInterruptId !== request.interruptId)
-            fail("InvalidTransition", "Thread is not waiting for this interruption");
-        validateManifest(stored.execution.registryManifest, registry, request.model);
-        const lease = await this.backend.ownership.acquire({
-            threadId: request.threadId,
-            ownerToken: this.ids.next("owner"),
-            ttlMs: 30000,
-        });
-        try {
-            const { interrupt, decision } = await validateResume(this.backend, registry, request.threadId, request.interruptId, request.value);
-            const cp = structuredClone(stored), records = new Map();
-            for (const kind of [
-                "streams",
-                "turns",
-                "model_attempts",
-                "tool_executions",
-                "interrupts",
-                "plugin_states",
-            ])
-                for (const row of await this.backend.executions.listRecords(kind, request.threadId))
-                    records.set(kind + ":" + ("id" in row ? row.id : ""), {
-                        kind,
-                        id: "id" in row ? row.id : "",
-                        threadId: request.threadId,
-                        data: structuredClone(row),
-                    });
-            const stream = records.get("streams:" + interrupt.streamId).data;
-            if (interrupt.actionRef?.toolExecutionId) {
-                const tool = this.rows({ records }, "tool_executions").find((t) => t.id === interrupt.actionRef.toolExecutionId);
-                if (!tool ||
-                    canonicalJson(tool.arguments) !== interrupt.actionRef.argumentsDigest)
-                    fail("ResumeIncompatible", "Pending operation payload changed");
-            }
-            let frame;
-            const state = new PluginStateAccess([
-                childStateDefinition,
-                ...registry.list("state"),
-            ], { type: "thread", id: request.threadId }, cp.state.pluginStates, async () => {
-                await this.commit(frame, "PluginStateCommitted");
-                return frame.cp.id;
-            }, undefined, this.backend.ownedState);
-            frame = {
-                request,
-                sink,
-                registry,
-                lease,
-                cp,
-                stream,
-                records,
-                state,
-                admitted: true,
-                sequence: 0,
-            };
-            const position = cp.execution, cursor = position.handlerCursor;
-            if (!cursor)
-                fail("ResumeIncompatible", "Missing continuation cursor");
-            const previous = cursor.decisions.at(-2);
-            const resolved = previous && ["deny", "stop"].includes(previous.decision)
-                ? previous
-                : decision;
-            cursor.decisions = [
-                ...cursor.decisions.slice(0, -1),
-                resolved,
-            ];
-            position.phase = phaseForEvent(cursor.eventId);
-            position.pendingInterruptId = null;
-            if (request.model) {
-                position.modelRef = request.model;
-                position.registryManifest = position.registryManifest.filter((r) => r.kind !== "provider");
-                const provider = registry.values.find((r) => r.kind === "provider" && r.id === request.model.providerId);
-                if (!provider)
-                    fail("MissingProvider", "Override model provider missing");
-                position.registryManifest = [
-                    ...position.registryManifest,
-                    {
-                        pluginId: provider.pluginId,
-                        kind: provider.kind,
-                        id: provider.id,
-                        version: provider.version,
-                        requiredForContinuation: true,
-                    },
-                ];
-            }
-            stream.status = "running";
-            this.put(frame, "interrupts", {
-                ...interrupt,
-                status: "resolved",
-                response: request.value,
-                resolvedDecision: resolved,
-                resolvedAt: this.clock.now(),
-                revision: cp.revision + 1,
-            });
-            sink.setId(stream.id);
-            await this.commit(frame, "Resumed");
-            return frame;
-        }
-        catch (error) {
-            await this.backend.ownership.release(lease);
-            throw error;
-        }
-    }
-    async finish(frame, status, reason, error = null) {
-        const pending = new Set();
-        for (const message of frame.cp.state.messages) {
-            for (const part of message.content)
-                if (part.type === "tool-call")
-                    pending.add(part.toolCallId);
-            if (message.role === "tool")
-                pending.delete(message.toolCallId);
-        }
-        for (const toolCallId of pending) {
-            const message = MessageCodec.encode(new ToolMessage({ toolCallId, content: "Execution " + status }));
-            frame.cp.state = {
-                ...frame.cp.state,
-                messages: [...frame.cp.state.messages, message],
-            };
-            frame.stream.outputMessageIds = [
-                ...frame.stream.outputMessageIds,
-                message.id,
-            ];
-            const tool = this.rows(frame, "tool_executions").find((t) => t.toolCallId === toolCallId && t.streamId === frame.stream.id);
-            if (tool && tool.status === "pending") {
-                tool.status = "cancelled";
-                tool.resultMessageId = message.id;
-                tool.endedAt = this.clock.now();
-            }
-        }
-        frame.stream.status = status;
-        frame.stream.stopReason = reason;
-        frame.stream.error = error;
-        frame.stream.endedAt = this.clock.now();
-        await this.updateUsage(frame);
-        let outcome = {
-            status,
-            reason,
-            output: frame.cp.state.messages.filter((m) => frame.stream.outputMessageIds.includes(m.id)),
-            usage: frame.stream.directUsage,
-            error,
-            interrupt: null,
-        };
-        try {
-            await this.hook(frame, AgentEvents.StreamBeforeEnd, immutable(outcome));
-        }
-        catch (finalizationError) {
-            if (!error && status !== "cancelled") {
-                status = "failed";
-                error = errorInfo(finalizationError);
-                reason = "FinalizationFailed";
-                frame.stream.status = status;
-                frame.stream.error = error;
-                frame.stream.stopReason = reason;
-                outcome = { ...outcome, status, error, reason };
-            }
-        }
-        const activeTurns = this.rows(frame, "turns").filter((turn) => turn.status === "running");
-        for (const turn of activeTurns) {
-            turn.status = status;
-            turn.stopReason = reason;
-            turn.error = error;
-            turn.endedAt = this.clock.now();
-            turn.durationMs = Date.parse(turn.endedAt) - Date.parse(turn.startedAt);
-        }
-        frame.cp.execution = null;
-        await this.commit(frame, "Terminal");
-        for (const turn of activeTurns)
-            await this.hook(frame, AgentEvents.TurnEnd, {
-                turnId: turn.id,
-                usage: turn.usage,
-            });
-        await this.hook(frame, AgentEvents.StreamEnd, immutable(outcome));
-    }
-    async cancel(threadId, streamId, reason = "Cancelled", target = { kind: "observer", observe: () => { } }) {
-        const active = this.active.get(streamId);
-        if (active) {
-            if (active.cp.threadId !== threadId)
-                fail("InvalidTransition", "Execution belongs to a different thread");
-            await this.hook(active, AgentEvents.StreamCancel, { reason });
-            active.sink.controller.abort(reason);
-            return;
-        }
-        const registry = this.registry.capture(), sink = createDelivery(threadId, this.ids, target, undefined, this.runtime().report);
-        let frame;
-        try {
-            frame = await this.restoreFrame({ kind: "recover", threadId, streamId }, sink, registry, false);
-            this.watchLease(frame);
-            if (frame.cp.execution?.phase === "ToolPending") {
-                const toolRecord = this.rows(frame, "tool_executions").find((t) => t.id === frame.cp.execution.pendingToolExecutionIds[0]);
-                const tool = registry.find("tool", toolRecord.toolName);
-                const outcome = tool?.recovery && toolRecord.idempotencyKey
-                    ? await tool.recovery.reconcile({
-                        id: toolRecord.id,
-                        input: tool.input.parse(toolRecord.arguments),
-                        key: toolRecord.idempotencyKey,
-                    })
-                    : { status: "unknown" };
-                if (outcome.status === "unknown") {
-                    frame.stream.status = "interrupted";
-                    toolRecord.status = "interrupted";
-                    await this.commit(frame, "ExecutionTransition");
-                    fail("RecoveryRequired", "Cannot close unknown external tool outcome");
-                }
-                if (outcome.status === "completed") {
-                    toolRecord.status = "succeeded";
-                    toolRecord.result = outcome.result;
-                    const message = MessageCodec.encode(new ToolMessage({
-                        toolCallId: toolRecord.toolCallId,
-                        content: outcome.result.content,
-                    }));
-                    toolRecord.resultMessageId = message.id;
-                    await this.appendMessage(frame, message);
-                }
-                else
-                    toolRecord.status = "pending";
-            }
-            for (const interrupt of this.rows(frame, "interrupts"))
-                if (interrupt.streamId === streamId && interrupt.status === "pending") {
-                    interrupt.status = "cancelled";
-                    interrupt.resolvedAt = this.clock.now();
-                }
-            for (const attempt of this.rows(frame, "model_attempts"))
-                if (attempt.streamId === streamId && attempt.status === "running") {
-                    attempt.status = "cancelled";
-                    attempt.endedAt = this.clock.now();
-                }
-            await this.hook(frame, AgentEvents.StreamCancel, { reason });
-            await this.finish(frame, "cancelled", reason);
-        }
-        finally {
-            if (frame) {
-                if (frame.heartbeat)
-                    clearInterval(frame.heartbeat);
-                await this.backend.ownership.release(frame.lease);
-            }
-            await registry.release();
-            sink.close();
-        }
+    async cancel(threadId, streamId, reason = "Cancelled", target = { kind: "observer", observe: () => { } }, context = {}) {
+        return cancel(this.executionContext(), threadId, streamId, reason, target, context);
     }
     async shutdown() {
         this.closed = true;
         for (const frame of this.active.values())
             frame.sink.controller.abort("Controller disposed");
         await Promise.allSettled([...this.jobs]);
+        this.pendingModels.clear();
+        this.releaseId();
     }
 }
 //# sourceMappingURL=agent.js.map