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

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

@@ -3,20 +3,36 @@
  * 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 while it can
- * still be told (dispatched, or running with input), else the run waiting for it (queued), else starts a new run.
+ * 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 { dialectOf, takesType } from './ports.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)
@@ -52,43 +68,50 @@ export function createRunService(deps) {
             },
         });
         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.archivedAt)
-            throw precondition('AGENT_ARCHIVED', 'The agent is archived.');
+        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) {
-        if (!takesType(deps.subjects.get(values.subject.kind), agent.type))
-            throw invalid(`A ${agent.type} agent cannot work on a ${values.subject.kind}.`, { reason: 'AGENT_TYPE_NOT_ALLOWED', agentType: agent.type });
         const now = clock.now().toISOString();
         const id = ids.next();
         await runsRepo(unit.conn).createOne({
             values: {
                 id,
                 agentId: agent.id,
-                agentType: agent.type,
+                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,
@@ -103,6 +126,7 @@ export function createRunService(deps) {
                 workDir: null,
                 directoryKey: null,
                 claimFailures: 0,
+                teamOnlyVariables: null,
                 payloadFingerprint: null,
                 createdAt: now,
                 updatedAt: now,
@@ -152,49 +176,247 @@ export function createRunService(deps) {
         }
         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 agent = await requireInvocable(unit, request.agentId, request.actorUserId);
-            // 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: request.subject.kind,
-                subjectId: request.subject.id,
-                threadScope: request.threadScope ?? DEFAULT_THREAD,
-            };
-            const open = await runsOfKey(unit.conn, key, ['queued', ...ACTIVE]);
-            const working = open.find((run) => run.status === 'dispatched' ||
-                (run.status === 'running' && Boolean(run.acceptsInput)));
-            const waiting = open.find((run) => run.status === 'queued');
-            const target = working ?? waiting;
-            const fireAt = fireAtOf(request.fireAt, clock.now());
-            if (!working && waiting)
-                await hurry(unit, waiting, request.priority ?? 0, fireAt);
-            if (target) {
-                const inputId = await insertInput(unit, target.id, request.input);
+            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 {
-                    runId: target.id,
-                    outcome: working ? 'appended' : 'merged',
-                    status: target.status,
-                    inputId,
+                    outcome: 'pending',
+                    requestId: created.id,
+                    status: 'pending',
+                    runId: null,
+                    inputId: null,
                 };
             }
-            const runId = await createRun(unit, agent, {
+            // 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: key.threadScope,
-                actorUserId: request.actorUserId,
-                ownerUserId: request.ownerUserId ?? null,
+                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 ?? [],
-                retryOfRunId: null,
-                availableAt: fireAt,
                 ...(request.parentRunId ? { parentRunId: request.parentRunId } : {}),
                 ...(request.maxAttempts ? { maxAttempts: request.maxAttempts } : {}),
+                input: request.input,
             });
-            const inputId = await insertInput(unit, runId, request.input);
-            return { runId, outcome: 'created', status: 'queued', inputId };
         }, 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))
@@ -263,44 +485,119 @@ export function createRunService(deps) {
             }
             return ended;
         }, outer),
-        retry: (runId, byUserId) => tx.run(async (unit) => {
-            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.');
-            const agent = await requireInvocable(unit, run.agentId, byUserId);
-            await lockAgentForClaim(unit.conn, agent.id, clock.now().toISOString());
-            const open = await runsOfKey(unit.conn, run, ['queued', ...ACTIVE]);
-            if (open.length > 0)
-                throw precondition('AGENT_BUSY', 'The agent is already working on this.', {
-                    runId: open[0].id,
+        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(),
+                    ],
                 });
-            const newId = await createRun(unit, agent, {
-                subject: { kind: run.subjectKind, id: run.subjectId },
-                threadScope: run.threadScope,
-                actorUserId: byUserId,
-                ownerUserId: run.ownerUserId,
-                priority: Number(run.priority),
-                requires: toRun(run).requires,
-                retryOfRunId: run.id,
-            });
-            for (const input of await pendingInputs(unit.conn, run.id))
+                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: input.type,
-                    actor: toInput(input).actor,
-                    text: input.text,
-                    ...(input.payload === null ? {} : { payload: input.payload }),
+                    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,
+                    },
                 });
-            await insertInput(unit, newId, {
-                type: 'retry',
-                actor: { kind: 'user', id: byUserId, name: byUserId },
-                text: 'Retry the work of the previous run.',
-                payload: { retryOfRunId: run.id, failureReason: run.failureReason },
+                unit.emit({
+                    type: 'run.retried',
+                    runId: newId,
+                    retryOfRunId: run.id,
+                    previousStatus: run.status,
+                });
+                return toRun(await require(unit.conn, newId));
             });
-            return toRun(await require(unit.conn, newId));
-        }),
-        get: async (runId) => toRun(await require(tx.read(), runId)),
+        },
+        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);
@@ -309,17 +606,36 @@ export function createRunService(deps) {
                 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 = new Map();
-            for (const child of children)
-                if (!names.has(child.agentId))
-                    names.set(child.agentId, (await findAgent(conn, child.agentId))?.name ?? null);
+            const names = await agentNamesOf(conn, [
+                ...children.map((child) => child.agentId),
+                ...inputs.flatMap((input) => input.actorKind === 'agent' && input.actorId ? [input.actorId] : []),
+            ]);
             return {
-                ...toRun(run),
-                inputs: inputs.map(toInputView),
+                ...(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) => ({
@@ -361,7 +677,7 @@ export function createRunService(deps) {
                 limit: Math.min(Math.max(filter.limit ?? 50, 1), 200),
                 ...(filter.cursor ? { cursor: filter.cursor } : {}),
             });
-            return records.map(toRun);
+            return readRuns(records);
         },
         async lastEnded(subjectKind, subjectIds) {
             if (subjectIds.length === 0)
@@ -383,16 +699,44 @@ export function createRunService(deps) {
                 if (!newest.has(key))
                     newest.set(key, record);
             }
-            return [...newest.values()].map(toRun);
+            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);
+            return readWorkload(tx.read(), clock, deps.runners, query, deps.diagnose);
         },
-        async events(runId, afterSeq, limit) {
+        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)]),
+                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),
             });
@@ -428,7 +772,8 @@ export function createRunService(deps) {
                 subjectRef: { kind: run.subjectKind, id: run.subjectId },
                 actorUserId: run.actorUserId,
                 cancelRequested: run.cancelRequestedAt !== null,
-                inputs: (await pendingInputs(conn, run.id)).map(toInput),
+                // 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) {
@@ -444,14 +789,10 @@ export function createRunService(deps) {
             const conn = tx.read();
             const binding = deps.subjects.get(run.subjectKind);
             const agent = await findAgent(conn, run.agentId);
-            // An online run is held by the application itself, not by a registered runner.
-            const runner = run.runnerId && agent?.type === 'runner'
+            const runner = run.runnerId
                 ? await deps.runners.find(conn, run.runnerId)
                 : null;
-            if (!binding ||
-                !agent ||
-                (agent.type === 'runner' && !runner) ||
-                !isActive(run.status))
+            if (!binding || !agent || !runner || !isActive(run.status))
                 throw notFound('Run context');
             const assembly = await binding.context.assemble(conn, {
                 run: toRun(run),
@@ -460,8 +801,7 @@ export function createRunService(deps) {
                 inputs: (await pendingInputs(conn, run.id)).map(toInput),
                 cli: deps.cliName,
                 appName: deps.appName,
-                dialect: dialectOf(agent),
-            });
+            }, await binding.context.prepare?.(toRun(run)));
             return assembly.data;
         },
         openOn: openRunsOn,