@nocobase/app-plugin-agents 0.0.0-stage → 0.1.0-beta.10

package/dist/server/core/runs/run.service.js

@@ -0,0 +1,813 @@
+/**
+ * Runs as the rest of the application starts and follows them: queueing work for an agent, adding input to a run,
+ * cancelling and retrying, and reading runs and their transcripts. Who may read or change a run is decided by the
+ * callers (the admin routes, the application); this service checks only that the person who wakes an agent may wake it.
+ *
+ * Work is keyed by (agent, subject, thread). New work for a key joins the run already working on it as the same person
+ * while it can still be told (dispatched, or running with input), else that person's run waiting for it (queued), else
+ * starts a new run. Runs of one key working as different people are claimed one at a time (`claim.ts`).
+ */
+import { ProtocolError, TERMINAL_RUN_STATUSES, } from '@nocobase/agent-protocol';
+import { conflict, forbidden, invalid, notFound, precondition, } from '../../kernel/errors.js';
+import { asJson, cleanList, jsonObject } from '../../kernel/values.js';
+import { findAgent, lockAgentForClaim } from '../agents/index.js';
+import { agentNamesOf } from '../agents/agent.store.js';
+import { createRunRequestService, insertRunRequest, } from './run-requests.js';
+import { authenticateRunToken } from './run-tokens.js';
+import { ACTIVE, eventsRepo, findRunRecord, inputsOnSince, inputsRepo, isActive, isTerminal, lastSummary, openRunsOn, pendingInputs, reposRepo, runsOfKey, runsRepo, toInput, toInputView, toRepo, toRun, usageRepo, } from './run.store.js';
+import { readWorkload } from './workload.js';
+import { finishRun } from './transitions.js';
+import { gateInputs, gatePending } from './input-gate.js';
+import { findBrief, requestReset } from './workspace.store.js';
+export const DEFAULT_THREAD = 'main';
+/**
+ * The run work went into, for a caller that names no responsible (a conversation, a consultation): such work is never
+ * pending, so a pending result is a programming error.
+ */
+export function queuedRun(result) {
+    if (result.outcome === 'pending')
+        throw new Error('Work that names no responsible was turned into a run request.');
+    return result;
+}
+/** Who a chain of work a run belongs to started with: who confirmed it, else who it was requested by. */
+function chainSourceOf(run) {
+    return run.confirmedByUserId ?? run.requestedByUserId ?? run.actorUserId;
+}
+/** A delay as the moment a run may be claimed, or null for now (and for any moment already past). */
+function fireAtOf(value, now) {
+    if (value === undefined)
+        return null;
+    const at = typeof value === 'string' ? new Date(value) : value;
+    if (Number.isNaN(at.getTime()))
+        throw invalid('fireAt is not a date.');
+    return at.getTime() > now.getTime() ? at.toISOString() : null;
+}
+export function createRunService(deps) {
+    const { tx, ids, clock } = deps;
+    const require = async (conn, id) => {
+        const run = await findRunRecord(conn, id);
+        if (!run)
+            throw notFound('Run');
+        return run;
+    };
+    async function insertInput(unit, runId, input) {
+        const id = ids.next();
+        await inputsRepo(unit.conn).createOne({
+            values: {
+                id,
+                runId,
+                type: input.type,
+                actorKind: input.actor.kind,
+                actorId: input.actor.id,
+                actorName: input.actor.name,
+                text: input.text,
+                payload: asJson(input.payload),
+                createdAt: clock.now().toISOString(),
+                deliveredAt: null,
+                handledAt: null,
+            },
+        });
+        unit.emit({ type: 'run.input', runId, inputId: id });
+        await runsRepo(unit.conn).updateMany({
+            filter: { id: runId, status: 'queued' },
+            // New input may change the scopes its variables come from: the next claim tells again.
+            values: { teamOnlyVariables: null },
+        });
+        return id;
+    }
+    async function requireInvocable(unit, agentId, userId) {
+        const agent = await findAgent(unit.conn, agentId);
+        if (!agent)
+            throw notFound('Agent');
+        if (agent.status !== 'enabled')
+            throw precondition('AGENT_NOT_ENABLED', 'The agent is not enabled.');
+        if (!deps.agents.mayInvoke(agent, userId))
+            throw forbidden('You may not wake this agent.');
+        return agent;
+    }
+    async function createRun(unit, agent, values) {
+        const now = clock.now().toISOString();
+        const id = ids.next();
+        await runsRepo(unit.conn).createOne({
+            values: {
+                id,
+                agentId: agent.id,
+                agentType: 'runner',
+                runnerId: null,
+                status: 'queued',
+                priority: values.priority,
+                attempt: 1,
+                maxAttempts: values.maxAttempts ?? agent.maxAttempts,
+                retryOfRunId: values.retryOfRunId,
+                freshSession: values.freshSession === true,
+                parentRunId: values.parentRunId ?? null,
+                subjectKind: values.subject.kind,
+                subjectId: values.subject.id,
+                threadScope: values.threadScope,
+                actorUserId: values.actorUserId,
+                requestedByUserId: values.requestedByUserId,
+                confirmedByUserId: values.confirmedByUserId,
+                ownerUserId: values.ownerUserId,
+                requires: cleanList([...values.requires]),
+                acceptsInput: false,
+                availableAt: values.availableAt ?? null,
+                queueEnteredAt: now,
+                leaseExpiresAt: null,
+                dispatchedAt: null,
+                startedAt: null,
+                finishedAt: null,
+                lastActivityAt: null,
+                cancelRequestedAt: null,
+                cancelledById: null,
+                failureReason: null,
+                failureDetail: null,
+                summary: null,
+                sessionId: null,
+                workDir: null,
+                directoryKey: null,
+                claimFailures: 0,
+                teamOnlyVariables: null,
+                payloadFingerprint: null,
+                createdAt: now,
+                updatedAt: now,
+            },
+        });
+        unit.emit({ type: 'run.queued', runId: id, agentId: agent.id });
+        unit.emit({ type: 'run.changed', runId: id, status: 'queued' });
+        return id;
+    }
+    /** A waiting run takes on the more urgent priority and the earlier moment of the work merged into it. */
+    async function hurry(unit, run, priority, fireAt) {
+        const values = {};
+        if (priority < Number(run.priority))
+            values.priority = priority;
+        if (run.availableAt &&
+            (fireAt === null || Date.parse(fireAt) < Date.parse(run.availableAt)))
+            values.availableAt = fireAt;
+        if (Object.keys(values).length === 0)
+            return;
+        await runsRepo(unit.conn).updateMany({
+            filter: (f) => f.and([f.string('id').eq(run.id), f.string('status').eq('queued')]),
+            values: { ...values, updatedAt: clock.now().toISOString() },
+        });
+    }
+    async function usageOf(conn, runId) {
+        const rows = await usageRepo(conn).findMany({ filter: { runId } });
+        const totals = new Map();
+        for (const row of rows) {
+            const key = `${row.tool}\u0000${row.model ?? ''}`;
+            const total = totals.get(key) ?? {
+                tool: row.tool,
+                model: row.model,
+                inputTokens: 0,
+                outputTokens: 0,
+                cacheReadTokens: 0,
+                cacheWriteTokens: 0,
+                reasoningTokens: 0,
+            };
+            totals.set(key, {
+                ...total,
+                inputTokens: total.inputTokens + Number(row.inputTokens),
+                outputTokens: total.outputTokens + Number(row.outputTokens),
+                cacheReadTokens: total.cacheReadTokens + Number(row.cacheReadTokens),
+                cacheWriteTokens: total.cacheWriteTokens + Number(row.cacheWriteTokens),
+                reasoningTokens: total.reasoningTokens + Number(row.reasoningTokens),
+            });
+        }
+        return [...totals.values()];
+    }
+    /** Legacy runs have no snapshots; report their known primary-tool models without inventing attempt boundaries. */
+    async function readRuns(records) {
+        const runs = records.map(toRun);
+        const legacy = runs.filter((run) => run.executions?.length === 0 &&
+            (run.dispatchedAt !== null ||
+                run.tool !== null ||
+                run.modelService !== null));
+        if (legacy.length === 0)
+            return runs;
+        const usage = await usageRepo(tx.read()).findMany({
+            select: (select) => select.fields('runId', 'tool', 'model'),
+            distinct: ['runId', 'tool', 'model'],
+            filter: (f) => f.and([
+                f.string('model').ne(null),
+                f.or(legacy.map((run) => f.and([
+                    f.string('runId').eq(run.id),
+                    f.string('tool').eq(run.tool ?? 'online'),
+                ]))),
+            ]),
+        });
+        const models = new Map();
+        for (const row of usage)
+            if (row.model)
+                models.set(row.runId, [...(models.get(row.runId) ?? []), row.model]);
+        return runs.map((run) => run.executions?.length
+            ? run
+            : {
+                ...run,
+                actualModels: models.get(run.id) ?? [],
+            });
+    }
+    /**
+     * Queues `work` for `agent`: it joins the run working on its key while that run can still be told, else the run
+     * waiting for it, else starts a new run.
+     */
+    async function queue(unit, agent, work) {
+        // Serializes enqueues and claims for this agent, so a key never gets two waiting runs.
+        await lockAgentForClaim(unit.conn, agent.id, clock.now().toISOString());
+        const key = {
+            agentId: agent.id,
+            subjectKind: work.subject.kind,
+            subjectId: work.subject.id,
+            threadScope: work.threadScope,
+        };
+        // Only into work done as the same person: merged into another's run, it would borrow their identity, or wait
+        // for a runner that never takes it.
+        const open = await runsOfKey(unit.conn, key, ['queued', ...ACTIVE], work.actorUserId);
+        const candidate = open.find((run) => !work.freshSession &&
+            (run.status === 'dispatched' ||
+                (run.status === 'running' && Boolean(run.acceptsInput))));
+        // Joins the working run only when the subject would let the agent act on it now; otherwise it waits in a queued run,
+        // which the claim admits or cancels.
+        const working = candidate &&
+            (await gateInputs(unit.conn, deps, candidate, agent, [
+                {
+                    id: '',
+                    at: clock.now().toISOString(),
+                    ...work.input,
+                },
+            ])).length > 0
+            ? candidate
+            : undefined;
+        const waiting = open.find((run) => run.status === 'queued');
+        const target = working ?? waiting;
+        if (!working && waiting)
+            await hurry(unit, waiting, work.priority, work.fireAt);
+        if (target) {
+            if (!working && work.freshSession && !target.freshSession)
+                await runsRepo(unit.conn).updateMany({
+                    filter: { id: target.id, status: 'queued' },
+                    values: { freshSession: true, updatedAt: clock.now().toISOString() },
+                });
+            const inputId = await insertInput(unit, target.id, work.input);
+            return {
+                runId: target.id,
+                outcome: working ? 'appended' : 'merged',
+                status: target.status,
+                inputId,
+            };
+        }
+        const runId = await createRun(unit, agent, {
+            freshSession: work.freshSession,
+            subject: work.subject,
+            threadScope: work.threadScope,
+            actorUserId: work.actorUserId,
+            requestedByUserId: work.requestedByUserId,
+            confirmedByUserId: work.confirmedByUserId,
+            ownerUserId: work.ownerUserId,
+            priority: work.priority,
+            requires: work.requires,
+            retryOfRunId: null,
+            availableAt: work.fireAt,
+            ...(work.parentRunId ? { parentRunId: work.parentRunId } : {}),
+            ...(work.maxAttempts ? { maxAttempts: work.maxAttempts } : {}),
+        });
+        const inputId = await insertInput(unit, runId, work.input);
+        return { runId, outcome: 'created', status: 'queued', inputId };
+    }
+    /** The source of the chain of work a request belongs to (`EnqueueRequest.requestedByUserId`). */
+    async function sourceOf(unit, request) {
+        if (request.causedByRunId) {
+            const cause = await findRunRecord(unit.conn, request.causedByRunId);
+            if (!cause)
+                throw invalid('causedByRunId names no run.');
+            return chainSourceOf(cause);
+        }
+        const source = request.requestedByUserId ??
+            request.actorUserId ??
+            request.responsibleUserId;
+        if (!source)
+            throw invalid('Name who woke the agent: actorUserId, requestedByUserId or responsibleUserId.');
+        return source;
+    }
+    async function selectedIdentity(unit, request) {
+        const identity = await deps.subjects
+            .get(request.subject.kind)
+            ?.actsAs?.(unit.conn, {
+            subjectId: request.subject.id,
+            agentId: request.agentId,
+            causedByRunId: request.causedByRunId,
+            inputs: [request.input],
+        });
+        if (identity && !identity.actorUserId)
+            throw new ProtocolError('FORBIDDEN', 'The subject has no valid execution identity.', { identityReason: identity.reason ?? 'noOwner' });
+        return identity;
+    }
+    /** Refuses work run as `userId` when no runner they may use can run the agent now: it would only wait. */
+    async function requireRunnerFor(unit, agent, userId, requires) {
+        // By the claim's own rules, the agent's variables included; the subject's are the claim's to check.
+        if (!(await deps.eligibility.canClaim(unit.conn, agent, {
+            actorUserId: userId,
+            requires: requires,
+        })))
+            throw precondition('NO_RUNNER_AVAILABLE', 'No runner you may use can run this agent now: connect one of your own, or ask the person who answers for this to confirm it.', { agentId: agent.id });
+    }
+    const requests = createRunRequestService({
+        tx,
+        ids,
+        clock,
+        people: deps.people,
+        currentResponsible: (unit, subject) => deps.subjects
+            .get(subject.kind)
+            ?.responsibleUserId?.(unit.conn, subject.id),
+        mayInvoke: (agent, userId) => deps.agents.mayInvoke(agent, userId),
+        requireInvocable,
+        requireRunnerFor,
+        direct: async (unit, run) => {
+            const identity = await selectedIdentity(unit, {
+                agentId: run.agent.id,
+                subject: run.subject,
+                input: run.input,
+            });
+            const actorUserId = identity?.actorUserId ?? run.actorUserId;
+            const agent = await requireInvocable(unit, run.agent.id, actorUserId);
+            return queue(unit, agent, {
+                freshSession: run.freshSession,
+                subject: run.subject,
+                threadScope: run.threadScope,
+                actorUserId,
+                requestedByUserId: run.requestedByUserId,
+                confirmedByUserId: run.confirmedByUserId,
+                ownerUserId: identity ? actorUserId : run.ownerUserId,
+                priority: run.priority,
+                // As it was asked: a moment already past when it is confirmed means now.
+                fireAt: fireAtOf(run.fireAt ?? undefined, clock.now()),
+                requires: run.requires,
+                ...(run.maxAttempts === null ? {} : { maxAttempts: run.maxAttempts }),
+                input: run.input,
+            });
+        },
+    });
+    return {
+        enqueue: (request, outer) => tx.run(async (unit) => {
+            const source = await sourceOf(unit, request);
+            const identity = await selectedIdentity(unit, request);
+            const responsible = identity
+                ? null
+                : (request.responsibleUserId ?? null);
+            const threadScope = request.threadScope ?? DEFAULT_THREAD;
+            const foreign = responsible !== null && source !== responsible;
+            if (foreign && (request.execution ?? 'auto') === 'auto') {
+                // A consultation's asker waits for its answer at once: it can never wait for someone's confirmation.
+                if (request.parentRunId)
+                    throw invalid('A consultation cannot wait for confirmation: name no responsible for it.');
+                // Someone else's work waits for the responsible, who must be able to run it once they confirm it.
+                const agent = await requireInvocable(unit, request.agentId, source);
+                if (!deps.agents.mayInvoke(agent, responsible))
+                    throw forbidden('The person who answers for this may not wake this agent.');
+                const created = await insertRunRequest(unit, { ids, clock }, {
+                    agentId: agent.id,
+                    freshSession: request.freshSession,
+                    subject: request.subject,
+                    threadScope,
+                    responsibleUserId: responsible,
+                    requestedByUserId: source,
+                    ownerUserId: request.ownerUserId ?? null,
+                    priority: request.priority ?? 0,
+                    requires: request.requires ?? [],
+                    fireAt: fireAtOf(request.fireAt, clock.now()),
+                    maxAttempts: request.maxAttempts ?? null,
+                    input: request.input,
+                });
+                return {
+                    outcome: 'pending',
+                    requestId: created.id,
+                    status: 'pending',
+                    runId: null,
+                    inputId: null,
+                };
+            }
+            // As the responsible when they caused it; as the source when they run it as themselves (`mine`); as whoever
+            // woke the agent when nobody answers for the subject.
+            const actorUserId = identity?.actorUserId ??
+                (foreign ? source : (responsible ?? request.actorUserId ?? source));
+            const agent = await requireInvocable(unit, request.agentId, actorUserId);
+            if (foreign)
+                await requireRunnerFor(unit, agent, actorUserId, request.requires ?? []);
+            return queue(unit, agent, {
+                freshSession: request.freshSession,
+                subject: request.subject,
+                threadScope,
+                actorUserId,
+                requestedByUserId: source,
+                confirmedByUserId: null,
+                ownerUserId: identity ? actorUserId : (request.ownerUserId ?? null),
+                priority: request.priority ?? 0,
+                fireAt: fireAtOf(request.fireAt, clock.now()),
+                requires: request.requires ?? [],
+                ...(request.parentRunId ? { parentRunId: request.parentRunId } : {}),
+                ...(request.maxAttempts ? { maxAttempts: request.maxAttempts } : {}),
+                input: request.input,
+            });
+        }, outer),
+        requests,
+        identityInputs: async (conn, runId) => {
+            const run = await findRunRecord(conn, runId);
+            if (!run)
+                return null;
+            const inputs = await inputsRepo(conn).findMany({ filter: { runId } });
+            return { run: toRun(run), inputs: inputs.map(toInput) };
+        },
+        addInput: (runId, input, outer) => tx.run(async (unit) => {
+            const run = await require(unit.conn, runId);
+            if (isTerminal(run.status))
+                throw new ProtocolError('RUN_NOT_ACTIVE', `The run is ${run.status}.`);
+            return insertInput(unit, run.id, input);
+        }, outer),
+        cancel: (runId, byUserId, outer) => tx.run(async (unit) => {
+            const run = await require(unit.conn, runId);
+            if (isTerminal(run.status))
+                throw new ProtocolError('RUN_NOT_ACTIVE', `The run is ${run.status}.`);
+            if (run.status === 'queued') {
+                const ended = await finishRun(unit, deps, run, {
+                    status: 'cancelled',
+                    reason: 'cancelled',
+                    cancelledById: byUserId,
+                });
+                if (!ended)
+                    throw conflict('The run changed; try again.');
+                return toRun(ended);
+            }
+            if (!run.cancelRequestedAt) {
+                const now = clock.now().toISOString();
+                await runsRepo(unit.conn).updateMany({
+                    filter: { id: run.id },
+                    values: {
+                        cancelRequestedAt: now,
+                        cancelledById: byUserId,
+                        updatedAt: now,
+                    },
+                });
+                unit.emit({ type: 'run.changed', runId: run.id, status: run.status });
+            }
+            return toRun(await require(unit.conn, run.id));
+        }, outer),
+        withdrawQueued: (request, outer) => tx.run(async (unit) => {
+            const { subject } = request;
+            if (!subject && !request.agentId)
+                throw invalid('Withdrawing queued runs needs a subject or an agent.');
+            const queued = await runsRepo(unit.conn).findMany({
+                filter: (f) => f.and([
+                    ...(subject
+                        ? [
+                            f.string('subjectKind').eq(subject.kind),
+                            f.string('subjectId').eq(subject.id),
+                        ]
+                        : []),
+                    f.string('status').eq('queued'),
+                    ...(request.agentId
+                        ? [f.string('agentId').eq(request.agentId)]
+                        : []),
+                    ...(request.actorUserId
+                        ? [f.string('actorUserId').eq(request.actorUserId)]
+                        : []),
+                ]),
+            });
+            const ended = [];
+            for (const run of queued) {
+                const done = await finishRun(unit, deps, run, {
+                    status: 'cancelled',
+                    reason: 'cancelled',
+                    ...(request.byUserId ? { cancelledById: request.byUserId } : {}),
+                    ...(request.detail ? { detail: request.detail } : {}),
+                });
+                if (done)
+                    ended.push(toRun(done));
+            }
+            return ended;
+        }, outer),
+        retry: async (runId, byUserId, source = 'api') => {
+            const target = await require(tx.read(), runId);
+            // Resolve collection metadata outside the transaction too. The lock must
+            // precede consistent reads so repeatable-read databases see a concurrent
+            // retry that committed while this request waited for the lock.
+            await findAgent(tx.read(), target.agentId);
+            return tx.run(async (unit) => {
+                await lockAgentForClaim(unit.conn, target.agentId, clock.now().toISOString());
+                const run = await require(unit.conn, runId);
+                if (run.status !== 'failed' && run.status !== 'cancelled')
+                    throw precondition('RUN_NOT_RETRYABLE', 'Only a failed or cancelled run can be retried.');
+                if (run.parentRunId)
+                    throw precondition('RUN_NOT_RETRYABLE', 'A consultation is not retried: the agent that asked asks again.');
+                // The agent lock serializes retry and enqueue across server instances. Check
+                // the relationship even after the replacement has already ended.
+                const retried = await runsRepo(unit.conn).findOne({
+                    filter: { retryOfRunId: run.id },
+                    sort: (sort) => [
+                        sort.field('createdAt').asc(),
+                        sort.field('id').asc(),
+                    ],
+                });
+                if (retried)
+                    throw precondition('RUN_ALREADY_RETRIED', 'This run has already been retried.', {
+                        runId: retried.id,
+                    });
+                const previousInputs = await inputsRepo(unit.conn).findMany({
+                    filter: { runId: run.id },
+                });
+                const identity = await deps.subjects
+                    .get(run.subjectKind)
+                    ?.actsAs?.(unit.conn, {
+                    subjectId: run.subjectId,
+                    agentId: run.agentId,
+                    inputs: previousInputs.map(toInput),
+                    causedByRunId: run.retryOfRunId ?? undefined,
+                });
+                if (identity && !identity.actorUserId)
+                    throw forbidden(identity.reason ?? 'noOwner');
+                const actorUserId = identity?.actorUserId ?? byUserId;
+                const agent = await requireInvocable(unit, run.agentId, actorUserId);
+                const open = await runsOfKey(unit.conn, run, ['queued', ...ACTIVE], actorUserId);
+                if (open.length > 0)
+                    throw precondition('AGENT_BUSY', 'The agent is already working on this.', {
+                        runId: open[0].id,
+                    });
+                const newId = await createRun(unit, agent, {
+                    subject: { kind: run.subjectKind, id: run.subjectId },
+                    threadScope: run.threadScope,
+                    actorUserId,
+                    requestedByUserId: byUserId,
+                    confirmedByUserId: null,
+                    ownerUserId: identity ? actorUserId : run.ownerUserId,
+                    priority: Number(run.priority),
+                    requires: toRun(run).requires,
+                    retryOfRunId: run.id,
+                    freshSession: run.freshSession,
+                });
+                for (const input of await pendingInputs(unit.conn, run.id))
+                    await insertInput(unit, newId, {
+                        type: input.type,
+                        actor: toInput(input).actor,
+                        text: input.text,
+                        ...(input.payload === null ? {} : { payload: input.payload }),
+                    });
+                await insertInput(unit, newId, {
+                    type: 'retry',
+                    actor: {
+                        kind: 'user',
+                        id: byUserId,
+                        name: (await deps.people.names(unit.conn, [byUserId])).get(byUserId) ??
+                            byUserId,
+                    },
+                    text: 'Retry the work of the previous run.',
+                    payload: {
+                        retryOfRunId: run.id,
+                        failureReason: run.failureReason,
+                        source,
+                    },
+                });
+                unit.emit({
+                    type: 'run.retried',
+                    runId: newId,
+                    retryOfRunId: run.id,
+                    previousStatus: run.status,
+                });
+                return toRun(await require(unit.conn, newId));
+            });
+        },
+        get: async (runId) => (await readRuns([await require(tx.read(), runId)]))[0],
+        async retryInfo(runId) {
+            const conn = tx.read();
+            const next = await runsRepo(conn).findOne({
+                filter: { retryOfRunId: runId },
+                sort: (sort) => [sort.field('createdAt').asc(), sort.field('id').asc()],
+            });
+            if (!next)
+                return null;
+            const input = await inputsRepo(conn).findOne({
+                filter: { runId: next.id, type: 'retry' },
+                sort: (sort) => [
+                    sort.field('createdAt').desc(),
+                    sort.field('id').desc(),
+                ],
+            });
+            const source = input?.payload?.source;
+            return {
+                runId: next.id,
+                actorUserId: next.actorUserId,
+                actorName: input ? toInputView(input).actor.name : next.actorUserId,
+                source: typeof source === 'string' ? source : 'unknown',
+            };
+        },
+        async detail(runId) {
+            const conn = tx.read();
+            const run = await require(conn, runId);
+            const inputs = await inputsRepo(conn).findMany({
+                filter: { runId },
+                sort: (sort) => [sort.field('createdAt').asc(), sort.field('id').asc()],
+            });
+            const repos = await reposRepo(conn).findMany({ filter: { runId } });
+            const retried = await runsRepo(conn).findOne({
+                filter: { retryOfRunId: runId },
+                sort: (sort) => [sort.field('createdAt').asc(), sort.field('id').asc()],
+            });
+            const children = await runsRepo(conn).findMany({
+                filter: { parentRunId: runId },
+                sort: (sort) => [sort.field('createdAt').asc(), sort.field('id').asc()],
+            });
+            const names = await agentNamesOf(conn, [
+                ...children.map((child) => child.agentId),
+                ...inputs.flatMap((input) => input.actorKind === 'agent' && input.actorId ? [input.actorId] : []),
+            ]);
+            return {
+                ...(await readRuns([run]))[0],
+                actorName: (await deps.people.names(conn, [run.actorUserId])).get(run.actorUserId) ?? run.actorUserId,
+                requestedByName: (await deps.people.names(conn, [
+                    run.requestedByUserId ?? run.actorUserId,
+                ])).get(run.requestedByUserId ?? run.actorUserId) ??
+                    run.requestedByUserId ??
+                    run.actorUserId,
+                retriedRunId: retried?.id ?? null,
+                inputs: inputs.map((input) => {
+                    const view = toInputView(input);
+                    const name = view.actor.kind === 'agent' && view.actor.id
+                        ? names.get(view.actor.id)
+                        : undefined;
+                    return name === undefined
+                        ? view
+                        : { ...view, actor: { ...view.actor, name } };
+                }),
+                repos: repos.map(toRepo),
+                usage: await usageOf(conn, runId),
+                children: children.map((child) => ({
+                    id: child.id,
+                    agentId: child.agentId,
+                    agentName: names.get(child.agentId) ?? null,
+                    status: child.status,
+                    failureReason: toRun(child).failureReason,
+                    summary: child.summary,
+                    createdAt: child.createdAt,
+                    finishedAt: child.finishedAt,
+                })),
+            };
+        },
+        async list(filter) {
+            const records = await runsRepo(tx.read()).findMany({
+                filter: (f) => f.and([
+                    ...(filter.subjectKind
+                        ? [f.string('subjectKind').eq(filter.subjectKind)]
+                        : []),
+                    ...(filter.subjectId
+                        ? [f.string('subjectId').eq(filter.subjectId)]
+                        : []),
+                    ...(filter.agentId ? [f.string('agentId').eq(filter.agentId)] : []),
+                    ...(filter.status ? [f.string('status').eq(filter.status)] : []),
+                    ...(filter.involvingUserId
+                        ? [
+                            f.or([
+                                f.string('actorUserId').eq(filter.involvingUserId),
+                                f.string('ownerUserId').eq(filter.involvingUserId),
+                            ]),
+                        ]
+                        : []),
+                ]),
+                sort: (sort) => [
+                    sort.field('createdAt').desc(),
+                    sort.field('id').desc(),
+                ],
+                limit: Math.min(Math.max(filter.limit ?? 50, 1), 200),
+                ...(filter.cursor ? { cursor: filter.cursor } : {}),
+            });
+            return readRuns(records);
+        },
+        async lastEnded(subjectKind, subjectIds) {
+            if (subjectIds.length === 0)
+                return [];
+            const records = await runsRepo(tx.read()).findMany({
+                filter: (f) => f.and([
+                    f.string('subjectKind').eq(subjectKind),
+                    f.or(subjectIds.map((id) => f.string('subjectId').eq(id))),
+                    f.or(TERMINAL_RUN_STATUSES.map((status) => f.string('status').eq(status))),
+                ]),
+                sort: (sort) => [
+                    sort.field('createdAt').desc(),
+                    sort.field('id').desc(),
+                ],
+            });
+            const newest = new Map();
+            for (const record of records) {
+                const key = `${record.agentId}:${record.subjectId}`;
+                if (!newest.has(key))
+                    newest.set(key, record);
+            }
+            return readRuns([...newest.values()]);
+        },
+        async workingOn(subjectKind, subjectIds) {
+            const ids = [...new Set(subjectIds)];
+            if (ids.length === 0)
+                return [];
+            const records = await runsRepo(tx.read()).findMany({
+                select: (select) => select.fields('subjectId', 'agentId'),
+                filter: (f) => f.and([
+                    f.string('subjectKind').eq(subjectKind),
+                    f.or(ids.map((id) => f.string('subjectId').eq(id))),
+                    f.or(['dispatched', 'running'].map((status) => f.string('status').eq(status))),
+                ]),
+            });
+            const pairs = new Map();
+            for (const record of records) {
+                pairs.set(JSON.stringify([record.subjectId, record.agentId]), {
+                    subjectId: record.subjectId,
+                    agentId: record.agentId,
+                    working: true,
+                });
+            }
+            return [...pairs.values()];
+        },
+        workload(query) {
+            return readWorkload(tx.read(), clock, deps.runners, query, deps.diagnose);
+        },
+        async events(runId, afterSeq, limit, types) {
+            const conn = tx.read();
+            await require(conn, runId);
+            const rows = await eventsRepo(conn).findMany({
+                filter: (f) => f.and([
+                    f.string('runId').eq(runId),
+                    f.number('seq').gt(afterSeq),
+                    ...(types?.length
+                        ? [f.or(types.map((type) => f.string('type').eq(type)))]
+                        : []),
+                ]),
+                sort: (sort) => sort.field('seq').asc(),
+                limit: Math.min(Math.max(limit, 1), 1000),
+            });
+            const events = rows.map((row) => ({
+                seq: Number(row.seq),
+                at: row.at,
+                type: row.type,
+                ...(row.tool ? { tool: row.tool } : {}),
+                ...(row.content === null ? {} : { content: row.content }),
+                ...(row.input === null || row.input === undefined
+                    ? {}
+                    : { input: row.input }),
+                ...(row.output === null ? {} : { output: row.output }),
+                ...(row.truncated ? { truncated: true } : {}),
+                ...(row.meta === null || row.meta === undefined
+                    ? {}
+                    : { meta: jsonObject(row.meta) }),
+            }));
+            return {
+                events,
+                lastSeq: events.length > 0 ? events[events.length - 1].seq : afterSeq,
+            };
+        },
+        authenticateToken: (value) => authenticateRunToken(tx.read(), clock, value),
+        async self({ run }) {
+            const conn = tx.read();
+            const agent = await findAgent(conn, run.agentId);
+            return {
+                runId: run.id,
+                attempt: Number(run.attempt),
+                status: run.status,
+                agent: { id: run.agentId, name: agent?.name ?? run.agentId },
+                subjectRef: { kind: run.subjectKind, id: run.subjectId },
+                actorUserId: run.actorUserId,
+                cancelRequested: run.cancelRequestedAt !== null,
+                // What the run may act on: a read never withholds anything, it only leaves out what delivery would.
+                inputs: (await gatePending(conn, deps, run)).kept.map(toInput),
+            };
+        },
+        async brief(runId) {
+            const brief = await findBrief(tx.read(), runId);
+            if (!brief)
+                throw notFound('Brief');
+            return brief;
+        },
+        resetWorkspace: (subject, byUserId) => tx.run(async ({ conn }) => {
+            await requestReset(conn, () => ids.next(), subject, byUserId, clock.now().toISOString());
+        }),
+        async context({ run }) {
+            const conn = tx.read();
+            const binding = deps.subjects.get(run.subjectKind);
+            const agent = await findAgent(conn, run.agentId);
+            const runner = run.runnerId
+                ? await deps.runners.find(conn, run.runnerId)
+                : null;
+            if (!binding || !agent || !runner || !isActive(run.status))
+                throw notFound('Run context');
+            const assembly = await binding.context.assemble(conn, {
+                run: toRun(run),
+                agent,
+                runner,
+                inputs: (await pendingInputs(conn, run.id)).map(toInput),
+                cli: deps.cliName,
+                appName: deps.appName,
+            }, await binding.context.prepare?.(toRun(run)));
+            return assembly.data;
+        },
+        openOn: openRunsOn,
+        pendingInputs: async (conn, runId) => (await pendingInputs(conn, runId)).map(toInput),
+        inputsSince: inputsOnSince,
+        lastSummary,
+    };
+}
+//# sourceMappingURL=run.service.js.map