@modelprofile.com/flexharness-agent 6.0.0 → 6.1.0

package/dist_ts_agent/classes.sessionengine.js

@@ -0,0 +1,2140 @@
+import * as plugins from './plugins.js';
+import { buildModelMessages } from './smartagent.context.js';
+import { createAgentEvent, createAgentEventId, modelMessagesToAgentEvents, } from './smartagent.events.js';
+import { AgentGenerationLeaseCleanupError, ContextOverflowError, } from './smartagent.interfaces.js';
+import { isAgentEventStoreV2, validateAgentEventSnapshotV2, } from './smartagent.persistence.js';
+import { filterModelVisibleAgentEvents, getAgentGenerationTransactions, getOpenAgentGenerationTransactions, getUncertainToolExecutionIntents, } from './smartagent.transactions.js';
+const RETRY_INITIAL_DELAY = 2000;
+const RETRY_BACKOFF_FACTOR = 2;
+const RETRY_MAX_DELAY = 30_000;
+const MAX_RETRY_ATTEMPTS = 8;
+const isTransactionalControlEvent = (event) => event.type === 'generation-begun'
+    || event.type === 'generation-execution-started'
+    || event.type === 'generation-execution-completed'
+    || event.type === 'generation-outcome'
+    || event.type === 'tool-execution-intent'
+    || event.type === 'tool-execution-reconciliation';
+const sessionHydrations = new WeakMap();
+const retryDelay = (attempt, headers) => {
+    if (headers) {
+        const milliseconds = headers['retry-after-ms'];
+        if (milliseconds) {
+            const parsed = Number.parseFloat(milliseconds);
+            if (!Number.isNaN(parsed))
+                return parsed;
+        }
+        const retryAfter = headers['retry-after'];
+        if (retryAfter) {
+            const seconds = Number.parseFloat(retryAfter);
+            if (!Number.isNaN(seconds))
+                return Math.ceil(seconds * 1000);
+            const dateDelay = Date.parse(retryAfter) - Date.now();
+            if (!Number.isNaN(dateDelay) && dateDelay > 0)
+                return Math.ceil(dateDelay);
+        }
+    }
+    return Math.min(RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1), RETRY_MAX_DELAY);
+};
+const sleep = async (milliseconds, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+        reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+        return;
+    }
+    let settled = false;
+    const cleanup = () => signal?.removeEventListener('abort', onAbort);
+    const onAbort = () => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        cleanup();
+        reject(signal?.reason ?? new DOMException('Aborted', 'AbortError'));
+    };
+    const timer = setTimeout(() => {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        resolve();
+    }, milliseconds);
+    signal?.addEventListener('abort', onAbort, { once: true });
+});
+const combineAbortSignals = (signals) => {
+    const controller = new AbortController();
+    const activeSignals = signals.filter((signal) => !!signal);
+    const listeners = new Map();
+    const cleanup = () => {
+        for (const [signal, listener] of listeners)
+            signal.removeEventListener('abort', listener);
+        listeners.clear();
+    };
+    for (const signal of activeSignals) {
+        const listener = () => {
+            if (!controller.signal.aborted) {
+                controller.abort(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+            }
+            cleanup();
+        };
+        if (signal.aborted) {
+            listener();
+            break;
+        }
+        listeners.set(signal, listener);
+        signal.addEventListener('abort', listener, { once: true });
+    }
+    return { signal: controller.signal, cleanup };
+};
+const waitWithAbort = (promise, signals) => {
+    const activeSignals = signals.filter((signal) => !!signal);
+    if (activeSignals.length === 0)
+        return promise;
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const listeners = new Map();
+        const cleanup = () => {
+            for (const [signal, listener] of listeners)
+                signal.removeEventListener('abort', listener);
+            listeners.clear();
+        };
+        const settle = (handler) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            handler();
+        };
+        for (const signal of activeSignals) {
+            const listener = () => settle(() => reject(signal.reason ?? new DOMException('Aborted', 'AbortError')));
+            if (signal.aborted) {
+                listener();
+                return;
+            }
+            listeners.set(signal, listener);
+            signal.addEventListener('abort', listener, { once: true });
+        }
+        promise.then((value) => settle(() => resolve(value)), (error) => settle(() => reject(error)));
+    });
+};
+const isRetryableError = (error) => {
+    const candidate = error;
+    const status = candidate?.status ?? candidate?.statusCode;
+    if (status === 429 || status === 529 || status === 503)
+        return true;
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    return message.includes('rate limit')
+        || message.includes('overloaded')
+        || message.includes('too many requests');
+};
+const isContextOverflow = (error) => {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    return message.includes('context_length_exceeded')
+        || message.includes('context window')
+        || message.includes('maximum context length')
+        || message.includes('too many tokens')
+        || message.includes('input is too long')
+        || error.name === 'AI_ContextWindowExceededError';
+};
+const parseToolInput = (input) => {
+    if (typeof input !== 'string')
+        return input;
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return input;
+    }
+};
+const errorToString = (error) => error instanceof Error ? error.message : String(error);
+const toolSignature = (toolName, input) => {
+    let serializedInput;
+    try {
+        serializedInput = JSON.stringify(input);
+    }
+    catch {
+        serializedInput = String(input);
+    }
+    return `${toolName}\n${serializedInput}`;
+};
+const isPromiseLike = (value) => ((typeof value === 'object' && value !== null) || typeof value === 'function')
+    && typeof value.then === 'function';
+const isAsyncIterable = (value) => ((typeof value === 'object' && value !== null) || typeof value === 'function')
+    && typeof value[Symbol.asyncIterator] === 'function';
+const fallbackModelOutput = (output, error) => {
+    if (error !== undefined)
+        return { type: 'error-text', value: error };
+    if (typeof output === 'string')
+        return { type: 'text', value: output };
+    let jsonOutput;
+    try {
+        jsonOutput = output === undefined ? null : JSON.parse(JSON.stringify(output));
+    }
+    catch {
+        jsonOutput = String(output);
+    }
+    return { type: 'json', value: jsonOutput };
+};
+const recordToolCall = (toolCalls, toolCallIndexes, toolCall, update = {}) => {
+    const toolCallId = String(toolCall.toolCallId ?? '');
+    const nextRecord = {
+        toolCallId,
+        toolName: String(toolCall.toolName ?? ''),
+        input: parseToolInput(toolCall.input ?? toolCall.args),
+    };
+    const hasOutput = Object.prototype.hasOwnProperty.call(update, 'output');
+    const hasError = Object.prototype.hasOwnProperty.call(update, 'error');
+    if (hasOutput)
+        nextRecord.output = update.output;
+    if (hasError && update.error !== undefined)
+        nextRecord.error = errorToString(update.error);
+    const existingIndex = toolCallIndexes.get(toolCallId);
+    if (existingIndex !== undefined) {
+        const existing = toolCalls[existingIndex];
+        existing.toolName = nextRecord.toolName || existing.toolName;
+        if (nextRecord.input !== undefined)
+            existing.input = nextRecord.input;
+        if (hasOutput)
+            existing.output = nextRecord.output;
+        if (nextRecord.error !== undefined)
+            existing.error = nextRecord.error;
+        return;
+    }
+    toolCalls.push(nextRecord);
+    toolCallIndexes.set(toolCallId, toolCalls.length - 1);
+};
+export class AgentSessionEngine {
+    platform;
+    ownership;
+    options;
+    events = [];
+    eventIds = new Set();
+    generationHandles = new Map();
+    unresolvedLeaseCleanups = new Set();
+    sequence = 0;
+    persistenceRevision = 0;
+    persistenceQueue = Promise.resolve();
+    persistenceError;
+    notificationDispatches = new Set();
+    listeners = new Map();
+    scheduledGenerations = new Map();
+    retentionPromise;
+    maintenanceError;
+    generationQueue = Promise.resolve();
+    currentGenerationAbortController;
+    sessionAbortController = new AbortController();
+    jobUnsubscribe;
+    closed = false;
+    closeFinalizationReached = false;
+    closeCleanupCompletedState = false;
+    get closeCleanupCompleted() {
+        return this.closeCleanupCompletedState;
+    }
+    refreshCloseCleanupCompleted() {
+        this.closeCleanupCompletedState = this.closeFinalizationReached
+            && this.jobUnsubscribe === undefined
+            && this.unresolvedLeaseCleanups.size === 0;
+    }
+    static async createWithFactory(options, create) {
+        if (!options.eventStore)
+            return create();
+        if (!options.sessionId?.trim()) {
+            throw new Error('AgentSession.create() requires sessionId when eventStore is configured.');
+        }
+        let snapshot = await options.eventStore.load(options.sessionId);
+        const v2Store = isAgentEventStoreV2(options.eventStore);
+        if (snapshot
+            && ((!v2Store && snapshot.schemaVersion !== 1)
+                || (v2Store && snapshot.schemaVersion !== 1 && snapshot.schemaVersion !== 2))) {
+            throw new Error(`Unsupported agent event snapshot schema version ${String(snapshot.schemaVersion)}.`);
+        }
+        if (!v2Store && snapshot?.events.some(isTransactionalControlEvent)) {
+            throw new Error('Transactional events require an IAgentEventStoreV2-capable event store.');
+        }
+        if (snapshot?.schemaVersion === 2) {
+            snapshot = validateAgentEventSnapshotV2(snapshot, options.sessionId);
+        }
+        sessionHydrations.set(options, snapshot);
+        let session;
+        try {
+            session = create();
+        }
+        finally {
+            sessionHydrations.delete(options);
+        }
+        await session.interruptRestoredTransactions();
+        await session.flushPersistence();
+        await session.runEventRetentionLocked();
+        session.attachJobSubscription();
+        return session;
+    }
+    constructor(options, platform, ownership) {
+        this.platform = platform;
+        this.ownership = ownership;
+        this.options = options;
+        const hasHydration = sessionHydrations.has(options);
+        const hydrationSnapshot = sessionHydrations.get(options);
+        if (options.eventStore && !hasHydration) {
+            throw new Error('Use AgentSession.create() when eventStore is configured.');
+        }
+        if (options.eventStore && !options.sessionId?.trim()) {
+            throw new Error('sessionId is required when eventStore is configured.');
+        }
+        const tools = options.tools ?? {};
+        if (Object.prototype.hasOwnProperty.call(tools, 'invalid')) {
+            throw new Error('Tool name "invalid" is reserved for SmartAgent tool-call repair.');
+        }
+        const maxContextOverflowRetries = options.maxContextOverflowRetries ?? 3;
+        if (!Number.isSafeInteger(maxContextOverflowRetries) || maxContextOverflowRetries < 0) {
+            throw new Error('maxContextOverflowRetries must be a non-negative integer.');
+        }
+        const changeListenerTimeoutMs = options.changeListenerTimeoutMs ?? 30_000;
+        if (!Number.isSafeInteger(changeListenerTimeoutMs) || changeListenerTimeoutMs <= 0) {
+            throw new Error('changeListenerTimeoutMs must be a positive integer.');
+        }
+        const maxPendingSessionChanges = options.maxPendingSessionChanges ?? 1000;
+        if (!Number.isSafeInteger(maxPendingSessionChanges) || maxPendingSessionChanges <= 0) {
+            throw new Error('maxPendingSessionChanges must be a positive integer.');
+        }
+        const generationLeaseCleanupTimeoutMs = options.generationLeaseCleanupTimeoutMs ?? 30_000;
+        if (!Number.isSafeInteger(generationLeaseCleanupTimeoutMs) || generationLeaseCleanupTimeoutMs <= 0) {
+            throw new Error('generationLeaseCleanupTimeoutMs must be a positive integer.');
+        }
+        const maxArchivedTransactionTombstones = options.maxArchivedTransactionTombstones ?? 1000;
+        if (!Number.isSafeInteger(maxArchivedTransactionTombstones)
+            || maxArchivedTransactionTombstones <= 0) {
+            throw new Error('maxArchivedTransactionTombstones must be a positive integer.');
+        }
+        if (options.eventRetention) {
+            if (!Number.isSafeInteger(options.eventRetention.maxEvents)
+                || options.eventRetention.maxEvents <= 0) {
+                throw new Error('eventRetention.maxEvents must be a positive integer.');
+            }
+            if (!options.contextCompactor) {
+                throw new Error('eventRetention requires contextCompactor.');
+            }
+            if (!options.eventStore?.archive) {
+                throw new Error('eventRetention requires an eventStore with archive support.');
+            }
+        }
+        if (hydrationSnapshot) {
+            this.persistenceRevision = hydrationSnapshot.revision;
+            for (const event of hydrationSnapshot.events)
+                this.restoreEvent(event);
+        }
+        const initialEvents = [
+            ...(options.events ?? []),
+            ...modelMessagesToAgentEvents(options.messages ?? []),
+        ];
+        if (hydrationSnapshot && initialEvents.length > 0) {
+            throw new Error('Persisted sessions cannot also receive initial events or messages.');
+        }
+        if (options.eventStore
+            && !isAgentEventStoreV2(options.eventStore)
+            && initialEvents.some(isTransactionalControlEvent)) {
+            throw new Error('Transactional events require an IAgentEventStoreV2-capable event store.');
+        }
+        for (const event of initialEvents)
+            this.commitEvent(event, false);
+        if (options.eventStore && (!hydrationSnapshot || initialEvents.length > 0)) {
+            this.queuePersistence();
+        }
+        if (!options.eventStore)
+            this.attachJobSubscription();
+    }
+    attachJobSubscription() {
+        if (this.jobUnsubscribe)
+            return;
+        this.jobUnsubscribe = this.options.executionContext?.jobs?.subscribe?.(async (jobEvent) => {
+            if (this.closed)
+                return;
+            const job = jobEvent.job;
+            const runtimeType = `${job.type}-${jobEvent.type}`;
+            await this.pushRuntimeEvent({
+                type: runtimeType,
+                executionId: job.executionId,
+                jobType: job.type,
+                state: job.state,
+                request: job.request,
+                exitCode: job.exitCode,
+                stdout: job.stdout,
+                stderr: job.stderr,
+                signal: job.signal,
+                ...(jobEvent.type === 'output'
+                    ? {
+                        stream: jobEvent.stream,
+                        chunk: jobEvent.chunk,
+                        outputSequence: jobEvent.sequence,
+                    }
+                    : {}),
+            });
+        });
+    }
+    restoreEvent(event) {
+        if (this.eventIds.has(event.id))
+            throw new Error(`Duplicate agent event id "${event.id}".`);
+        if (!Number.isSafeInteger(event.sequence) || (event.sequence ?? 0) <= this.sequence) {
+            throw new Error(`Invalid persisted sequence for agent event "${event.id}".`);
+        }
+        this.events.push(event);
+        this.eventIds.add(event.id);
+        this.sequence = event.sequence;
+    }
+    queuePersistence() {
+        if (!this.options.eventStore)
+            return Promise.resolve();
+        const snapshot = structuredClone(this.events);
+        const operation = this.persistenceQueue.then(async () => {
+            if (this.persistenceError !== undefined)
+                throw this.persistenceError;
+            this.persistenceRevision = await this.options.eventStore.save(this.options.sessionId, snapshot, this.persistenceRevision);
+        });
+        this.persistenceQueue = operation.catch((error) => {
+            this.persistenceError ??= error;
+        });
+        return operation;
+    }
+    async flushPersistence() {
+        await this.persistenceQueue;
+        if (this.persistenceError !== undefined)
+            throw this.persistenceError;
+    }
+    reportListenerError(error) {
+        this.platform.reportListenerError(error);
+    }
+    queueNotification(change, durability) {
+        const dispatch = (async () => {
+            try {
+                await durability;
+            }
+            catch {
+                return;
+            }
+            for (const state of this.listeners.values()) {
+                this.enqueueListenerChange(state, change);
+            }
+        })();
+        this.notificationDispatches.add(dispatch);
+        void dispatch.then(() => this.notificationDispatches.delete(dispatch), () => this.notificationDispatches.delete(dispatch));
+    }
+    enqueueListenerChange(state, change) {
+        if (!state.subscribed)
+            return;
+        const maxPending = this.options.maxPendingSessionChanges ?? 1000;
+        if (state.queue.length >= maxPending) {
+            state.subscribed = false;
+            state.queue.length = 0;
+            this.listeners.delete(state.listener);
+            this.reportListenerError(new Error(`Session change listener exceeded ${maxPending} pending changes and was removed.`));
+            return;
+        }
+        state.queue.push(change);
+        if (state.deliveryPromise)
+            return;
+        const delivery = this.deliverListenerChanges(state);
+        state.deliveryPromise = delivery;
+        void delivery.then(() => {
+            if (state.deliveryPromise === delivery)
+                state.deliveryPromise = undefined;
+        });
+    }
+    async deliverListenerChanges(state) {
+        while (state.subscribed && state.queue.length > 0) {
+            const change = state.queue.shift();
+            let timer;
+            state.executing = true;
+            try {
+                await Promise.race([
+                    Promise.resolve().then(() => state.listener(change)),
+                    new Promise((_resolve, reject) => {
+                        timer = setTimeout(() => reject(new Error(`Session change listener timed out after ${this.options.changeListenerTimeoutMs ?? 30_000}ms.`)), this.options.changeListenerTimeoutMs ?? 30_000);
+                    }),
+                ]);
+            }
+            catch (error) {
+                state.subscribed = false;
+                state.queue.length = 0;
+                this.listeners.delete(state.listener);
+                this.reportListenerError(error);
+            }
+            finally {
+                state.executing = false;
+                if (timer)
+                    clearTimeout(timer);
+            }
+        }
+    }
+    commitEvents(events, notify = true) {
+        const nextIds = new Set();
+        for (const event of events) {
+            if (this.eventIds.has(event.id) || nextIds.has(event.id)) {
+                throw new Error(`Duplicate agent event id "${event.id}".`);
+            }
+            nextIds.add(event.id);
+        }
+        if (this.options.eventStore)
+            structuredClone(events);
+        const committedEvents = events.map((event) => ({
+            ...event,
+            sequence: ++this.sequence,
+        }));
+        for (const event of committedEvents) {
+            this.events.push(event);
+            this.eventIds.add(event.id);
+            if (event.type === 'generation-outcome') {
+                this.generationHandles.delete(event.generationId);
+            }
+        }
+        if (notify && committedEvents.length > 0) {
+            const durability = this.queuePersistence();
+            this.queueNotification({ type: 'committed', events: committedEvents }, durability);
+        }
+        return committedEvents;
+    }
+    commitEvent(event, notify = true) {
+        return this.commitEvents([event], notify)[0];
+    }
+    pushEvent(event) {
+        if (this.closed)
+            return Promise.reject(new Error('AgentSession is closed.'));
+        if (this.persistenceError !== undefined)
+            return Promise.reject(this.persistenceError);
+        if (this.maintenanceError !== undefined)
+            return Promise.reject(this.maintenanceError);
+        if (isTransactionalControlEvent(event)
+            && this.options.eventStore
+            && !isAgentEventStoreV2(this.options.eventStore)) {
+            return Promise.reject(new Error('Transactional events require an IAgentEventStoreV2-capable event store.'));
+        }
+        this.commitEvent(event);
+        return this.flushPersistence().then(async () => {
+            this.scheduleEventRetention();
+            if (!this.currentGenerationAbortController && this.retentionPromise) {
+                await this.retentionPromise;
+            }
+        });
+    }
+    pushUserMessage(content) {
+        return this.pushEvent(createAgentEvent({
+            type: 'user-message',
+            content,
+            parentIds: this.events.length > 0 ? [this.events[this.events.length - 1].id] : undefined,
+        }));
+    }
+    pushRuntimeEvent(event) {
+        return this.pushEvent(createAgentEvent({
+            type: 'runtime-event',
+            event,
+            parentIds: this.events.length > 0 ? [this.events[this.events.length - 1].id] : undefined,
+        }));
+    }
+    transaction(generationId) {
+        const transaction = getAgentGenerationTransactions(this.events).get(generationId);
+        if (!transaction) {
+            throw new Error(`Unknown transactional generation "${generationId}".`);
+        }
+        if (transaction.state === 'invalid') {
+            throw new Error(`Transactional generation "${generationId}" has an invalid event sequence.`);
+        }
+        return transaction;
+    }
+    archivedTransaction(generationId) {
+        for (let index = this.events.length - 1; index >= 0; index--) {
+            const event = this.events[index];
+            if (event.type !== 'context-compaction')
+                continue;
+            const transaction = event.archivedTransactions?.find((entry) => entry.generationId === generationId);
+            if (transaction)
+                return transaction;
+        }
+        return undefined;
+    }
+    verifyGenerationClaim(transaction) {
+        if (!transaction?.generationId?.trim() || !transaction.claimToken?.trim()) {
+            throw new Error('A valid transactional generation handle is required.');
+        }
+        const activeTransaction = getAgentGenerationTransactions(this.events).get(transaction.generationId);
+        if (activeTransaction?.state === 'invalid') {
+            throw new Error(`Transactional generation "${transaction.generationId}" has an invalid event sequence.`);
+        }
+        const state = activeTransaction ?? this.archivedTransaction(transaction.generationId);
+        if (!state)
+            throw new Error(`Unknown transactional generation "${transaction.generationId}".`);
+        const expectedDigest = 'begun' in state
+            ? state.begun.claimTokenDigest
+            : state.claimTokenDigest;
+        const actualDigest = this.platform.hashClaimToken(transaction.claimToken);
+        if (!/^[a-f0-9]{64}$/.test(expectedDigest)
+            || !this.platform.equalClaimDigests(expectedDigest, actualDigest)) {
+            throw new Error(`Invalid claim for transactional generation "${transaction.generationId}".`);
+        }
+        return state;
+    }
+    async interruptRestoredTransactions() {
+        const openTransactions = getOpenAgentGenerationTransactions(this.events);
+        if (openTransactions.length === 0)
+            return;
+        if (openTransactions.some((transaction) => transaction.state === 'invalid')) {
+            throw new Error('Cannot restore a session with an invalid transactional generation sequence.');
+        }
+        this.commitEvents(openTransactions.map((transaction) => createAgentEvent({
+            type: 'generation-outcome',
+            generationId: transaction.generationId,
+            outcome: 'interrupted',
+            reason: 'Session restoration interrupted nonterminal transactional execution.',
+            parentIds: [
+                transaction.executionCompleted?.id
+                    ?? transaction.executionStarted?.id
+                    ?? transaction.begun.id,
+            ],
+        })));
+        await this.flushPersistence();
+    }
+    transactionalStoreCapabilityError() {
+        return this.options.eventStore && !isAgentEventStoreV2(this.options.eventStore)
+            ? new Error('Transactional generations require an IAgentEventStoreV2-capable event store.')
+            : undefined;
+    }
+    beginGeneration(content, options = {}) {
+        const capabilityError = this.transactionalStoreCapabilityError();
+        if (capabilityError)
+            return Promise.reject(capabilityError);
+        return this.queueExclusive(async () => {
+            await this.flushPersistence();
+            const generationId = options.generationId ?? createAgentEventId('generation');
+            if (!generationId.trim())
+                throw new Error('Transactional generationId must not be empty.');
+            const existingTransaction = getAgentGenerationTransactions(this.events).get(generationId);
+            if (existingTransaction) {
+                if (existingTransaction.state === 'invalid') {
+                    throw new Error(`Transactional generation "${generationId}" has an invalid event sequence.`);
+                }
+                const existingMessage = this.events.find((event) => event.type === 'user-message'
+                    && event.generationId === generationId
+                    && event.causationId === existingTransaction.begun.id);
+                const handle = this.generationHandles.get(generationId);
+                if (handle && existingMessage && this.platform.isDeepEqual(existingMessage.content, content)) {
+                    return handle;
+                }
+                throw new Error(`Transactional generation "${generationId}" already exists and its claim cannot be reissued.`);
+            }
+            if (this.events.some((event) => event.generationId === generationId)) {
+                throw new Error(`Generation id "${generationId}" is already correlated with legacy events.`);
+            }
+            if (this.archivedTransaction(generationId) || this.generationHandles.has(generationId)) {
+                throw new Error(`Transactional generation "${generationId}" already exists and its claim cannot be reissued.`);
+            }
+            const claimToken = this.platform.createClaimToken();
+            const claimTokenDigest = this.platform.hashClaimToken(claimToken);
+            const priorEvent = this.events[this.events.length - 1];
+            const begun = createAgentEvent({
+                type: 'generation-begun',
+                generationId,
+                claimTokenDigest,
+                parentIds: priorEvent ? [priorEvent.id] : undefined,
+            });
+            const userMessage = createAgentEvent({
+                type: 'user-message',
+                content,
+                generationId,
+                causationId: begun.id,
+                parentIds: [begun.id],
+            });
+            this.commitEvents([begun, userMessage]);
+            const handle = Object.freeze({ generationId, claimToken });
+            this.generationHandles.set(generationId, handle);
+            await this.flushPersistence();
+            this.scheduleEventRetention();
+            return handle;
+        });
+    }
+    async appendGenerationOutcome(generationId, outcome, reason) {
+        const transaction = this.transaction(generationId);
+        if (transaction.state === 'accepted'
+            || transaction.state === 'rejected'
+            || transaction.state === 'interrupted') {
+            if (transaction.state === outcome)
+                return;
+            throw new Error(`Transactional generation "${generationId}" already has outcome "${transaction.state}".`);
+        }
+        if (outcome !== 'interrupted') {
+            if (transaction.state !== 'execution-completed') {
+                throw new Error(`Transactional generation "${generationId}" must be execution-completed before ${outcome}.`);
+            }
+            if (getUncertainToolExecutionIntents(this.events, generationId).length > 0) {
+                throw new Error(`Transactional generation "${generationId}" has unresolved tool execution intents.`);
+            }
+        }
+        const parent = transaction.executionCompleted
+            ?? transaction.executionStarted
+            ?? transaction.begun;
+        this.commitEvent(createAgentEvent({
+            type: 'generation-outcome',
+            generationId,
+            outcome,
+            reason,
+            parentIds: [parent.id],
+        }));
+        await this.flushPersistence();
+        this.scheduleEventRetention();
+    }
+    transactionOutcomeErrorReason(error) {
+        if (this.options.transactionOutcomeErrorProjector) {
+            try {
+                const projected = this.options.transactionOutcomeErrorProjector(error);
+                if (typeof projected === 'string' && projected.trim())
+                    return projected;
+            }
+            catch {
+                // Invalid projectors fall back to the normal diagnostic reason.
+            }
+        }
+        return errorToString(error);
+    }
+    finalizeGeneration(transaction, outcome) {
+        const capabilityError = this.transactionalStoreCapabilityError();
+        if (capabilityError)
+            return Promise.reject(capabilityError);
+        return this.queueExclusive(async () => {
+            if (!['accepted', 'rejected', 'interrupted'].includes(outcome)) {
+                throw new Error(`Invalid transactional generation outcome "${String(outcome)}".`);
+            }
+            const state = this.verifyGenerationClaim(transaction);
+            if (!('begun' in state)) {
+                if (state.outcome === outcome)
+                    return;
+                throw new Error(`Transactional generation "${transaction.generationId}" already has outcome "${state.outcome}".`);
+            }
+            await this.appendGenerationOutcome(transaction.generationId, outcome);
+        });
+    }
+    listUncertainToolExecutions() {
+        return structuredClone(getUncertainToolExecutionIntents(this.events));
+    }
+    reconcileToolExecution(intentId, reconciliation) {
+        const capabilityError = this.transactionalStoreCapabilityError();
+        if (capabilityError)
+            return Promise.reject(capabilityError);
+        return this.queueExclusive(async () => {
+            await this.flushPersistence();
+            const intent = this.events.find((event) => event.type === 'tool-execution-intent' && event.id === intentId);
+            if (!intent)
+                throw new Error(`Unknown tool execution intent "${intentId}".`);
+            const defaultError = reconciliation.resolution === 'not-executed'
+                ? 'Tool execution was reconciled as not executed.'
+                : reconciliation.resolution === 'abandoned-unknown'
+                    ? 'Tool execution was abandoned with an unknown outcome.'
+                    : undefined;
+            const error = reconciliation.resolution === 'executed'
+                ? undefined
+                : reconciliation.error ?? defaultError;
+            const existing = this.events.find((event) => event.type === 'tool-execution-reconciliation' && event.intentId === intentId);
+            if (existing) {
+                const same = existing.resolution === reconciliation.resolution
+                    && existing.error === error
+                    && this.platform.isDeepEqual(existing.output, reconciliation.resolution === 'executed' ? reconciliation.output : undefined)
+                    && this.platform.isDeepEqual(existing.modelOutput, reconciliation.resolution === 'executed' ? reconciliation.modelOutput : undefined);
+                if (!same)
+                    throw new Error(`Tool execution intent "${intentId}" has a conflicting reconciliation.`);
+                return;
+            }
+            if (!getUncertainToolExecutionIntents(this.events).some((entry) => entry.id === intentId)) {
+                throw new Error(`Tool execution intent "${intentId}" already has a terminal result.`);
+            }
+            if (reconciliation.resolution === 'executed'
+                && (!Object.prototype.hasOwnProperty.call(reconciliation, 'output') || !reconciliation.modelOutput)) {
+                throw new Error('Executed tool reconciliation requires explicit output and modelOutput.');
+            }
+            const toolCall = [...this.events].reverse().find((event) => event.type === 'tool-call'
+                && event.generationId === intent.generationId
+                && event.toolCallId === intent.toolCallId);
+            const reconciliationEvent = createAgentEvent({
+                type: 'tool-execution-reconciliation',
+                generationId: intent.generationId,
+                inferenceId: intent.inferenceId,
+                causationId: intent.id,
+                intentId: intent.id,
+                toolCallId: intent.toolCallId,
+                toolName: intent.toolName,
+                resolution: reconciliation.resolution,
+                output: reconciliation.resolution === 'executed' ? reconciliation.output : undefined,
+                modelOutput: reconciliation.resolution === 'executed' ? reconciliation.modelOutput : undefined,
+                error,
+                parentIds: [intent.id],
+            });
+            const resultEvent = createAgentEvent({
+                type: 'tool-result',
+                generationId: intent.generationId,
+                inferenceId: intent.inferenceId,
+                causationId: intent.inferenceId,
+                executionIntentId: intent.id,
+                toolCallId: intent.toolCallId,
+                toolName: intent.toolName,
+                output: reconciliation.resolution === 'executed' ? reconciliation.output : undefined,
+                error,
+                modelOutput: reconciliation.resolution === 'executed'
+                    ? reconciliation.modelOutput
+                    : { type: 'error-text', value: error },
+                parentIds: toolCall ? [toolCall.id] : [intent.id],
+            });
+            this.commitEvents([reconciliationEvent, resultEvent]);
+            await this.flushPersistence();
+            this.scheduleEventRetention();
+        });
+    }
+    getEvents() {
+        return this.events.slice();
+    }
+    getModelMessages() {
+        return this.buildContext(this.events);
+    }
+    buildContext(events) {
+        const visibleEvents = filterModelVisibleAgentEvents(events);
+        return this.options.contextBuilder
+            ? this.options.contextBuilder({ events: visibleEvents })
+            : buildModelMessages(visibleEvents);
+    }
+    subscribe(listener) {
+        if (this.closed)
+            throw new Error('AgentSession is closed.');
+        const existing = this.listeners.get(listener);
+        if (existing) {
+            return () => {
+                existing.subscribed = false;
+                existing.queue.length = 0;
+                this.listeners.delete(listener);
+            };
+        }
+        const state = {
+            listener,
+            queue: [],
+            executing: false,
+            subscribed: true,
+        };
+        this.listeners.set(listener, state);
+        return () => {
+            state.subscribed = false;
+            state.queue.length = 0;
+            this.listeners.delete(listener);
+        };
+    }
+    scheduleGenerate(options) {
+        if (this.closed)
+            return Promise.reject(new Error('AgentSession is closed.'));
+        const capabilityError = options.transaction
+            ? this.transactionalStoreCapabilityError()
+            : undefined;
+        if (capabilityError)
+            return Promise.reject(capabilityError);
+        if (!options.key.trim())
+            return Promise.reject(new Error('Scheduled generation key must not be empty.'));
+        const debounceMs = options.debounceMs ?? 50;
+        if (!Number.isSafeInteger(debounceMs) || debounceMs < 0) {
+            return Promise.reject(new Error('debounceMs must be a non-negative integer.'));
+        }
+        const existing = this.scheduledGenerations.get(options.key);
+        if (existing) {
+            if (existing.model !== options.model
+                || existing.system !== options.system
+                || existing.tools !== options.tools
+                || existing.providerOptions !== options.providerOptions
+                || existing.cache !== options.cache
+                || existing.maxSteps !== options.maxSteps
+                || existing.abort !== options.abort
+                || existing.prepare !== options.prepare
+                || existing.transaction?.generationId !== options.transaction?.generationId
+                || existing.transaction?.claimToken !== options.transaction?.claimToken) {
+                return Promise.reject(new Error(`Conflicting options for scheduled generation "${options.key}".`));
+            }
+            if (existing.state === 'debouncing') {
+                clearTimeout(existing.timer);
+                existing.debounceMs = debounceMs;
+                existing.timer = setTimeout(() => this.startScheduledGeneration(options.key), debounceMs);
+            }
+            return existing.promise;
+        }
+        if (options.abort?.aborted) {
+            const abortReason = options.abort.reason ?? new DOMException('Aborted', 'AbortError');
+            if (!options.transaction)
+                return Promise.reject(abortReason);
+            return this.queueExclusive(async () => {
+                const transaction = this.verifyGenerationClaim(options.transaction);
+                if (!('begun' in transaction)) {
+                    if (transaction.outcome === 'interrupted')
+                        throw abortReason;
+                    throw new Error(`Transactional generation "${transaction.generationId}" already has outcome "${transaction.outcome}".`);
+                }
+                await this.appendGenerationOutcome(options.transaction.generationId, 'interrupted', this.transactionOutcomeErrorReason(abortReason));
+                throw abortReason;
+            });
+        }
+        let resolve;
+        let reject;
+        const promise = new Promise((resolvePromise, rejectPromise) => {
+            resolve = resolvePromise;
+            reject = rejectPromise;
+        });
+        const controller = new AbortController();
+        const onAbort = () => this.cancelScheduledGeneration(options.key, options.abort?.reason ?? new DOMException('Aborted', 'AbortError'));
+        options.abort?.addEventListener('abort', onAbort, { once: true });
+        const scheduled = {
+            state: 'debouncing',
+            debounceMs,
+            model: options.model,
+            system: options.system,
+            tools: options.tools,
+            providerOptions: options.providerOptions,
+            cache: options.cache,
+            maxSteps: options.maxSteps,
+            abort: options.abort,
+            transaction: options.transaction,
+            prepare: options.prepare,
+            timer: setTimeout(() => this.startScheduledGeneration(options.key), debounceMs),
+            controller,
+            removeAbortListener: () => options.abort?.removeEventListener('abort', onAbort),
+            promise,
+            resolve,
+            reject,
+        };
+        this.scheduledGenerations.set(options.key, scheduled);
+        return promise;
+    }
+    startScheduledGeneration(key) {
+        const scheduled = this.scheduledGenerations.get(key);
+        if (!scheduled || scheduled.state !== 'debouncing')
+            return;
+        scheduled.state = 'queued';
+        void this.generate({
+            model: scheduled.model,
+            system: scheduled.system,
+            tools: scheduled.tools,
+            providerOptions: scheduled.providerOptions,
+            cache: scheduled.cache,
+            maxSteps: scheduled.maxSteps,
+            abort: scheduled.controller.signal,
+            transaction: scheduled.transaction,
+            prepare: scheduled.prepare,
+        }).then((result) => this.settleScheduledGeneration(key, scheduled, () => scheduled.resolve(result)), (error) => this.settleScheduledGeneration(key, scheduled, () => scheduled.reject(error)));
+    }
+    settleScheduledGeneration(key, scheduled, settle) {
+        if (this.scheduledGenerations.get(key) === scheduled) {
+            this.scheduledGenerations.delete(key);
+        }
+        scheduled.removeAbortListener();
+        settle();
+    }
+    cancelScheduledGeneration(key, reason) {
+        const scheduled = this.scheduledGenerations.get(key);
+        if (!scheduled)
+            return false;
+        clearTimeout(scheduled.timer);
+        this.scheduledGenerations.delete(key);
+        scheduled.removeAbortListener();
+        const cancellationReason = reason
+            ?? new DOMException('Scheduled generation cancelled', 'AbortError');
+        if (!scheduled.controller.signal.aborted)
+            scheduled.controller.abort(cancellationReason);
+        if (!scheduled.transaction) {
+            scheduled.reject(cancellationReason);
+            return true;
+        }
+        let transaction;
+        try {
+            const claim = this.verifyGenerationClaim(scheduled.transaction);
+            if (!('begun' in claim)) {
+                scheduled.reject(new Error(`Transactional generation "${claim.generationId}" already has outcome "${claim.outcome}".`));
+                return true;
+            }
+            transaction = claim;
+        }
+        catch (error) {
+            scheduled.reject(error);
+            return true;
+        }
+        if (transaction.state === 'execution-started')
+            return true;
+        void this.appendGenerationOutcome(scheduled.transaction.generationId, 'interrupted', this.transactionOutcomeErrorReason(cancellationReason)).then(() => scheduled.reject(cancellationReason), (error) => scheduled.reject(error));
+        return true;
+    }
+    async performCompaction(reason, abortSignal) {
+        abortSignal?.throwIfAborted();
+        await this.flushPersistence();
+        abortSignal?.throwIfAborted();
+        const unresolvedIntents = getUncertainToolExecutionIntents(this.events);
+        if (unresolvedIntents.length > 0) {
+            if (reason === 'context-overflow' || reason === 'retention')
+                return undefined;
+            throw new Error('Context compaction is blocked by unresolved tool execution intents.');
+        }
+        const openTransactions = getOpenAgentGenerationTransactions(this.events);
+        if (openTransactions.some((transaction) => transaction.state === 'invalid')) {
+            throw new Error('Context compaction is blocked by an invalid transactional generation sequence.');
+        }
+        let coveredEvents;
+        if (openTransactions.length > 0) {
+            if (reason === 'retention')
+                return undefined;
+            if (reason !== 'context-overflow') {
+                throw new Error('Context compaction is blocked while a transactional generation is open.');
+            }
+            const openGenerationIds = new Set(openTransactions.map((transaction) => transaction.generationId));
+            const firstOpenIndex = this.events.findIndex((event) => !!event.generationId && openGenerationIds.has(event.generationId));
+            coveredEvents = firstOpenIndex < 0 ? [] : this.events.slice(0, firstOpenIndex);
+        }
+        else {
+            coveredEvents = this.events.slice();
+        }
+        if (coveredEvents.length === 0)
+            return undefined;
+        const visibleCoveredEvents = filterModelVisibleAgentEvents(coveredEvents);
+        const messages = this.buildContext(visibleCoveredEvents);
+        const replacementMessages = this.options.contextCompactor
+            ? await this.invokeGenerationCallback(() => this.options.contextCompactor(messages, visibleCoveredEvents, { abortSignal, reason }))
+            : reason === 'context-overflow' && this.options.onContextOverflow
+                ? await this.invokeGenerationCallback(() => this.options.onContextOverflow(messages, { abortSignal }))
+                : undefined;
+        if (!replacementMessages) {
+            throw new ContextOverflowError('Agent context compaction requires a contextCompactor.');
+        }
+        abortSignal?.throwIfAborted();
+        const archivedTransactionMap = new Map();
+        const rememberArchivedTransaction = (transaction) => {
+            archivedTransactionMap.delete(transaction.generationId);
+            archivedTransactionMap.set(transaction.generationId, transaction);
+        };
+        for (const event of coveredEvents) {
+            if (event.type !== 'context-compaction')
+                continue;
+            for (const transaction of event.archivedTransactions ?? []) {
+                rememberArchivedTransaction(transaction);
+            }
+        }
+        const coveredTransactions = getAgentGenerationTransactions(coveredEvents);
+        for (const event of coveredEvents) {
+            if (event.type !== 'generation-outcome')
+                continue;
+            const transaction = coveredTransactions.get(event.generationId);
+            if (!transaction || transaction.state === 'invalid')
+                continue;
+            rememberArchivedTransaction({
+                generationId: transaction.generationId,
+                claimTokenDigest: transaction.begun.claimTokenDigest,
+                outcome: event.outcome,
+            });
+        }
+        const archivedTransactions = [...archivedTransactionMap.values()]
+            .slice(-(this.options.maxArchivedTransactionTombstones ?? 1000));
+        const compaction = this.commitEvent(createAgentEvent({
+            type: 'context-compaction',
+            coveredEventIds: coveredEvents.map((event) => event.id),
+            replacementEvents: modelMessagesToAgentEvents(replacementMessages),
+            archivedTransactions: archivedTransactions.length > 0
+                ? archivedTransactions
+                : undefined,
+            parentIds: [coveredEvents[coveredEvents.length - 1].id],
+        }));
+        await this.flushPersistence();
+        return compaction;
+    }
+    queueExclusive(operation) {
+        const run = this.generationQueue.then(() => {
+            if (this.closed)
+                throw new Error('AgentSession is closed.');
+            if (this.maintenanceError !== undefined)
+                throw this.maintenanceError;
+            return operation();
+        });
+        this.generationQueue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    compact(options = {}) {
+        const combinedAbort = combineAbortSignals([options.abort, this.sessionAbortController.signal]);
+        const operation = this.queueExclusive(async () => {
+            combinedAbort.signal.throwIfAborted();
+            await this.performCompaction(options.reason ?? 'manual', combinedAbort.signal);
+        }).finally(combinedAbort.cleanup);
+        return waitWithAbort(operation, [options.abort, this.sessionAbortController.signal]);
+    }
+    archiveCompactedEvents(compactionEventId) {
+        return this.queueExclusive(() => this.archiveCompactedEventsLocked(compactionEventId));
+    }
+    async archiveCompactedEventsLocked(compactionEventId) {
+        if (getOpenAgentGenerationTransactions(this.events).length > 0) {
+            throw new Error('Archival is blocked while a transactional generation is open.');
+        }
+        if (getUncertainToolExecutionIntents(this.events).length > 0) {
+            throw new Error('Archival is blocked by unresolved tool execution intents.');
+        }
+        const eventStore = this.options.eventStore;
+        if (!eventStore?.archive) {
+            throw new Error('Archival requires an eventStore with archive support.');
+        }
+        const compaction = compactionEventId
+            ? this.events.find((event) => event.id === compactionEventId)
+            : [...this.events].reverse().find((event) => event.type === 'context-compaction');
+        if (!compaction || compaction.type !== 'context-compaction')
+            return undefined;
+        const coveredIds = new Set(compaction.coveredEventIds);
+        const archivedEvents = this.events.filter((event) => coveredIds.has(event.id));
+        if (archivedEvents.length === 0) {
+            return isAgentEventStoreV2(eventStore)
+                ? eventStore.loadArchive?.(this.options.sessionId, compaction.id)
+                : eventStore.loadArchive?.(this.options.sessionId, compaction.id);
+        }
+        const archiveBase = {
+            sessionId: this.options.sessionId,
+            archiveId: compaction.id,
+            createdAt: Date.now(),
+            events: structuredClone(archivedEvents),
+        };
+        const archive = isAgentEventStoreV2(eventStore)
+            ? { ...archiveBase, schemaVersion: 2 }
+            : { ...archiveBase, schemaVersion: 1 };
+        await this.flushPersistence();
+        if (isAgentEventStoreV2(eventStore)) {
+            await eventStore.archive?.(archive);
+        }
+        else {
+            await eventStore.archive?.(archive);
+        }
+        this.events.splice(0, this.events.length, ...this.events.filter((event) => !coveredIds.has(event.id)));
+        for (const event of archivedEvents)
+            this.eventIds.delete(event.id);
+        const durability = this.queuePersistence();
+        this.queueNotification({ type: 'archived', events: archivedEvents }, durability);
+        await durability;
+        return archive;
+    }
+    async runEventRetentionLocked() {
+        const retention = this.options.eventRetention;
+        if (!retention)
+            return;
+        if (getOpenAgentGenerationTransactions(this.events).length > 0
+            || getUncertainToolExecutionIntents(this.events).length > 0)
+            return;
+        while (this.events.length > retention.maxEvents) {
+            const compaction = await this.performCompaction('retention', this.sessionAbortController.signal);
+            if (!compaction)
+                return;
+            await this.archiveCompactedEventsLocked(compaction.id);
+        }
+    }
+    scheduleEventRetention() {
+        const retention = this.options.eventRetention;
+        if (!retention
+            || this.events.length <= retention.maxEvents
+            || this.retentionPromise
+            || this.closed)
+            return;
+        const operation = this.generationQueue.then(() => {
+            if (this.maintenanceError !== undefined)
+                throw this.maintenanceError;
+            return this.runEventRetentionLocked();
+        });
+        this.generationQueue = operation.then(() => undefined, () => undefined);
+        this.retentionPromise = operation;
+        void operation.then(() => {
+            if (this.retentionPromise === operation)
+                this.retentionPromise = undefined;
+        }, (error) => {
+            const expectedCloseAbort = this.closed
+                && (error === this.sessionAbortController.signal.reason
+                    || (error instanceof DOMException && error.name === 'AbortError'));
+            if (!expectedCloseAbort)
+                this.maintenanceError ??= error;
+            if (this.retentionPromise === operation)
+                this.retentionPromise = undefined;
+        });
+    }
+    eventsByIds(ids) {
+        return this.events.filter((event) => ids.has(event.id));
+    }
+    currentGenerationEvent(generationId, type, toolCallId, inferenceId) {
+        return this.events.find((event) => event.generationId === generationId
+            && event.type === type
+            && event.toolCallId === toolCallId
+            && (inferenceId === undefined || event.inferenceId === inferenceId));
+    }
+    reconcileToolResult(generationId, modelEvent) {
+        const existingIndex = this.events.findIndex((event) => event.generationId === generationId
+            && event.type === 'tool-result'
+            && event.toolCallId === modelEvent.toolCallId
+            && event.inferenceId === modelEvent.inferenceId);
+        let provisionalIndex = existingIndex;
+        if (provisionalIndex === -1) {
+            for (let index = this.events.length - 1; index >= 0; index--) {
+                const event = this.events[index];
+                if (event.generationId === generationId
+                    && event.type === 'tool-result'
+                    && event.toolCallId === modelEvent.toolCallId
+                    && event.responseMessageCommitted !== true) {
+                    provisionalIndex = index;
+                    break;
+                }
+            }
+        }
+        if (provisionalIndex === -1) {
+            this.commitEvent(modelEvent);
+            return;
+        }
+        const existing = this.events[provisionalIndex];
+        this.events[provisionalIndex] = {
+            ...existing,
+            modelOutput: modelEvent.modelOutput,
+            responseMessageCommitted: true,
+            providerOptions: modelEvent.providerOptions,
+            messageProviderOptions: modelEvent.messageProviderOptions,
+        };
+        const updatedEvent = this.events[provisionalIndex];
+        const durability = this.queuePersistence();
+        this.queueNotification({ type: 'updated', events: [updatedEvent] }, durability);
+    }
+    commitResponseMessages(messages, generationId, inferenceId, executionIntentIds) {
+        const convertedEvents = modelMessagesToAgentEvents(messages, {
+            causationId: inferenceId,
+            generationId,
+            inferenceId,
+        });
+        for (const event of convertedEvents) {
+            if (event.type === 'tool-call') {
+                if (!this.currentGenerationEvent(generationId, 'tool-call', event.toolCallId, inferenceId)) {
+                    this.commitEvent(event);
+                }
+            }
+            else if (event.type === 'tool-result') {
+                const executionIntentId = event.executionIntentId
+                    ?? executionIntentIds.get(event.toolCallId);
+                this.reconcileToolResult(generationId, executionIntentId ? { ...event, executionIntentId } : event);
+            }
+            else {
+                this.commitEvent(event);
+            }
+        }
+    }
+    wrapToolsForGeneration(generationId, tools, preparations, completedPreparations, preparationErrors, ledger, getMessages) {
+        const wrappedTools = {};
+        for (const [toolName, toolDefinition] of Object.entries(tools)) {
+            const executableTool = toolDefinition;
+            if (!executableTool.execute) {
+                wrappedTools[toolName] = toolDefinition;
+                continue;
+            }
+            const originalExecute = executableTool.execute.bind(executableTool);
+            wrappedTools[toolName] = {
+                ...toolDefinition,
+                execute: (input, executionOptions) => {
+                    const toolCallId = executionOptions.toolCallId;
+                    const signature = toolSignature(toolName, input);
+                    const preparation = preparations.get(toolCallId);
+                    if (!preparation) {
+                        throw new Error(`Tool call "${toolCallId}" executed before preparation in generation "${generationId}".`);
+                    }
+                    if (preparation.signature !== signature) {
+                        throw new Error(`Tool call id collision for "${toolCallId}" in generation "${generationId}".`);
+                    }
+                    if (!completedPreparations.has(toolCallId)) {
+                        throw preparationErrors.get(toolCallId)
+                            ?? new Error(`Tool call "${toolCallId}" executed before preparation completed in generation "${generationId}".`);
+                    }
+                    const existing = ledger.get(toolCallId);
+                    if (existing) {
+                        if (existing.signature !== signature) {
+                            throw new Error(`Tool call id collision for "${toolCallId}" in generation "${generationId}".`);
+                        }
+                        return existing.promise;
+                    }
+                    const contextualExecutionOptions = {
+                        ...executionOptions,
+                        messages: getMessages(),
+                    };
+                    let resolveCompletion;
+                    let rejectCompletion;
+                    const promise = new Promise((resolve, reject) => {
+                        resolveCompletion = resolve;
+                        rejectCompletion = reject;
+                    });
+                    void promise.catch(() => undefined);
+                    ledger.set(toolCallId, { signature, promise });
+                    try {
+                        const result = this.invokeGenerationCallback(() => originalExecute(input, contextualExecutionOptions));
+                        if (isAsyncIterable(result)) {
+                            return this.trackToolExecutionIterable(result, resolveCompletion, rejectCompletion);
+                        }
+                        if (isPromiseLike(result)) {
+                            const deferredIterable = (async function* () {
+                                const output = await result;
+                                if (isAsyncIterable(output)) {
+                                    yield* output;
+                                }
+                                else {
+                                    yield output;
+                                }
+                            })();
+                            return this.trackToolExecutionIterable(deferredIterable, resolveCompletion, rejectCompletion);
+                        }
+                        resolveCompletion(result);
+                        return result;
+                    }
+                    catch (error) {
+                        rejectCompletion(error);
+                        throw error;
+                    }
+                },
+            };
+        }
+        wrappedTools.invalid = plugins.tool({
+            description: 'Sink for unrecognised tool calls; returns an error message to the model',
+            inputSchema: plugins.z.object({ tool: plugins.z.string(), error: plugins.z.string() }),
+            execute: async ({ tool, error }) => `Unknown tool "${tool}": ${error}`,
+        });
+        return wrappedTools;
+    }
+    trackToolExecutionIterable(iterable, resolveCompletion, rejectCompletion) {
+        const iterator = iterable[Symbol.asyncIterator]();
+        let settled = false;
+        let lastOutput;
+        const settleSuccess = () => {
+            if (settled)
+                return;
+            settled = true;
+            resolveCompletion(lastOutput);
+        };
+        const settleError = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            rejectCompletion(error);
+        };
+        const incompleteError = () => new Error('Tool execution stream ended before normal completion.');
+        const observe = (operation, cacheOutput, rejectWhenDone = false) => {
+            let operationResult;
+            try {
+                operationResult = Promise.resolve(operation());
+            }
+            catch (error) {
+                settleError(error);
+                return Promise.reject(error);
+            }
+            return operationResult.then((result) => {
+                if (!result.done && cacheOutput)
+                    lastOutput = result.value;
+                if (result.done) {
+                    if (rejectWhenDone)
+                        settleError(incompleteError());
+                    else
+                        settleSuccess();
+                }
+                return result;
+            }, (error) => {
+                settleError(error);
+                throw error;
+            });
+        };
+        const wrappedIterator = {
+            next: (...args) => observe(() => iterator.next(...args), true),
+            return: iterator.return
+                ? (...args) => {
+                    let returnResult;
+                    try {
+                        returnResult = Promise.resolve(iterator.return(...args));
+                        settleError(incompleteError());
+                    }
+                    catch (error) {
+                        settleError(error);
+                        return Promise.reject(error);
+                    }
+                    return returnResult.then((result) => result, (error) => {
+                        settleError(error);
+                        throw error;
+                    });
+                }
+                : async (...args) => {
+                    settleError(incompleteError());
+                    return { done: true, value: args[0] };
+                },
+            throw: iterator.throw
+                ? (error) => observe(() => iterator.throw(error), true, true)
+                : async (error) => {
+                    settleError(error);
+                    throw error;
+                },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+        return wrappedIterator;
+    }
+    ownGenerationLeaseCleanup(lease) {
+        if (!lease?.close)
+            return undefined;
+        const ownership = { lease, settled: false };
+        this.unresolvedLeaseCleanups.add(ownership);
+        return ownership;
+    }
+    async cleanupGenerationLease(ownership) {
+        if (ownership.settled)
+            return;
+        const timeoutMs = this.options.generationLeaseCleanupTimeoutMs ?? 30_000;
+        const timeoutError = new Error(`Generation lease cleanup timed out after ${timeoutMs}ms.`);
+        let timer;
+        const closePromise = Promise.resolve().then(() => this.invokeGenerationCallback(() => ownership.lease.close()));
+        void closePromise.then(() => {
+            ownership.settled = true;
+            this.unresolvedLeaseCleanups.delete(ownership);
+            this.refreshCloseCleanupCompleted();
+        }, () => undefined);
+        const timeoutPromise = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => reject(timeoutError), timeoutMs);
+        });
+        try {
+            await Promise.race([closePromise, timeoutPromise]);
+            ownership.settled = true;
+            this.unresolvedLeaseCleanups.delete(ownership);
+        }
+        catch (error) {
+            throw new AgentGenerationLeaseCleanupError(ownership.lease, error, () => this.cleanupGenerationLease(ownership));
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    generate(options = {}) {
+        const capabilityError = options.transaction
+            ? this.transactionalStoreCapabilityError()
+            : undefined;
+        if (capabilityError)
+            return Promise.reject(capabilityError);
+        const run = this.generationQueue.then(async () => {
+            if (!options.transaction)
+                options.abort?.throwIfAborted();
+            if (!options.transaction && this.sessionAbortController.signal.aborted) {
+                throw this.sessionAbortController.signal.reason
+                    ?? new DOMException('Agent session aborted', 'AbortError');
+            }
+            if (this.closed)
+                throw new Error('AgentSession is closed.');
+            if (this.maintenanceError !== undefined)
+                throw this.maintenanceError;
+            await this.runEventRetentionLocked();
+            return this.generateLocked(options);
+        });
+        this.generationQueue = run.then(() => undefined, () => undefined);
+        return options.transaction
+            ? run
+            : waitWithAbort(run, [options.abort, this.sessionAbortController.signal]);
+    }
+    resolveEffectiveGenerationRuntime(options, lease) {
+        const model = lease?.model ?? options.model ?? this.options.model;
+        if (!model) {
+            throw new Error('Agent generation requires a model from its prepared lease, generate options, or session defaults.');
+        }
+        const system = lease?.system ?? options.system ?? this.options.system;
+        const tools = lease?.tools ?? options.tools ?? this.options.tools ?? {};
+        if (Object.prototype.hasOwnProperty.call(tools, 'invalid')) {
+            throw new Error('Tool name "invalid" is reserved for SmartAgent tool-call repair.');
+        }
+        const providerOptions = lease?.providerOptions
+            ?? options.providerOptions
+            ?? this.options.providerOptions;
+        const cache = lease?.cache ?? options.cache ?? this.options.cache ?? 'auto';
+        const maxSteps = lease?.maxSteps ?? options.maxSteps ?? this.options.maxSteps ?? 20;
+        if (!Number.isSafeInteger(maxSteps) || maxSteps <= 0) {
+            throw new Error('maxSteps must be a positive integer.');
+        }
+        const configuredCacheProvider = typeof cache === 'object' ? cache.provider : undefined;
+        const messageCacheProvider = cache === false
+            ? undefined
+            : configuredCacheProvider
+                ?? plugins.resolveSmartAiCacheProvider(model.provider, model.modelId);
+        const effectiveModel = messageCacheProvider
+            ? plugins.wrapLanguageModel({
+                model,
+                middleware: plugins.createSmartAiCachingMiddleware({
+                    ...(typeof cache === 'object' ? cache : {}),
+                    provider: messageCacheProvider,
+                }),
+            })
+            : model;
+        return {
+            model: effectiveModel,
+            system,
+            tools,
+            providerOptions: plugins.applySmartAiCacheProviderOptions({
+                provider: model.provider,
+                modelId: model.modelId,
+                providerOptions,
+                cache,
+                sessionId: this.options.sessionId,
+            }),
+            maxSteps,
+        };
+    }
+    async generateLocked(options) {
+        await this.flushPersistence();
+        const maxContextOverflowRetries = this.options.maxContextOverflowRetries ?? 3;
+        const generationId = options.transaction?.generationId ?? createAgentEventId('generation');
+        const generationAbortController = new AbortController();
+        this.currentGenerationAbortController = generationAbortController;
+        const combinedAbort = combineAbortSignals([
+            this.sessionAbortController.signal,
+            generationAbortController.signal,
+            options.abort,
+        ]);
+        let lease;
+        let leaseCleanupOwnership;
+        let operationError;
+        let completedResult;
+        let transactionExecutionStarted = false;
+        try {
+            if (options.transaction) {
+                const transaction = this.verifyGenerationClaim(options.transaction);
+                if (!('begun' in transaction) || transaction.state !== 'begun') {
+                    const transactionState = 'begun' in transaction
+                        ? transaction.state
+                        : transaction.outcome;
+                    throw new Error(`Transactional generation "${generationId}" cannot execute from state "${transactionState}".`);
+                }
+                this.commitEvent(createAgentEvent({
+                    type: 'generation-execution-started',
+                    generationId,
+                    parentIds: [transaction.begun.id],
+                }));
+                await this.flushPersistence();
+                transactionExecutionStarted = true;
+            }
+            combinedAbort.signal.throwIfAborted();
+            lease = options.prepare
+                ? await this.invokeGenerationCallback(() => options.prepare({ generationId, abortSignal: combinedAbort.signal }))
+                : undefined;
+            leaseCleanupOwnership = this.ownGenerationLeaseCleanup(lease);
+            combinedAbort.signal.throwIfAborted();
+            const runtime = this.resolveEffectiveGenerationRuntime(options, lease);
+            const maxSteps = runtime.maxSteps;
+            let stepCount = 0;
+            let attempt = 0;
+            let contextOverflowRetries = 0;
+            let totalInput = 0;
+            let totalOutput = 0;
+            let totalCacheRead = 0;
+            let totalCacheWrite = 0;
+            let currentInferenceId;
+            let latestInferenceVisibleIds = new Set(this.events.map((event) => event.id));
+            const completedInferenceIds = new Set();
+            const reasoningTextById = new Map();
+            const toolCalls = [];
+            const toolCallIndexes = new Map();
+            const preparations = new Map();
+            const completedPreparations = new Set();
+            const preparationErrors = new Map();
+            const ledger = new Map();
+            const executionIntentIds = new Map();
+            const preliminaryToolOutputs = new Map();
+            const beginInference = async () => {
+                const marker = this.commitEvent(createAgentEvent({
+                    type: 'runtime-event',
+                    event: {
+                        type: 'inference-started',
+                        generationId,
+                        completedSteps: stepCount,
+                    },
+                    modelVisible: false,
+                    generationId,
+                    parentIds: this.events.length > 0
+                        ? [this.events[this.events.length - 1].id]
+                        : undefined,
+                }));
+                currentInferenceId = marker.id;
+                latestInferenceVisibleIds = new Set(this.events.map((event) => event.id));
+                await this.flushPersistence();
+                return marker.id;
+            };
+            const allTools = this.wrapToolsForGeneration(generationId, runtime.tools, preparations, completedPreparations, preparationErrors, ledger, () => this.buildContext(this.eventsByIds(latestInferenceVisibleIds)));
+            const flushReasoning = () => {
+                for (const [id, reasoningText] of reasoningTextById) {
+                    this.options.onReasoningEnd?.(id, reasoningText);
+                }
+                reasoningTextById.clear();
+            };
+            while (true) {
+                const remainingSteps = maxSteps - stepCount;
+                if (remainingSteps <= 0) {
+                    throw new Error(`Agent generation exhausted its ${maxSteps} step limit during retry.`);
+                }
+                let streamError;
+                try {
+                    currentInferenceId = undefined;
+                    const result = plugins.streamText({
+                        model: runtime.model,
+                        instructions: runtime.system,
+                        messages: this.getModelMessages(),
+                        allowSystemInMessages: true,
+                        tools: allTools,
+                        providerOptions: runtime.providerOptions,
+                        stopWhen: plugins.stepCountIs(remainingSteps),
+                        maxRetries: 0,
+                        abortSignal: combinedAbort.signal,
+                        prepareStep: async () => {
+                            await beginInference();
+                            return { messages: this.buildContext(this.eventsByIds(latestInferenceVisibleIds)) };
+                        },
+                        onError: ({ error }) => {
+                            streamError = error;
+                        },
+                        repairToolCall: async ({ toolCall, tools: availableTools, error }) => {
+                            const lowerName = toolCall.toolName.toLowerCase();
+                            if (lowerName !== toolCall.toolName
+                                && Object.prototype.hasOwnProperty.call(availableTools, lowerName)) {
+                                return { ...toolCall, toolName: lowerName };
+                            }
+                            return {
+                                ...toolCall,
+                                toolName: 'invalid',
+                                input: JSON.stringify({ tool: toolCall.toolName, error: String(error) }),
+                            };
+                        },
+                        onChunk: ({ chunk }) => {
+                            const chunkType = String(chunk.type ?? '');
+                            if (chunkType === 'text-delta') {
+                                const textChunk = chunk;
+                                this.options.onToken?.(textChunk.delta ?? textChunk.textDelta ?? textChunk.text ?? '');
+                                return;
+                            }
+                            if (chunkType === 'tool-result') {
+                                const toolResultChunk = chunk;
+                                if (toolResultChunk.preliminary === true) {
+                                    const previous = preliminaryToolOutputs.get(toolResultChunk.toolCallId);
+                                    if (!previous || !this.platform.isDeepEqual(previous.output, toolResultChunk.output)) {
+                                        const event = {
+                                            toolCallId: toolResultChunk.toolCallId,
+                                            toolName: toolResultChunk.toolName,
+                                            input: toolResultChunk.input,
+                                            output: toolResultChunk.output,
+                                        };
+                                        preliminaryToolOutputs.set(toolResultChunk.toolCallId, event);
+                                        this.options.onToolCallUpdate?.(event);
+                                    }
+                                }
+                                return;
+                            }
+                            const reasoningChunk = chunk;
+                            const id = reasoningChunk.id ?? 'reasoning';
+                            if (chunkType === 'reasoning-start') {
+                                reasoningTextById.set(id, '');
+                                this.options.onReasoningStart?.(id, reasoningChunk.providerMetadata);
+                            }
+                            else if (chunkType === 'reasoning-delta') {
+                                const delta = reasoningChunk.delta ?? reasoningChunk.textDelta ?? reasoningChunk.text ?? '';
+                                if (!reasoningTextById.has(id)) {
+                                    reasoningTextById.set(id, '');
+                                    this.options.onReasoningStart?.(id, reasoningChunk.providerMetadata);
+                                }
+                                reasoningTextById.set(id, (reasoningTextById.get(id) ?? '') + delta);
+                                this.options.onReasoningDelta?.(id, delta, reasoningChunk.providerMetadata);
+                            }
+                            else if (chunkType === 'reasoning-end') {
+                                const text = reasoningTextById.get(id) ?? '';
+                                reasoningTextById.delete(id);
+                                this.options.onReasoningEnd?.(id, text, reasoningChunk.providerMetadata);
+                            }
+                        },
+                        onToolExecutionStart: ({ toolCall }) => {
+                            const input = parseToolInput(toolCall.input);
+                            const signature = toolSignature(toolCall.toolName, input);
+                            const existing = preparations.get(toolCall.toolCallId);
+                            if (existing) {
+                                if (existing.signature !== signature) {
+                                    throw new Error(`Tool call id collision for "${toolCall.toolCallId}" in generation "${generationId}".`);
+                                }
+                                return existing.promise;
+                            }
+                            const promise = Promise.resolve().then(async () => {
+                                const startedBeforeInference = !currentInferenceId;
+                                const inferenceId = currentInferenceId ?? await beginInference();
+                                const approvalAssistantEvent = startedBeforeInference
+                                    ? [...this.events].reverse().find((candidate) => candidate.type === 'assistant-message'
+                                        && Array.isArray(candidate.content)
+                                        && candidate.content.some((part) => part.type === 'tool-call' && part.toolCallId === toolCall.toolCallId))
+                                    : undefined;
+                                let callEvent = [...this.events].reverse().find((event) => event.type === 'tool-call'
+                                    && event.toolCallId === toolCall.toolCallId
+                                    && (event.generationId === generationId
+                                        || (!!approvalAssistantEvent?.id
+                                            && event.parentIds?.includes(approvalAssistantEvent.id) === true)));
+                                if (callEvent && toolSignature(callEvent.toolName, callEvent.input) !== signature) {
+                                    throw new Error(`Tool call id collision for "${toolCall.toolCallId}" in generation "${generationId}".`);
+                                }
+                                if (!callEvent) {
+                                    callEvent = this.commitEvent(createAgentEvent({
+                                        type: 'tool-call',
+                                        toolCallId: toolCall.toolCallId,
+                                        toolName: toolCall.toolName,
+                                        input,
+                                        generationId,
+                                        inferenceId,
+                                        causationId: inferenceId,
+                                        parentIds: [inferenceId],
+                                    }));
+                                }
+                                await this.flushPersistence();
+                                recordToolCall(toolCalls, toolCallIndexes, toolCall);
+                                if (options.transaction) {
+                                    let intent = [...this.events].reverse().find((event) => event.type === 'tool-execution-intent'
+                                        && event.generationId === generationId
+                                        && event.toolCallId === toolCall.toolCallId);
+                                    if (intent && toolSignature(intent.toolName, intent.input) !== signature) {
+                                        throw new Error(`Tool call id collision for "${toolCall.toolCallId}" in generation "${generationId}".`);
+                                    }
+                                    if (!intent) {
+                                        intent = this.commitEvent(createAgentEvent({
+                                            type: 'tool-execution-intent',
+                                            generationId,
+                                            inferenceId: callEvent.inferenceId,
+                                            causationId: callEvent.id,
+                                            toolCallId: toolCall.toolCallId,
+                                            toolName: toolCall.toolName,
+                                            input,
+                                            parentIds: [callEvent.id],
+                                        }));
+                                    }
+                                    executionIntentIds.set(toolCall.toolCallId, intent.id);
+                                    await this.flushPersistence();
+                                }
+                                completedPreparations.add(toolCall.toolCallId);
+                                const callbackEvent = {
+                                    toolCallId: toolCall.toolCallId,
+                                    toolName: toolCall.toolName,
+                                    input,
+                                };
+                                this.options.onToolCallStart?.(callbackEvent);
+                                this.options.onToolCall?.(callbackEvent.toolName, callbackEvent.input);
+                            });
+                            preparations.set(toolCall.toolCallId, { signature, promise });
+                            void promise.catch((error) => {
+                                if (!completedPreparations.has(toolCall.toolCallId)) {
+                                    preparationErrors.set(toolCall.toolCallId, error);
+                                }
+                            });
+                            return promise;
+                        },
+                        onToolExecutionEnd: async (finish) => {
+                            preliminaryToolOutputs.delete(finish.toolCall.toolCallId);
+                            const inferenceId = currentInferenceId ?? await beginInference();
+                            const previousResult = this.currentGenerationEvent(generationId, 'tool-result', finish.toolCall.toolCallId);
+                            if (this.currentGenerationEvent(generationId, 'tool-result', finish.toolCall.toolCallId, inferenceId))
+                                return;
+                            const input = parseToolInput(finish.toolCall.input);
+                            const startEvent = {
+                                toolCallId: finish.toolCall.toolCallId,
+                                toolName: finish.toolCall.toolName,
+                                input,
+                            };
+                            const finishEvent = finish.toolOutput.type === 'tool-result'
+                                ? { ...startEvent, success: true, output: finish.toolOutput.output }
+                                : { ...startEvent, success: false, error: errorToString(finish.toolOutput.error) };
+                            const parentCall = this.currentGenerationEvent(generationId, 'tool-call', finish.toolCall.toolCallId, inferenceId);
+                            const toolWithModelOutput = allTools[finish.toolCall.toolName];
+                            const modelOutput = finishEvent.success && toolWithModelOutput?.toModelOutput
+                                ? await this.invokeGenerationCallback(() => toolWithModelOutput.toModelOutput({
+                                    toolCallId: finish.toolCall.toolCallId,
+                                    input,
+                                    output: finishEvent.output,
+                                }))
+                                : fallbackModelOutput(finishEvent.success ? finishEvent.output : undefined, finishEvent.success ? undefined : finishEvent.error);
+                            const executionIntentId = executionIntentIds.get(finish.toolCall.toolCallId);
+                            this.commitEvent(createAgentEvent({
+                                type: 'tool-result',
+                                toolCallId: finish.toolCall.toolCallId,
+                                toolName: finish.toolCall.toolName,
+                                ...(executionIntentId ? { executionIntentId } : {}),
+                                output: finishEvent.success ? finishEvent.output : undefined,
+                                error: finishEvent.success ? undefined : finishEvent.error,
+                                modelOutput,
+                                generationId,
+                                inferenceId,
+                                causationId: inferenceId,
+                                parentIds: parentCall ? [parentCall.id] : [inferenceId],
+                            }));
+                            await this.flushPersistence();
+                            recordToolCall(toolCalls, toolCallIndexes, finish.toolCall, finishEvent.success ? { output: finishEvent.output } : { error: finishEvent.error });
+                            if (previousResult)
+                                return;
+                            this.options.onToolCallFinish?.(finishEvent);
+                            this.options.onToolResult?.(finishEvent.toolName, finishEvent.success ? finishEvent.output : undefined);
+                        },
+                        onStepEnd: async (step) => {
+                            if (!currentInferenceId)
+                                throw new Error('Model step finished outside an inference.');
+                            if (!completedInferenceIds.has(currentInferenceId)) {
+                                completedInferenceIds.add(currentInferenceId);
+                                stepCount++;
+                            }
+                            totalInput += step.usage.inputTokens ?? 0;
+                            totalOutput += step.usage.outputTokens ?? 0;
+                            totalCacheRead += step.usage.inputTokenDetails.cacheReadTokens ?? 0;
+                            totalCacheWrite += step.usage.inputTokenDetails.cacheWriteTokens ?? 0;
+                            for (const toolCall of step.toolCalls) {
+                                recordToolCall(toolCalls, toolCallIndexes, toolCall);
+                            }
+                            for (const toolResult of step.toolResults) {
+                                recordToolCall(toolCalls, toolCallIndexes, toolResult, { output: toolResult.output });
+                            }
+                            for (const part of step.content) {
+                                if (part.type === 'tool-error') {
+                                    recordToolCall(toolCalls, toolCallIndexes, part, { error: part.error });
+                                }
+                            }
+                            this.commitResponseMessages(step.response.messages, generationId, currentInferenceId, executionIntentIds);
+                            await this.flushPersistence();
+                            attempt = 0;
+                            contextOverflowRetries = 0;
+                        },
+                    });
+                    const text = await result.text;
+                    const finishReason = await result.finishReason;
+                    await result.response;
+                    if (streamError)
+                        throw streamError;
+                    flushReasoning();
+                    await this.flushPersistence();
+                    const resultVisibleIds = new Set(latestInferenceVisibleIds);
+                    for (const event of this.events) {
+                        if (event.generationId === generationId)
+                            resultVisibleIds.add(event.id);
+                    }
+                    const generationResult = {
+                        text,
+                        messages: this.buildContext(this.eventsByIds(resultVisibleIds)),
+                        steps: stepCount,
+                        finishReason,
+                        usage: {
+                            inputTokens: totalInput,
+                            outputTokens: totalOutput,
+                            totalTokens: totalInput + totalOutput,
+                            cacheReadTokens: totalCacheRead,
+                            cacheWriteTokens: totalCacheWrite,
+                        },
+                        toolCalls,
+                        events: this.getEvents(),
+                    };
+                    await this.runEventRetentionLocked();
+                    generationResult.events = this.getEvents();
+                    completedResult = generationResult;
+                    return generationResult;
+                }
+                catch (error) {
+                    flushReasoning();
+                    const effectiveError = streamError ?? error;
+                    if (combinedAbort.signal.aborted) {
+                        throw combinedAbort.signal.reason ?? new DOMException('Aborted', 'AbortError');
+                    }
+                    if (effectiveError instanceof DOMException && effectiveError.name === 'AbortError') {
+                        throw effectiveError;
+                    }
+                    if (currentInferenceId
+                        && !completedInferenceIds.has(currentInferenceId)
+                        && this.events.some((event) => event.generationId === generationId
+                            && event.inferenceId === currentInferenceId
+                            && event.type === 'tool-result')) {
+                        completedInferenceIds.add(currentInferenceId);
+                        stepCount++;
+                    }
+                    if (isRetryableError(effectiveError) && attempt < MAX_RETRY_ATTEMPTS && stepCount < maxSteps) {
+                        attempt++;
+                        const errorWithHeaders = effectiveError;
+                        await sleep(retryDelay(attempt, errorWithHeaders.responseHeaders ?? errorWithHeaders.headers), combinedAbort.signal);
+                        continue;
+                    }
+                    if (isContextOverflow(effectiveError)) {
+                        if (!this.options.contextCompactor && !this.options.onContextOverflow) {
+                            throw new ContextOverflowError();
+                        }
+                        if (contextOverflowRetries >= maxContextOverflowRetries) {
+                            throw new ContextOverflowError(`Agent context overflow persisted after ${maxContextOverflowRetries} compaction retries`);
+                        }
+                        combinedAbort.signal.throwIfAborted();
+                        contextOverflowRetries++;
+                        await this.performCompaction('context-overflow', combinedAbort.signal);
+                        continue;
+                    }
+                    throw effectiveError;
+                }
+            }
+        }
+        catch (error) {
+            operationError = error;
+        }
+        finally {
+            let cleanupError;
+            if (leaseCleanupOwnership) {
+                try {
+                    await this.cleanupGenerationLease(leaseCleanupOwnership);
+                }
+                catch (error) {
+                    cleanupError = error;
+                }
+            }
+            if (operationError === undefined && combinedAbort.signal.aborted) {
+                operationError = combinedAbort.signal.reason
+                    ?? new DOMException('Aborted', 'AbortError');
+            }
+            let effectiveError = operationError !== undefined && cleanupError !== undefined
+                ? new AggregateError([operationError, cleanupError], 'Agent generation and generation lease cleanup both failed.')
+                : operationError ?? cleanupError;
+            try {
+                if (options.transaction && transactionExecutionStarted) {
+                    if (effectiveError === undefined && combinedAbort.signal.aborted) {
+                        effectiveError = combinedAbort.signal.reason
+                            ?? new DOMException('Aborted', 'AbortError');
+                    }
+                    try {
+                        if (effectiveError !== undefined) {
+                            await this.appendGenerationOutcome(generationId, 'interrupted', this.transactionOutcomeErrorReason(effectiveError));
+                        }
+                        else {
+                            const transaction = this.transaction(generationId);
+                            if (transaction.state !== 'execution-started') {
+                                throw new Error(`Transactional generation "${generationId}" cannot complete from state "${transaction.state}".`);
+                            }
+                            combinedAbort.signal.throwIfAborted();
+                            this.commitEvent(createAgentEvent({
+                                type: 'generation-execution-completed',
+                                generationId,
+                                parentIds: [transaction.executionStarted.id],
+                            }));
+                            await this.flushPersistence();
+                            if (combinedAbort.signal.aborted) {
+                                const abortError = combinedAbort.signal.reason
+                                    ?? new DOMException('Aborted', 'AbortError');
+                                await this.appendGenerationOutcome(generationId, 'interrupted', this.transactionOutcomeErrorReason(abortError));
+                                throw abortError;
+                            }
+                            if (completedResult)
+                                completedResult.events = this.getEvents();
+                        }
+                    }
+                    catch (outcomeError) {
+                        if (effectiveError !== undefined) {
+                            throw new AggregateError([effectiveError, outcomeError], 'Agent generation failed and its interrupted outcome could not be persisted.');
+                        }
+                        throw outcomeError;
+                    }
+                }
+                if (effectiveError !== undefined)
+                    throw effectiveError;
+            }
+            finally {
+                combinedAbort.cleanup();
+                if (this.currentGenerationAbortController === generationAbortController) {
+                    this.currentGenerationAbortController = undefined;
+                }
+            }
+        }
+        throw operationError ?? new Error('Agent generation ended without a result.');
+    }
+    abortCurrentGeneration(reason) {
+        this.currentGenerationAbortController?.abort(reason ?? new DOMException('Current agent generation aborted', 'AbortError'));
+    }
+    async abortSession(reason, options = {}) {
+        if (!this.sessionAbortController.signal.aborted) {
+            this.sessionAbortController.abort(reason ?? new DOMException('Agent session aborted', 'AbortError'));
+        }
+        this.abortCurrentGeneration(reason);
+        for (const key of [...this.scheduledGenerations.keys()]) {
+            this.cancelScheduledGeneration(key, reason ?? new DOMException('Agent session aborted', 'AbortError'));
+        }
+        if (options.abortBackgroundJobs) {
+            const jobs = this.options.executionContext?.jobs;
+            if (!jobs?.abort)
+                return;
+            const runningJobs = (await jobs.list()).filter((job) => job.state === 'running');
+            await Promise.all(runningJobs.map((job) => jobs.abort(job.executionId)));
+        }
+    }
+    async getBackgroundExecution(executionId) {
+        const jobs = this.options.executionContext?.jobs;
+        if (!jobs)
+            throw new Error('This AgentSession has no background job context.');
+        return jobs.get(executionId);
+    }
+    async abortBackgroundExecution(executionId) {
+        const jobs = this.options.executionContext?.jobs;
+        if (!jobs?.abort)
+            throw new Error('This AgentSession cannot abort background jobs.');
+        await jobs.abort(executionId);
+    }
+    async close() {
+        if (this.ownership.kind === 'exposed' && this.ownership.callbackScope.getStore()?.active) {
+            throw new Error('AgentSession.close() cannot be called from an active tool or compactor callback.');
+        }
+        this.closeFinalizationReached = false;
+        this.refreshCloseCleanupCompleted();
+        if (!this.closed) {
+            this.closed = true;
+            const closeReason = new DOMException('AgentSession closed', 'AbortError');
+            if (!this.sessionAbortController.signal.aborted) {
+                this.sessionAbortController.abort(closeReason);
+            }
+            this.abortCurrentGeneration(closeReason);
+            for (const key of [...this.scheduledGenerations.keys()]) {
+                this.cancelScheduledGeneration(key, closeReason);
+            }
+        }
+        let closeError;
+        const rememberCloseError = (error, message) => {
+            closeError = closeError === undefined
+                ? error
+                : new AggregateError([closeError, error], message);
+        };
+        try {
+            const unsubscribe = this.jobUnsubscribe;
+            unsubscribe?.();
+            this.jobUnsubscribe = undefined;
+        }
+        catch (error) {
+            rememberCloseError(error, 'AgentSession close encountered multiple cleanup errors.');
+        }
+        try {
+            await this.generationQueue;
+            for (const transaction of getOpenAgentGenerationTransactions(this.events)) {
+                await this.appendGenerationOutcome(transaction.generationId, 'interrupted', 'AgentSession closed before the transactional generation was finalized.');
+            }
+            if (this.retentionPromise)
+                await this.retentionPromise;
+            await this.flushPersistence();
+            if (this.maintenanceError !== undefined)
+                throw this.maintenanceError;
+        }
+        catch (error) {
+            rememberCloseError(error, 'AgentSession close encountered persistence or maintenance errors.');
+        }
+        finally {
+            for (const ownership of [...this.unresolvedLeaseCleanups]) {
+                try {
+                    await this.cleanupGenerationLease(ownership);
+                }
+                catch (error) {
+                    rememberCloseError(error, 'AgentSession close encountered multiple cleanup errors.');
+                }
+            }
+            this.generationHandles.clear();
+            try {
+                while (this.notificationDispatches.size > 0) {
+                    await Promise.all(this.notificationDispatches);
+                }
+            }
+            catch (error) {
+                rememberCloseError(error, 'AgentSession close encountered notification cleanup errors.');
+            }
+            const listenerStates = [...this.listeners.values()];
+            this.listeners.clear();
+            try {
+                await Promise.all(listenerStates
+                    .filter((state) => !state.executing && state.deliveryPromise)
+                    .map((state) => state.deliveryPromise));
+            }
+            catch (error) {
+                rememberCloseError(error, 'AgentSession close encountered listener cleanup errors.');
+            }
+            finally {
+                this.closeFinalizationReached = true;
+                this.refreshCloseCleanupCompleted();
+            }
+        }
+        if (closeError !== undefined)
+            throw closeError;
+    }
+    runInCallbackScope(state, callback) {
+        return this.ownership.kind === 'exposed'
+            ? this.ownership.callbackScope.run(state, callback)
+            : callback();
+    }
+    invokeGenerationCallback(callback) {
+        const state = { active: true };
+        return this.runInCallbackScope(state, () => {
+            try {
+                const result = callback();
+                return this.adoptGenerationCallbackResult(result, state);
+            }
+            catch (error) {
+                state.active = false;
+                throw error;
+            }
+        });
+    }
+    adoptGenerationCallbackResult(result, state) {
+        try {
+            if (isAsyncIterable(result)) {
+                return this.wrapGenerationCallbackIterable(result, state);
+            }
+            if (isPromiseLike(result)) {
+                return Promise.resolve(result).then((resolvedResult) => this.adoptGenerationCallbackResult(resolvedResult, state), (error) => {
+                    state.active = false;
+                    throw error;
+                });
+            }
+            state.active = false;
+            return result;
+        }
+        catch (error) {
+            state.active = false;
+            throw error;
+        }
+    }
+    wrapGenerationCallbackIterable(iterable, state) {
+        const iterator = this.runInCallbackScope(state, () => iterable[Symbol.asyncIterator]());
+        let settled = false;
+        const settle = () => {
+            if (settled)
+                return;
+            settled = true;
+            state.active = false;
+        };
+        const invoke = (operation) => {
+            let operationResult;
+            try {
+                operationResult = this.runInCallbackScope(state, () => Promise.resolve(operation()));
+            }
+            catch (error) {
+                settle();
+                return Promise.reject(error);
+            }
+            return operationResult.then((iteratorResult) => {
+                if (iteratorResult.done)
+                    settle();
+                return iteratorResult;
+            }, (error) => {
+                settle();
+                throw error;
+            });
+        };
+        const wrappedIterator = {
+            next: (...args) => invoke(() => iterator.next(...args)),
+            return: iterator.return
+                ? async (...args) => {
+                    let iteratorResult = await invoke(() => iterator.return(...args));
+                    while (!iteratorResult.done) {
+                        iteratorResult = await invoke(() => iterator.next());
+                    }
+                    return iteratorResult;
+                }
+                : async (...args) => {
+                    settle();
+                    return { done: true, value: args[0] };
+                },
+            throw: iterator.throw
+                ? (error) => invoke(() => iterator.throw(error))
+                : async (error) => {
+                    settle();
+                    throw error;
+                },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+        return wrappedIterator;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.sessionengine.js","sourceRoot":"","sources":["../ts_agent/classes.sessionengine.ts"],"names":[],"mappings":"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"}