@stratusagent/gateway 0.14.8 → 0.14.9

package/dist/recovery.js

@@ -0,0 +1,487 @@
+/*
+ * Restart recovery: the turns the last process left parked on a person or
+ * still running, the sub-sessions it orphaned, and how a repeated
+ * idempotency key settles against an unfinished item or a rollover's
+ * archived transcript. Moved out of `createGateway` in index.ts as is: the
+ * statements are unchanged, inside a factory that takes what they closed
+ * over there, and `createGateway` calls it where they were. The edits:
+ * `stopping`, `abortingWith` and `orphanedAtStart` are `let`s reassigned
+ * later, so they are read through `isStopping()`, `getAbortingWith()` and
+ * `getOrphanedAtStart()`, and `onSessionChain`, declared further down, is
+ * passed late-bound.
+ */
+import { completeAnsweredTurn, lastResponseIsAnswer, PENDING_APPROVAL_METADATA_KEY, readPendingApproval, recordTurnFailure, turnKeyOf, turnMessageOf, workItemState, } from '@stratusagent/core';
+import { delegatingSessionIdOf, isDelegatedSession, outstandingDelegationFor, SCHEDULE_ID_METADATA_KEY, } from '@stratusagent/agents';
+import { ABANDONED_TURN_ERROR, crossIdentityError, isSubAgentSession, ORPHANED_DELEGATION_ERROR, ROLLED_OVER_FROM_METADATA_KEY, ROLLOVER_REPEAT_WINDOW_MS, } from "./session-keys.js";
+import { FALLBACK_ACTIVE_METADATA_KEY } from '@stratusagent/state';
+export const createRecovery = ({ log, warn, bus, store, scheduler, effectiveApprovalTimeoutMs, refreshAgent, runtimeContextFor, runnerFor, withWatchdog, isStopping, trackTurn, untrackTurn, getAbortingWith, shutdownAbort, activeTurns, onTurnRuntime, getOrphanedAtStart, runtimeForAgent, watchdogStreamsFor, reachesHarness, onSessionChain, }) => {
+    /**
+     * Finishes the turns that were parked on a human when this daemon last
+     * went down.
+     *
+     * Run after the channels are up, deliberately: recovery re-asks, and a
+     * request emitted into a gateway with no live adapter would be declined
+     * for want of anywhere to put it — turning "your approval survived the
+     * restart" into "your approval was denied by the restart".
+     *
+     * Each session is recovered independently and failures are per-session:
+     * one unrecoverable turn must not stop the daemon from serving, or from
+     * recovering the others.
+     */
+    const recoverParkedTurns = async (orphaned) => {
+        if (!store.listIdsByStatus) {
+            return;
+        }
+        const parked = await store.listIdsByStatus('pending_approval');
+        if (parked.length === 0) {
+            return;
+        }
+        log(`recovering ${parked.length} turn(s) parked on approval`);
+        // Started together, not one after another. Each recovery re-asks and
+        // then waits on a human, so awaiting them in sequence would mean the
+        // second parked turn is not even *announced* until the first is
+        // answered — fifteen minutes later by default, and never at all with a
+        // zero timeout. They are independent turns; only same-session work is
+        // ordered, and onSessionChain already guarantees that.
+        await Promise.allSettled(parked.map((sessionId) => recoverOne(sessionId, orphaned.has(sessionId))));
+    };
+    /**
+     * The parked sub-sessions whose delegating turn the last process was
+     * still inside — read BEFORE the channels start, for the same reason the
+     * abandoned list is.
+     *
+     * The proof is the parent's transcript: only the runner writes an
+     * assistant `agent.delegate` call, and only a delegation in flight leaves
+     * one with no result behind it. That evidence does not survive contact
+     * with a channel, though — a message for the parent arriving once the
+     * adapters are up resumes it, and the resume closes the dangling call as
+     * interrupted. Read live from the sweep, the parent would then look as if
+     * it awaited nothing and the child would be re-asked after all, which is
+     * the bug this exists to stop. So it is read while nothing can dispatch,
+     * and the sweep judges from the snapshot; a child whose parent is missing
+     * or not inside such a call is left to ordinary recovery.
+     *
+     * Matched call by call, not parent by parent: the call that awaits a
+     * child names it (see `outstandingDelegationFor`), and a call can await
+     * only one. Two parked children claiming the same call — one of them a
+     * sub-session continued from outside under a version that kept its
+     * markers, parked again on something of its own — is an ambiguity this
+     * cannot settle, and both are left to ordinary recovery rather than one
+     * of them being failed for a delegation that was never its.
+     */
+    const listOrphanedDelegations = async () => {
+        const claimants = new Map();
+        if (!store.listIdsByStatus) {
+            return new Set();
+        }
+        for (const sessionId of await store.listIdsByStatus('pending_approval')) {
+            const parentId = delegatingSessionIdOf(sessionId);
+            if (parentId === undefined) {
+                continue;
+            }
+            const session = await store.get(sessionId);
+            if (!session || !isDelegatedSession(session)) {
+                continue;
+            }
+            const parent = await store.get(parentId);
+            const callId = parent ? outstandingDelegationFor(parent, session) : undefined;
+            if (callId !== undefined) {
+                const key = `${parentId}\u0000${callId}`;
+                claimants.set(key, [...(claimants.get(key) ?? []), sessionId]);
+            }
+        }
+        return new Set([...claimants.values()].filter((ids) => ids.length === 1).map(([id]) => id));
+    };
+    const recoverOne = (sessionId, orphaned) => onSessionChain(sessionId, () => recoverParked(sessionId, orphaned));
+    /**
+     * `recoverOne`'s work, for a caller already on the session's chain: a
+     * repeated idempotency key that reached the chain before the parked sweep
+     * did, and would otherwise wait on a turn nothing is running yet.
+     */
+    const recoverParked = async (sessionId, orphaned) => {
+        if (isStopping()) {
+            return;
+        }
+        try {
+            const session = await store.get(sessionId);
+            if (!session) {
+                return;
+            }
+            const record = readPendingApproval(session);
+            // A delegated sub-session is only ever awaited by its parent's
+            // `agent.delegate` call, and that parent was running when the last
+            // process died — it is in the abandoned sweep, not in this one.
+            // Nothing will read the reply, so the parked call is not re-asked:
+            // a person would be approving a command that runs for no one.
+            //
+            // Judged on the re-read, on the chain: the channels are up before
+            // this sweep starts, so a message for this id can have taken the
+            // chain first and moved the session on — and a turn that finished
+            // normally must not be rewritten as failed. The delegation metadata
+            // is durable, so it proves what the session is, not what state it
+            // is in; the status and the checkpoint say that.
+            //
+            // Whether it IS an orphan was decided before the channels started
+            // (`listOrphanedDelegations`), from the parent's transcript, which
+            // a message arriving since may already have rewritten.
+            // A sub-agent never parks (nobody is asked for it), and if one ever
+            // did, its parent's turn died with the last process: nothing would
+            // read its answer, and recovering it would run it as the full agent.
+            if (isSubAgentSession(session) && session.status === 'pending_approval') {
+                log(`${sessionId}: a sub-agent parked when the last stratusd stopped; failing it`);
+                await failParked(session, ABANDONED_TURN_ERROR);
+                return;
+            }
+            if (orphaned && isDelegatedSession(session) && session.status === 'pending_approval' && record) {
+                log(`${sessionId}: parked on ${record.call.toolName} for a delegating turn the last stratusd was still running; failing it`);
+                await failOrphanedDelegation(session);
+                return;
+            }
+            // A wait that outlived its window while the daemon was down is
+            // honoured, not restarted: the request really did go unanswered for
+            // the whole time it was configured to wait, and downtime is not a
+            // reason to extend a security decision. Measured from when the turn
+            // parked against this daemon's timeout — the transport's original
+            // deadline was chosen after the checkpoint was written and is gone
+            // with the process that chose it. Denying goes through the same
+            // recovery path, so the queue behind it still drains.
+            const parkedAt = record ? Date.parse(record.parkedAt) : Number.NaN;
+            const expired = effectiveApprovalTimeoutMs > 0
+                && Number.isFinite(parkedAt)
+                && Date.now() - parkedAt >= effectiveApprovalTimeoutMs;
+            if (expired) {
+                log(`${sessionId}: the approval for ${record?.call.toolName} outlived its window while the daemon was down; denying it`);
+            }
+            // Resolved the way a dispatch for this agent would resolve it, so a
+            // recovered turn finishes on the same provider, model, and
+            // credentials it was parked on.
+            const source = await refreshAgent(session.agent.id);
+            // And on the CURRENT definition, saved before recovery reads the
+            // session back. An allowlist is a permission boundary: a soul that
+            // dropped a tool while the daemon was down must not have that tool
+            // executed by the turn that outlived the change, and
+            // `allowedToolsFor` reads the definition frozen into the session
+            // ahead of the registry. Dispatch refreshes it the same way before
+            // resuming.
+            session.agent = source.definition;
+            await store.save(session);
+            const recoveredConfig = await runtimeForAgent(source);
+            const runner = runnerFor(recoveredConfig, source.definition.id);
+            // Tracked like a dispatched turn's controller: a recovered turn that
+            // runs on past its approval is a turn like any other, so a restart's
+            // window has to be able to cut it short with the same reason (or it
+            // runs unseen to the second window and the restart reports
+            // undrained), and a stop for the session has to find it. Only once
+            // the checkpoint has been read on this chain, right before the runner
+            // takes it: a stop counted then always ends in the turn's own
+            // outcome. A stop sent during the reads above finds nothing running
+            // and reaches the session as an ordinary message, queued behind it.
+            const controller = new AbortController();
+            if (record) {
+                trackTurn(sessionId, controller);
+                if (getAbortingWith() !== undefined) {
+                    controller.abort(shutdownAbort());
+                }
+            }
+            try {
+                await onTurnRuntime(sessionId, { source, config: recoveredConfig }, () => runner.recoverPendingApproval(sessionId, {
+                    denyPending: expired,
+                    runtime: runtimeContextFor(source, recoveredConfig, session.metadata?.[FALLBACK_ACTIVE_METADATA_KEY] === true, session.metadata),
+                    signal: controller.signal,
+                }));
+            }
+            finally {
+                untrackTurn(sessionId, controller);
+                // A recovered firing's row outlived the process that would have
+                // retired it, and the firing is over either way — a recovery that
+                // failed has durably failed its session, which is as finished as
+                // completing. The scheduler decides whether there is a row to
+                // retire, and only this firing's own.
+                const scheduleId = session.metadata?.[SCHEDULE_ID_METADATA_KEY];
+                if (typeof scheduleId === 'string') {
+                    scheduler.retireSpentOneShot(scheduleId, sessionId);
+                }
+            }
+        }
+        catch (error) {
+            warn(`could not recover parked session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+            // A keyed item is a promise to its caller, and one whose recovery
+            // cannot even start (its agent gone, its provider unresolvable) would
+            // otherwise stay parked for every later start and redelivery to try
+            // again. An unkeyed one keeps waiting for a sweep that can, as before.
+            const after = await store.get(sessionId).catch(() => undefined);
+            const key = after === undefined ? undefined : turnKeyOf(turnMessageOf(after));
+            if (after !== undefined && key !== undefined && after.status === 'pending_approval' && workItemState(after, key) === 'unfinished') {
+                await failParked(after, ABANDONED_TURN_ERROR).catch(() => { });
+            }
+        }
+    };
+    /**
+     * Closes an orphaned sub-session the way the abandoned sweep closes its
+     * parent: durably failed, with the checkpoint retired so no later sweep
+     * can find a call to re-enter, and announced where surfaces can hear it.
+     */
+    const failOrphanedDelegation = (session) => failParked(session, ORPHANED_DELEGATION_ERROR);
+    const failParked = async (session, error) => {
+        const metadata = { ...(session.metadata ?? {}) };
+        delete metadata[PENDING_APPROVAL_METADATA_KEY];
+        session.metadata = metadata;
+        recordTurnFailure(session, error);
+        await store.save(session);
+        await bus.emit({ type: 'session.updated', sessionId: session.id, status: 'failed' });
+        await bus.emit({ type: 'session.failed', sessionId: session.id, error });
+    };
+    /**
+     * Turns the last process was still running when it stopped being able to
+     * finish them.
+     *
+     * `pending_approval` is the one window a turn can be picked up from, and
+     * it has its own sweep above. Everything else a turn does is saved as
+     * `running`: the provider call, the executor, and — on a provider that
+     * hosts its own loop — the approval wait too, since a hosted call is
+     * deliberately not checkpointed (`executeHostedToolCall` passes
+     * `recoverable: false`, because the SDK's inner loop is not something a
+     * restart can rebuild). None of those can be re-entered where they
+     * stopped, and nothing else sweeps them, so the record would go on
+     * claiming the turn is running for as long as the session exists. A turn
+     * whose caller gave it an idempotency key is continued from its
+     * transcript instead, with its dangling calls closed as interrupted
+     * (`settleAbandonedTurn`); the rest are failed.
+     *
+     * Note what this is *not* for. A graceful stop denies everything parked
+     * and drains the turns those denials release, so an operator restarting
+     * the daemon normally has nothing here. These are the turns a crash, a
+     * SIGKILL, or a lost machine left behind.
+     */
+    const listAbandonedTurns = async () => {
+        if (!store.listIdsByStatus) {
+            return [];
+        }
+        return store.listIdsByStatus('running');
+    };
+    /**
+     * Settles each of them — continued if keyed, otherwise marked failed with
+     * a reason that says what happened.
+     *
+     * Read BEFORE the channels start and applied after, which is the only
+     * ordering that is both honest and safe. Reading first means the list is
+     * exactly what the last process left, with no chance of a turn this
+     * process started being in it. Applying after means the failure is
+     * emitted into a gateway whose surfaces are listening, rather than into
+     * one where nothing is.
+     *
+     * The gap between the two is real, though: an inbound message for one of
+     * these sessions can arrive as soon as the channels are up. What makes
+     * that safe is single-flight — every writer of a session goes through
+     * `onSessionChain`, so this runs either wholly before that turn (it
+     * fails, and `resume()` then clears `lastError` and starts fresh) or
+     * wholly after it (the status has moved off `running`, and the re-read
+     * below leaves it alone). There is no interleaving in which this
+     * overwrites a live turn.
+     *
+     * What that invariant does NOT cover is a second daemon on the same
+     * database, whose turns are running with no chain of ours in front of
+     * them. Two processes sharing a session store is already unsupported —
+     * the parked sweep above would re-ask that daemon's approvals for the
+     * same reason — and no check here would make it supported.
+     */
+    const failAbandonedTurns = async (abandoned) => {
+        if (abandoned.length === 0) {
+            return;
+        }
+        log(`settling ${abandoned.length} turn(s) left running by the last stratusd`);
+        await Promise.allSettled(abandoned.map((id) => failAbandonedTurn(id)));
+    };
+    const failAbandonedTurn = (id) => onSessionChain(id, async () => {
+        if (isStopping()) {
+            return;
+        }
+        try {
+            const session = await store.get(id);
+            // Re-read on the chain, because the snapshot is from before the
+            // channels came up: a message that arrived since has already taken
+            // this session somewhere else, and that turn owns it now.
+            if (!session || session.status !== 'running') {
+                return;
+            }
+            await settleAbandonedTurn(session);
+        }
+        catch (error) {
+            warn(`could not settle abandoned turn ${id}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+    /**
+     * A turn left `running` with nothing running it, read on its chain.
+     *
+     * One whose message carries an idempotency key is a work item its caller
+     * was promised would finish, so it is continued from the transcript
+     * (`AgentRunner.continueTurn`) — once. A turn that already was, and is
+     * here again, took the last process down with it, and continuing it again
+     * would do the same on every start; it is failed like an unkeyed one,
+     * whose caller was never promised anything and is told to send again.
+     */
+    const settleAbandonedTurn = async (session) => {
+        const message = turnMessageOf(session);
+        if (message === undefined || turnKeyOf(message) === undefined) {
+            return failAbandoned(session);
+        }
+        // An answer already in the transcript is completed whatever came before
+        // — a second crash, a harness, an agent or provider gone since —
+        // because completing it needs none of them and runs nothing again;
+        // failing it would throw away a finished reply.
+        if (lastResponseIsAnswer(session)) {
+            log(`${session.id}: a keyed turn the last stratusd was running had saved its answer; completing it`);
+            return completeAnsweredTurn(session, store, bus);
+        }
+        if (message.continuedAfterCrash === true) {
+            return failAbandoned(session);
+        }
+        if (message.hostedLoop === true) {
+            log(`${session.id}: a keyed turn the last stratusd was running could reach a harness, which cannot be continued; failing it`);
+            return failAbandoned(session);
+        }
+        return continueAbandonedTurn(session);
+    };
+    const failAbandoned = async (session) => {
+        recordTurnFailure(session, ABANDONED_TURN_ERROR);
+        await store.save(session);
+        await bus.emit({ type: 'session.updated', sessionId: session.id, status: 'failed' });
+        await bus.emit({ type: 'session.failed', sessionId: session.id, error: ABANDONED_TURN_ERROR });
+        return session;
+    };
+    /**
+     * Continues an abandoned turn on the configuration a dispatch for its
+     * agent would resolve now, and under the same watchdog — it is a provider
+     * call like any turn's. The definition is refreshed and saved first, as
+     * `recoverOne` does and for the same reason: an allowlist is a permission
+     * boundary, and a tool dropped while the daemon was down must not run.
+     *
+     * Not on a harness (`runsOnHarness`) — neither one the turn could have
+     * run on (`Message.hostedLoop`, recorded when it was accepted) nor one it
+     * would continue on. A harness runs its own tool loop inside a single
+     * provider call and keeps its own conversation, so the prompt the dead
+     * turn sent may already have run tools there that the transcript never
+     * saw, and continuing would send it again. That turn is failed as an
+     * unkeyed one is — the same answer as before keys existed. (A turn whose
+     * answer is already saved never gets here: `settleAbandonedTurn`
+     * completes it first.)
+     */
+    const continueAbandonedTurn = async (session) => {
+        // Its parent's turn died with the last process, and continuing it here
+        // would run it as the full agent. (Sub-agent turns carry no key today,
+        // so this is a guard, not a path.)
+        if (isSubAgentSession(session)) {
+            return failAbandoned(session);
+        }
+        // Settled either way: a turn whose agent left the roster, or whose
+        // provider no longer resolves, must not stay `running` for every later
+        // start and every redelivery to find unfinished and trip over again.
+        let source;
+        let config;
+        try {
+            source = await refreshAgent(session.agent.id);
+            config = await runtimeForAgent(source);
+        }
+        catch (error) {
+            log(`${session.id}: a keyed turn the last stratusd was running cannot be continued (${error instanceof Error ? error.message : String(error)}); failing it`);
+            return failAbandoned(session);
+        }
+        const { switchedToFallback, effectiveStreams, fallbackStreams } = watchdogStreamsFor(session, config);
+        // The message's own record covers the runtimes the turn could have run
+        // on; this covers the ones it would continue on — a fallback included —
+        // which a changed config may make a harness.
+        if (reachesHarness(config, switchedToFallback)) {
+            log(`${session.id}: a keyed turn the last stratusd was running would continue on a harness; failing it`);
+            return failAbandoned(session);
+        }
+        log(`${session.id}: continuing a keyed turn the last stratusd was still running`);
+        session.agent = source.definition;
+        await store.save(session);
+        const runner = runnerFor(config, source.definition.id);
+        return onTurnRuntime(session.id, { source, config }, () => withWatchdog(session.id, undefined, effectiveStreams, fallbackStreams, async (signal) => await runner.continueTurn(session.id, {
+            runtime: runtimeContextFor(source, config, switchedToFallback, session.metadata),
+            signal,
+        }) ?? session));
+    };
+    /**
+     * A repeated idempotency key that reached the session's chain, so nothing
+     * else is running on the session. `undefined` means the key is new here
+     * and the dispatch runs as any other; otherwise this is the session to
+     * resolve with, and no new turn starts.
+     *
+     * An unfinished item here has no live turn — the live map would have
+     * answered first — so it is one the last process left, reached before
+     * the start-up sweep that would have settled it: settled now, the way
+     * that sweep would, which then finds it no longer needs anything.
+     */
+    const settleRepeat = async (sessionId, idempotencyKey, agentId, turnId, onRepeat) => {
+        const session = await store.get(sessionId);
+        if (session === undefined) {
+            return undefined;
+        }
+        // Before anything is returned: the turn a dispatch would run is refused
+        // for naming another agent, and the one it would repeat is no less that
+        // agent's — a repeat is not a way to read its transcript.
+        if (agentId !== undefined && session.agent.id !== agentId) {
+            throw crossIdentityError(sessionId, session.agent.id, agentId);
+        }
+        const state = workItemState(session, idempotencyKey);
+        if (state === undefined) {
+            const archived = await archivedRepeat(session, idempotencyKey);
+            if (archived !== undefined) {
+                onRepeat?.('finished');
+            }
+            return archived;
+        }
+        if (state === 'finished') {
+            onRepeat?.('finished');
+            return session;
+        }
+        // Run now, on this caller's behalf, so its events are this caller's
+        // turn — the adapter waiting on them has no other way to claim them.
+        if (turnId !== undefined) {
+            activeTurns.set(sessionId, turnId);
+        }
+        try {
+            return await settleUnfinished(session);
+        }
+        finally {
+            if (turnId !== undefined) {
+                activeTurns.delete(sessionId);
+            }
+        }
+    };
+    /**
+     * The archived transcript holding a key the live row does not, when the
+     * row is a rollover's fresh one made inside `ROLLOVER_REPEAT_WINDOW_MS`.
+     * Only the one rollover back: a second inside the window is a redelivery
+     * outliving two deliberate resets, and the chain is not walked for it.
+     * Always finished — a rollover refuses a session with a turn in flight.
+     */
+    const archivedRepeat = async (session, idempotencyKey) => {
+        const archivedAs = session.metadata?.[ROLLED_OVER_FROM_METADATA_KEY];
+        if (typeof archivedAs !== 'string' || Date.now() - Date.parse(session.createdAt) > ROLLOVER_REPEAT_WINDOW_MS) {
+            return undefined;
+        }
+        const archived = await store.get(archivedAs);
+        return archived !== undefined && workItemState(archived, idempotencyKey) !== undefined ? archived : undefined;
+    };
+    /** An unfinished item with no live turn, settled the way the start-up sweeps would. */
+    const settleUnfinished = async (session) => {
+        if (session.status === 'pending_approval') {
+            await recoverParked(session.id, getOrphanedAtStart().has(session.id));
+            return (await store.get(session.id)) ?? session;
+        }
+        return settleAbandonedTurn(session);
+    };
+    return {
+        recoverParkedTurns,
+        listOrphanedDelegations,
+        listAbandonedTurns,
+        failAbandonedTurns,
+        settleRepeat,
+        archivedRepeat,
+        settleUnfinished,
+    };
+};
+//# sourceMappingURL=recovery.js.map

package/dist/recovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.js","sourceRoot":"","sources":["../src/recovery.ts"],"names":[],"mappings":"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"}

package/dist/steering.d.ts

@@ -0,0 +1,24 @@
+import { type Session, type SteeredMessage } from '@stratusagent/core';
+import { type MergeBatch, type MergeJoiner } from './merge-batch.ts';
+import type { ShardedSessionStore } from './sessions.ts';
+import type { Recovery } from './recovery.ts';
+/** What steering closes over in `createGateway`. */
+export interface SteeringDeps extends Pick<Recovery, 'archivedRepeat'> {
+    log: (line: string) => void;
+    store: ShardedSessionStore;
+    releaseQueued: (sessionId: string) => void;
+    waitingDispatches: Map<string, number>;
+    isStopping: () => boolean;
+    liveWorkItems: Map<string, Map<string, {
+        turn: Promise<Session>;
+        agentId: string | undefined;
+        confirmed: boolean;
+        addressed: boolean;
+    }>>;
+    openBatches: Map<string, MergeBatch>;
+}
+export declare const createSteering: ({ log, store, releaseQueued, waitingDispatches, isStopping, liveWorkItems, openBatches, archivedRepeat, }: SteeringDeps) => {
+    takeSteered: (sessionId: string, agentId: string | undefined, into: MergeJoiner[], admit: (parts: readonly MergeJoiner[]) => boolean) => Promise<SteeredMessage | undefined>;
+};
+export type Steering = ReturnType<typeof createSteering>;
+//# sourceMappingURL=steering.d.ts.map

package/dist/steering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steering.d.ts","sourceRoot":"","sources":["../src/steering.ts"],"names":[],"mappings":"AASA,OAAO,EAKL,KAAK,OAAO,EACZ,KAAK,cAAc,EAEpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,KAAK,UAAU,EAAoB,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,oDAAoD;AACpD,MAAM,WAAW,YAAa,SAAQ,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpE,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,KAAK,EAAE,mBAAmB,CAAC;IAC3B,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAC3C,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,UAAU,EAAE,MAAM,OAAO,CAAC;IAC1B,aAAa,EAAE,GAAG,CAChB,MAAM,EACN,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,SAAS,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC,CAC7G,CAAC;IACF,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACtC;AAED,eAAO,MAAM,cAAc,GAAI,2GAS5B,YAAY;6BAeA,MAAM,WACR,MAAM,GAAG,SAAS,QACrB,WAAW,EAAE,SAOZ,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,KAAK,OAAO,KAChD,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC;CA6EvC,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/steering.js

@@ -0,0 +1,108 @@
+/*
+ * What a running turn takes in at its next tool step (card 948): the merged
+ * batch waiting behind it. Moved out of `createGateway` in index.ts as is:
+ * the statement is unchanged, inside a factory that takes what it closed
+ * over there, and `createGateway` calls it where it was. The one kind of
+ * edit: `stopping` is a `let` set at shutdown, so it is read through
+ * `isStopping()`.
+ */
+import { abortErrorFor, leastTrusted, SENDER_TRUST_METADATA_KEY, senderTrustOf, workItemState, } from '@stratusagent/core';
+import { MERGED_SEPARATOR } from "./merge-batch.js";
+export const createSteering = ({ log, store, releaseQueued, waitingDispatches, isStopping, liveWorkItems, openBatches, archivedRepeat, }) => {
+    /**
+     * What a running turn takes in at its next tool step (card 948): the
+     * merged-turn batch waiting behind it, whole — leader and absorbed alike
+     * — when it is for the same agent. The dispatches it takes join `into`,
+     * which the running turn settles with its own outcome (`runSteerable`).
+     *
+     * A part cancelled while it waited is refused, as `runMerged` refuses it.
+     * A part whose key this session (or the archive it rolled over from)
+     * already holds is a repeat, and judging a repeat can mean settling a
+     * turn — never something to do from inside one — so such a batch is not
+     * taken: it waits and runs next, merged, where that is judged. Nor while
+     * the gateway is stopping, when the batch is what the drain refuses.
+     */
+    const takeSteered = async (sessionId, agentId, into, 
+    /**
+     * Asked last, with nothing awaited after it: whether the running turn
+     * still takes these callers, joining them to its cancellation if so. A
+     * turn cancelled while the store was read takes nothing, and the batch
+     * waits and runs next, as it would have.
+     */
+    admit) => {
+        const batch = openBatches.get(sessionId);
+        if (isStopping() || batch === undefined || !batch.firstInLine || batch.agentId !== agentId) {
+            return undefined;
+        }
+        // Until every key in it is checked with nothing awaited since: a message
+        // can join while the store is read, and is checked on the next pass; a
+        // batch closed meanwhile is no longer this turn's to take.
+        const checked = new Set();
+        let session;
+        for (;;) {
+            if (isStopping() || openBatches.get(sessionId) !== batch) {
+                return undefined;
+            }
+            const unchecked = [batch.leader, ...batch.absorbed].flatMap((part) => (part.input.idempotencyKey !== undefined && !checked.has(part.input.idempotencyKey) ? [part.input.idempotencyKey] : []));
+            if (unchecked.length === 0) {
+                break;
+            }
+            session ??= await store.get(sessionId);
+            for (const key of unchecked) {
+                checked.add(key);
+                if (session !== undefined && (workItemState(session, key) !== undefined || await archivedRepeat(session, key) !== undefined)) {
+                    return undefined;
+                }
+            }
+        }
+        const all = [batch.leader, ...batch.absorbed];
+        if (!admit(all.filter((part) => part.input.signal?.aborted !== true))) {
+            return undefined;
+        }
+        openBatches.delete(sessionId);
+        batch.steered = true;
+        // Its place on the chain runs nothing now, so it is not ahead of a batch
+        // opening behind it, which can then be steered at a later step.
+        releaseQueued(sessionId);
+        // Not waiting any more; the leader's place on the chain does not count it again.
+        const left = (waitingDispatches.get(sessionId) ?? all.length) - all.length;
+        if (left > 0) {
+            waitingDispatches.set(sessionId, left);
+        }
+        else {
+            waitingDispatches.delete(sessionId);
+        }
+        const runnable = [];
+        for (const part of all) {
+            if (part.input.signal?.aborted) {
+                part.reject(abortErrorFor(part.input.signal));
+                continue;
+            }
+            runnable.push(part);
+        }
+        if (runnable.length === 0) {
+            return undefined;
+        }
+        const keys = runnable.flatMap((part) => (part.input.idempotencyKey !== undefined ? [part.input.idempotencyKey] : []));
+        const items = liveWorkItems.get(sessionId);
+        for (const key of keys) {
+            const item = items?.get(key);
+            if (item !== undefined) {
+                item.confirmed = true;
+            }
+        }
+        into.push(...runnable);
+        const labelled = runnable.some((part) => part.input.metadata !== undefined && SENDER_TRUST_METADATA_KEY in part.input.metadata);
+        const lowest = leastTrusted(...runnable.map((part) => senderTrustOf(part.input.metadata)));
+        const images = runnable.flatMap((part) => part.input.images ?? []);
+        log(`${sessionId}: ${runnable.length} message(s) sent during the running turn reached it at its next step`);
+        return {
+            userMessage: runnable.map((part) => part.input.userMessage).join(MERGED_SEPARATOR),
+            ...(images.length > 0 ? { images } : {}),
+            ...(labelled ? { metadata: { [SENDER_TRUST_METADATA_KEY]: lowest } } : {}),
+            ...(keys.length > 0 ? { keys } : {}),
+        };
+    };
+    return { takeSteered };
+};
+//# sourceMappingURL=steering.js.map