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

package/dist/server/routes/schemas.js

@@ -2,13 +2,14 @@
  * The path parameters, query strings and small bodies of the plugin's routes. Bodies the services own (an agent, a
  * skill, a model service) keep their schemas beside the service, strict there too.
  */
-import { ACTOR_KINDS, AGENT_TOOLS, AgentToolSchema, FailureReasonSchema, PERMISSION_MODES, RUN_INPUT_TYPES, RUN_STATUSES, RunEventSchema, RunnerFeatureSchema, RunnerPolicySchema, RunStatusSchema, ToolInfoSchema, ToolLoadSchema, ToolSlotsSchema, } from '@nocobase/agent-protocol';
+import { ACTOR_KINDS, AGENT_TOOLS, AgentToolSchema, FailureReasonSchema, PERMISSION_MODES, RUN_INPUT_TYPES, RUN_EVENT_TYPES, RUN_STATUSES, RunEventSchema, RunnerFeatureSchema, RunnerPolicySchema, RunStatusSchema, ToolInfoSchema, ToolLoadSchema, ToolSlotsSchema, WorkspaceDecisionSchema, WorkspaceCleanupResultSchema, } from '@nocobase/agent-protocol';
 import { z } from 'zod';
-import { AGENT_ACCESS, AGENT_CHANGE_ACTIONS, AGENT_HISTORY_FIELDS, AGENT_TYPES, CONFIRM_CHANGES, } from '../../shared/agents.js';
+import { AGENT_CHANGE_ACTIONS, AGENT_SOURCES, AGENT_STATUSES, AGENT_UNUSABLE_REASONS, CONFIRM_CHANGES, } from '../../shared/agents.js';
 import { CONSULTATION_STATES, CONVERSATION_SOURCE_PATTERN, MESSAGE_ROLES, OFFLINE_REASONS, TITLE_SOURCES, } from '../../shared/conversations.js';
 import { MODEL_KINDS, MODEL_PROVIDER_NAMES, } from '../../shared/models.js';
 import { USAGE_GROUP_BYS, } from '../../shared/reports.js';
 import { RUNNER_STATUSES, RUNNER_TRUST, } from '../../shared/runners.js';
+import { RUN_REQUEST_STATUSES, } from '../../shared/runs.js';
 import { VARIABLE_AUDIT_ACTIONS, } from '../../shared/variables.js';
 /** `true` or `false` in a query string; anything else is refused. */
 const queryBoolean = z
@@ -76,6 +77,15 @@ export const RunListQuery = z.object({
  */
 export const RunEventsQuery = z.object({
     after: z.coerce.number().int().min(0).optional(),
+    // Hono represents one query value as a string and repeated values as an array.
+    type: z
+        .preprocess((value) => (typeof value === 'string' ? [value] : value), z.array(z.enum(RUN_EVENT_TYPES)).min(1).max(100))
+        .optional()
+        .meta({
+        type: 'array',
+        items: { type: 'string', enum: [...RUN_EVENT_TYPES] },
+        description: 'Only these raw event types (repeat for more). Omit to read every type.',
+    }),
     pageSize: pageSize(500, 1000),
     pageToken,
 });
@@ -114,9 +124,22 @@ export const ModelCatalogQuery = z.object({
 export const ClaimQuery = z.object({
     wait: queryBoolean.optional(),
 });
-export const DistTargetQuery = z.object({ format: z.enum(['json', 'env']).optional() });
+export const DistTargetQuery = z.object({
+    format: z.enum(['json', 'env']).optional(),
+    accept: z.string().max(200).optional().meta({
+        description: 'The other answers the caller understands, comma-separated. `npm`: when the application has no tarball of the product but names its npm package, answer that package and exact version (`kind: npm`) instead of 404. Unknown values are ignored.',
+    }),
+});
 export const VariableValueInput = z.strictObject({
-    value: z.string().max(100_000),
+    value: z.string().max(100_000).optional().meta({
+        description: 'The value; required for a new variable, left out to keep the value of one that exists.',
+    }),
+    teamRunnersOnly: z.boolean().optional().meta({
+        description: 'Only team runners receive it; left out, a new variable is not restricted and an existing one keeps its setting.',
+    }),
+    fromRunner: z.boolean().optional().meta({
+        description: 'Take it from the runner: no value is kept here, and the runner that takes the run provides it (`nocobase-runner env set NAME`, or `--pass-env NAME`). Leave `value` out.',
+    }),
 });
 export const SkillRestoreInput = z.strictObject({ expectedRevision: z.number().int().min(1) });
 export const RunnerPatchInput = z
@@ -185,65 +208,47 @@ const RunnerModelEntrySchema = z
 })
     .meta({
     ref: 'AgentsRunnerModelEntry',
-    description: "A runner agent's entry: a coding tool and its model.",
-});
-const OnlineModelEntrySchema = z
-    .object({
-    modelService: z.string(),
-    model: z.string(),
-    effort: z.string().nullable().optional().meta({
-        description: "The reasoning effort: minimal, low, medium, high or xhigh; null for the provider's default.",
-    }),
-})
-    .meta({
-    ref: 'AgentsOnlineModelEntry',
-    description: "An online agent's entry: a model service (its name) and one of its models.",
-});
-const ChatModelChoiceSchema = OnlineModelEntrySchema.extend({
-    serviceTitle: z.string().meta({
-        description: "Its service's title; its name when no enabled service has it any more.",
-    }),
-    modelLabel: z.string().meta({
-        description: "The model's label in its service; its id when the service no longer offers it.",
-    }),
-}).meta({
-    ref: 'AgentsChatModelChoice',
-    description: 'An entry a conversation may answer with, named as the person reads it.',
+    description: "An agent's entry: a coding tool and its model.",
 });
 const agentObject = z.object({
     id: z.string(),
-    name: z.string(),
-    description: z.string().nullable(),
-    nameText: I18nTextSchema.nullable().meta({
-        description: "For an agent the application ships: its name as an i18n reference, shown in the viewer's language in place of `name` until someone edits the name.",
+    name: z.string().meta({
+        description: 'As the model catalog names its tool and model (`Claude · Opus 5.5`), or as the application named its own.',
     }),
-    descriptionText: I18nTextSchema.nullable().meta({
-        description: "For an agent the application ships: its description as an i18n reference, shown in the viewer's language in place of `description` until someone edits it.",
+    description: z.string().nullable().meta({
+        description: 'What it is good at: the project manager hands it work by this. Null until someone writes it.',
     }),
+    nameText: I18nTextSchema.nullable().meta({
+        description: "An application's own agent: its name as an i18n reference, shown in the viewer's language in place of `name`.",
+    }),
+    descriptionText: I18nTextSchema.nullable(),
     avatar: z
         .string()
         .nullable()
         .meta({ description: 'An image URL; null shows the bot icon.' }),
-    type: z.enum(AGENT_TYPES).meta({
-        description: '`runner`: a coding tool on a runner; `online`: a model on the server. Never changes.',
+    source: z.enum(AGENT_SOURCES).meta({
+        description: '`runner`: one of the coding tools and models runners report; `system`: kept by the application.',
     }),
-    modelEntries: z
-        .array(z.union([RunnerModelEntrySchema, OnlineModelEntrySchema]))
-        .meta({
-        description: "The tools and models it works with, in order; the first is its default. A runner takes a runner agent's run with the first entry whose tool it has signed in; an online agent's runs use the first entry, or the one a conversation chose.",
+    status: z.enum(AGENT_STATUSES).meta({
+        description: '`pending` until someone enables it; only `enabled` agents are offered work.',
+    }),
+    tool: AgentToolSchema.nullable(),
+    model: z.string().nullable().meta({
+        description: 'Its model, normalized; null for the application’s own.',
+    }),
+    modelEntries: z.array(RunnerModelEntrySchema).meta({
+        description: 'The tools and models it works with, in order; a runner takes a run with the first it reports.',
     }),
     instructions: z.string().nullable(),
     actions: z.array(z.string()),
     confirmChanges: z.enum(CONFIRM_CHANGES),
-    access: z.enum(AGENT_ACCESS),
-    userIds: z.array(z.string()),
-    ownerUserId: z.string(),
-    runnerIds: z.array(z.string()),
     skillIds: z.array(z.string()),
     maxConcurrentRuns: z.number().int(),
     maxAttempts: z.number().int(),
     toolPolicy: toolPolicyOverrides.nullable(),
-    archivedAt: dateTime.nullable(),
+    lastReportedAt: dateTime.nullable().meta({
+        description: 'When a runner last reported its tool and model.',
+    }),
     revision: z.number().int().meta({
         description: 'Raised by every change; an edit names the revision it was made against.',
     }),
@@ -253,27 +258,69 @@ const agentObject = z.object({
 export const AgentSchema = agentObject.meta({
     ref: 'AgentsAgent',
 });
-export const AgentSummarySchema = agentObject
+export const AgentViewSchema = agentObject
     .extend({
-    ownerName: z.string().nullable(),
-    activeRuns: z.number().int(),
-    onlineRunners: z.number().int(),
+    discoveryKey: z.string().optional().meta({
+        description: 'Persistent display group; known catalog models share a tool/model key across providers.',
+    }),
+    discoveryRevision: z.number().int().optional().meta({
+        description: 'Expected preference revision for ignore or restore; zero when no preference exists yet.',
+    }),
+    ignored: z.boolean().optional().meta({
+        description: 'Shared administrator preference hiding pending discoveries in this group.',
+    }),
+    effort: z.string().nullable().meta({
+        description: 'Its default reasoning effort.',
+    }),
+    efforts: z.array(z.string()).meta({
+        description: 'The efforts its tool takes, weakest first.',
+    }),
+    reported: z.boolean().meta({
+        description: 'A runner reported its tool and model in the last 14 days.',
+    }),
+    runners: z
+        .object({
+        team: z.number().int(),
+        personal: z.number().int(),
+        mine: z.number().int(),
+        names: z.array(z.string()),
+    })
+        .meta({
+        description: 'The online runners that have its tool and model: team ones, personal ones, the caller’s own, and a few names.',
+    }),
+    personalOnly: z.boolean().meta({
+        description: 'Only personal runners have it.',
+    }),
+    unusable: z.enum(AGENT_UNUSABLE_REASONS).nullable().meta({
+        description: 'Why it cannot take the caller’s work now; null when it can.',
+    }),
+    busy: z.number().int(),
+    suggestion: z.object({ en: z.string(), zh: z.string() }).nullable().meta({
+        description: 'What the model catalog says it is good at, to start from when enabling it.',
+    }),
     canEdit: z.boolean(),
-    canCopy: z.boolean(),
 })
-    .meta({ ref: 'AgentsAgentSummary' });
+    .meta({ ref: 'AgentsAgentView' });
+export const AgentNameSchema = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    nameText: I18nTextSchema.nullable(),
+})
+    .meta({ ref: 'AgentsAgentName' });
 export const AvailableAgentSchema = z
     .object({
     id: z.string(),
     name: z.string(),
     goodAt: z.string().meta({ description: "The agent's description." }),
-    type: z.enum(AGENT_TYPES),
-    tool: AgentToolSchema.nullable().meta({
-        description: "A runner agent's default coding tool; null for an online agent.",
+    tool: AgentToolSchema.nullable(),
+    model: z.string().nullable(),
+    online: z.boolean().meta({
+        description: 'Whether a runner would take the caller’s work now.',
+    }),
+    personalOnly: z.boolean().meta({
+        description: 'Only personal runners have it.',
     }),
-    online: z
-        .boolean()
-        .meta({ description: 'Whether it could start work now.' }),
     busy: z
         .number()
         .int()
@@ -289,7 +336,7 @@ export const AgentChangeSchema = z.object({
     actorName: z.string().nullable(),
     changes: z.array(z.union([
         z.object({
-            field: z.enum(AGENT_HISTORY_FIELDS),
+            field: z.string(),
             before: z.unknown(),
             after: z.unknown(),
         }),
@@ -310,22 +357,11 @@ export const AgentActionOptionSchema = z.object({
     defaultOn: z.boolean().optional(),
     grantable: z.boolean().optional(),
     reason: I18nTextSchema.optional(),
-    types: z.array(z.enum(AGENT_TYPES)).optional(),
 });
 export const UserRefSchema = z.object({
     id: z.string(),
     name: z.string(),
 });
-export const AgentPresetSchema = z.object({
-    key: z.string(),
-    name: z.string(),
-    description: z.string(),
-    nameText: I18nTextSchema,
-    descriptionText: I18nTextSchema,
-    instructions: z.string(),
-    type: z.enum(AGENT_TYPES).optional(),
-    actions: z.array(z.string()),
-});
 export const VocabularySchema = z.object({
     subjects: z.array(z.object({
         kind: z.string(),
@@ -378,6 +414,12 @@ export const RunBriefSchema = z.object({
 export const VariableSchema = z
     .object({
     name: z.string(),
+    teamRunnersOnly: z.boolean().optional().meta({
+        description: 'Only team runners receive it: a run that gets it waits for one rather than going to a personal runner.',
+    }),
+    fromRunner: z.boolean().optional().meta({
+        description: 'Taken from the runner: it has no value here, and the runner that takes the run provides it from its own configuration.',
+    }),
     updatedAt: dateTime,
     updatedById: z.string().nullable(),
     updatedByName: z.string().nullable(),
@@ -494,10 +536,65 @@ export const SkillFileQuery = z.object({
 });
 export const SkillAttachmentsSchema = z.object({ skillIds: z.array(z.string()) });
 // Runs.
+const RunEffortReportSchema = z
+    .object({
+    effort: z.string().nullable().meta({
+        description: 'A tool-reported effort; null means the tool did not report the current value.',
+    }),
+    source: z.string().meta({
+        description: 'The tool response that supplied the value, never a request setting.',
+    }),
+    at: dateTime.meta({ description: 'When this reported value changed.' }),
+})
+    .meta({ ref: 'AgentsRunEffortReport' });
+export const RunExecutionSnapshotSchema = z
+    .object({
+    selection: z
+        .object({
+        reason: z.enum(['preferredQueued', 'preferredUnavailable']),
+        preferredTool: z.string(),
+        preferredModel: z.string().nullable(),
+        queueEnteredAt: dateTime,
+        waitedSeconds: z.number(),
+    })
+        .optional(),
+    attempt: z.number().int(),
+    runnerId: z.string(),
+    runnerName: z.string().nullable(),
+    runnerOwnerUserId: z.string().nullable(),
+    runnerOwnerName: z.string().nullable(),
+    runnerTrust: z.enum(['team', 'ownerOnly']).nullable(),
+    tool: z.string().nullable(),
+    toolVersion: z.string().nullable(),
+    modelService: z.string().nullable(),
+    model: z.string().nullable(),
+    actualModels: z.array(z.string()),
+    effort: z.string().nullable(),
+    effortReports: z.array(RunEffortReportSchema).optional(),
+    actualEffortObservedAt: dateTime.optional(),
+    actualEffort: z.string().nullable().optional(),
+    actualEffortSource: z.string().nullable().optional(),
+    actualEffortAt: dateTime.nullable().optional(),
+    machineHidden: z.boolean().optional(),
+    dispatchedAt: dateTime,
+    finishedAt: dateTime.nullable(),
+    failureReason: z.string().nullable(),
+})
+    .meta({ ref: 'AgentsRunExecutionSnapshot' });
 const runObject = z.object({
     id: z.string(),
     agentId: z.string(),
     agentType: z.enum(['online', 'runner']),
+    executions: z.array(RunExecutionSnapshotSchema).optional(),
+    runnerName: z.string().nullable().optional(),
+    runnerOwnerUserId: z.string().nullable().optional(),
+    runnerOwnerName: z.string().nullable().optional(),
+    toolVersion: z.string().nullable().optional(),
+    actualModels: z.array(z.string()).optional(),
+    actualEffort: z.string().nullable().optional(),
+    actualEffortSource: z.string().nullable().optional(),
+    actualEffortAt: dateTime.nullable().optional(),
+    machineHidden: z.boolean().optional(),
     runnerId: z.string().nullable().meta({
         description: 'The runner holding it; `server:<instance>` for an online run held by an application instance.',
     }),
@@ -518,16 +615,26 @@ const runObject = z.object({
     attempt: z.number().int(),
     maxAttempts: z.number().int(),
     retryOfRunId: z.string().nullable(),
+    freshSession: z.boolean().optional(),
     parentRunId: z.string().nullable().meta({
         description: 'A consultation: the run whose agent asked this one a question (`ask_agent`); null for every other run.',
     }),
     subject: z.object({ kind: z.string(), id: z.string() }),
     threadScope: z.string(),
-    actorUserId: z.string(),
+    actorUserId: z.string().meta({
+        description: 'The person the run acts as: their permissions bound it, and only their runners (or team runners) take it.',
+    }),
+    requestedByUserId: z.string().meta({
+        description: 'Who the chain of work the run belongs to started with; the actor when they started it themselves.',
+    }),
+    confirmedByUserId: z.string().nullable().meta({
+        description: 'Who confirmed the run request the run was queued from; null for work its actor started.',
+    }),
     ownerUserId: z.string().nullable(),
     requires: z.array(RunnerFeatureSchema),
     acceptsInput: z.boolean(),
     availableAt: dateTime.nullable(),
+    queueEnteredAt: dateTime.nullable().optional(),
     leaseExpiresAt: dateTime.nullable(),
     dispatchedAt: dateTime.nullable(),
     startedAt: dateTime.nullable(),
@@ -542,6 +649,14 @@ const runObject = z.object({
 });
 export const RunSchema = runObject.meta({ ref: 'AgentsRun' });
 export const RunDetailSchema = runObject.extend({
+    actorName: z
+        .string()
+        .optional()
+        .meta({ description: 'The name of the execution identity.' }),
+    requestedByName: z.string().optional().meta({
+        description: 'The name of the user associated with the chain origin; input actors identify individual triggers.',
+    }),
+    retriedRunId: z.string().nullable().optional(),
     inputs: z.array(z.object({
         id: z.string(),
         type: z.enum(RUN_INPUT_TYPES),
@@ -561,6 +676,12 @@ export const RunDetailSchema = runObject.extend({
         branch: z.string(),
         pushed: z.boolean(),
         headSha: z.string().nullable(),
+        failure: z
+            .object({ reason: z.string(), message: z.string() })
+            .nullable()
+            .meta({
+            description: 'Why the runner could not push the repository at the end of the run; null when it pushed or did not try.',
+        }),
         updatedAt: dateTime,
     })),
     usage: z.array(z.object({
@@ -760,9 +881,6 @@ const conversationSummaryObject = z.object({
     mode: z.enum(['online', 'runner']),
     agent: conversationAgent,
     fallbackFrom: conversationAgent.nullable(),
-    model: OnlineModelEntrySchema.nullable().meta({
-        description: "An online conversation's model: the owner's choice while the agent lists it, else the agent's first entry. Null for a runner conversation.",
-    }),
     read: z.boolean(),
     lastMessageAt: dateTime,
     archivedAt: dateTime.nullable(),
@@ -779,9 +897,6 @@ const conversationSummaryObject = z.object({
 export const ConversationSummarySchema = conversationSummaryObject.meta({ ref: 'AgentsConversationSummary' });
 const conversationDetailObject = conversationSummaryObject.extend({
     availability,
-    models: z.array(ChatModelChoiceSchema).meta({
-        description: "An online conversation: the entries of its agent's list the owner may choose from; empty otherwise.",
-    }),
     canFallback: z.boolean(),
     canRestore: z.boolean(),
 });
@@ -798,6 +913,16 @@ const notice = z.discriminatedUnion('code', [
         agentId: z.string(),
         fromAgentId: z.string(),
     }),
+    z.object({
+        code: z.literal('switchedToOnline'),
+        agentId: z.string(),
+        fromAgentId: z.string(),
+    }),
+    z.object({
+        code: z.literal('onlineFallbackUnavailable'),
+        fromAgentId: z.string(),
+        reason: z.enum(OFFLINE_REASONS),
+    }),
     z.object({
         code: z.literal('switchedBack'),
         agentId: z.string(),
@@ -817,6 +942,7 @@ const notice = z.discriminatedUnion('code', [
     }),
     z.object({
         code: z.literal('consultation'),
+        identitySnapshot: z.boolean().optional(),
         callId: z.string(),
         runId: z.string().nullable(),
         agentId: z.string().nullable(),
@@ -894,6 +1020,7 @@ const messageObject = z.object({
         agentId: z.string().optional(),
         runEventSeq: z.number().int().optional(),
         notice: notice.optional(),
+        onlineFallbackResolved: z.boolean().optional(),
         clientId: z.string().optional(),
         streaming: z.boolean().optional(),
         interrupted: z.boolean().optional(),
@@ -921,16 +1048,66 @@ export const ChatAgentSchema = z.object({
     nameText: I18nTextSchema.nullable(),
     descriptionText: I18nTextSchema.nullable(),
     avatar: z.string().nullable(),
-    type: z.enum(['online', 'runner']),
-    models: z.array(ChatModelChoiceSchema).meta({
-        description: 'An online agent: the entries a new conversation may answer with, the first its default; empty for a runner agent.',
-    }),
-    personal: z.boolean(),
     isSystemDefault: z.boolean(),
     isMyDefault: z.boolean(),
     availability,
+    personalOnly: z.boolean().meta({
+        description: 'Only personal runners have it.',
+    }),
 });
-export const ChatDefaultAgentSchema = z.object({ defaultAgentId: z.string().nullable() });
+export const ChatDefaultAgentSchema = z.object({
+    defaultAgentId: z.string().nullable(),
+});
+export const ChatSettingsSchema = z.object({
+    defaultAgentId: z.string().nullable().meta({
+        description: 'The agent new conversations go to when a person has no default of their own.',
+    }),
+});
+// A runner's working directories, as it last reported them.
+const RunnerWorkspaceSchema = z.object({
+    subjectKey: z.string().optional(),
+    sizeBytes: z.number().int().nonnegative().optional(),
+    decision: WorkspaceDecisionSchema.optional(),
+    cleanup: WorkspaceCleanupResultSchema.optional(),
+    runId: z
+        .string()
+        .optional()
+        .meta({ description: 'The last run that worked in it.' }),
+    workDir: z.string().meta({ description: 'Where it is on the runner.' }),
+    unpushed: z.boolean().meta({
+        description: "It holds changes not committed, or commits the remote task branch lacks; never removed on the application's word.",
+    }),
+    lastUsedAt: z.string(),
+    subjectKind: z.string().nullable(),
+    subjectId: z.string().nullable(),
+    settled: z.boolean().nullable().meta({
+        description: "Its subject's work is over (true), goes on (false), or cannot be told (null).",
+    }),
+});
+const RunnerWorkspaceUsageSchema = z
+    .object({
+    disk: z
+        .object({
+        freeBytes: z.number().int(),
+        totalBytes: z.number().int(),
+        minFreeBytes: z.number().int().nullable().meta({
+            description: "What the runner's owner keeps free; below it, the runner removes directories that may go. Null for nothing.",
+        }),
+    })
+        .nullable()
+        .meta({
+        description: "The disk holding the runner's working directories; null when it did not say.",
+    }),
+    intervalMs: z.number().int().positive().optional(),
+    count: z.number().int(),
+    unpushedCount: z.number().int(),
+    measuredAt: dateTime.nullable(),
+    diskMeasuredAt: dateTime.optional(),
+    workspaces: z.array(RunnerWorkspaceSchema).meta({
+        description: "This application's, most recently used first; empty for a caller who may not see the runner's machine.",
+    }),
+})
+    .meta({ ref: 'AgentsRunnerWorkspaceUsage' });
 // Runners, as people manage them.
 const runnerObject = z.object({
     id: z.string(),
@@ -954,11 +1131,23 @@ const runnerObject = z.object({
     toolSlots: ToolSlotsSchema.nullable().meta({
         description: 'How many runs of each coding tool it may hold at once, beside `slots`; null, or a tool left out, for no limit of its own.',
     }),
+    draining: z.enum(['updatePending', 'pruning']).optional().meta({
+        description: 'Why the runner temporarily accepts no new work, regardless of available slots.',
+    }),
+    globalFree: z.number().nonnegative().optional().meta({
+        description: 'Free slots reported in the latest heartbeat across all applications; absent before a heartbeat.',
+    }),
     toolLoad: z.partialRecord(AgentToolSchema, ToolLoadSchema).nullable().meta({
         description: 'What it last reported per coding tool it limits on its own side, across every application it serves: how many runs of each it holds at most and could take now.',
     }),
     acceptJobs: z.boolean(),
     policy: RunnerPolicySchema.nullable(),
+    variables: z.array(z.string()).nullable().optional().meta({
+        description: 'The names of the variables it provides to runs that take them from the runner, as it last reported them; null when it reported none. Names only.',
+    }),
+    workspaceUsage: RunnerWorkspaceUsageSchema.nullable().optional().meta({
+        description: 'The working directories it keeps for this application and the free space on the disk holding them, as it last reported them; null or absent before it reports.',
+    }),
     lastSeenAt: dateTime.nullable(),
     createdAt: dateTime,
     updatedAt: dateTime,
@@ -980,8 +1169,10 @@ export const RunnerSummarySchema = runnerObject
         description: 'The runs it holds now by the coding tool each runs with; a tool it runs nothing of is left out.',
     }),
     takes: z.array(z.object({ id: z.string(), name: z.string() })),
+    canSeeMachine: z.boolean().optional(),
     canManage: z.boolean(),
     canChangeTrust: z.boolean(),
+    canRevoke: z.boolean(),
     updateVersion: z.string().nullable(),
     requiredProtocol: z.object({
         min: z.number().int(),
@@ -1037,4 +1228,98 @@ export const RunContextSchema = z
     .meta({
     description: "The context the run's subject assembles; its fields depend on the subject kind.",
 });
+// Run requests: work someone asked of an agent on a subject another person answers for.
+export const RunRequestParams = z.object({
+    requestId: id,
+});
+export const RunRequestListQuery = z.object({
+    role: z.enum(['responsible', 'requester']).optional().meta({
+        description: '`responsible`: the requests the caller answers for (to confirm); `requester`: the ones the caller asked. Both when left out.',
+    }),
+    status: z.enum(RUN_REQUEST_STATUSES).optional(),
+    subjectKind: id.optional(),
+    subjectId: id.optional(),
+    agentId: id.optional(),
+    pageSize: pageSize(50, 200),
+    pageToken,
+});
+export const RunRequestRejectInput = z.strictObject({
+    note: z.string().max(2000).optional().meta({
+        description: 'Why, for the person who asked.',
+    }),
+});
+const runRequestObject = z.object({
+    freshSession: z.boolean().optional(),
+    id: z.string(),
+    agentId: z.string(),
+    subject: z.object({ kind: z.string(), id: z.string() }),
+    threadScope: z.string(),
+    responsibleUserId: z.string().meta({
+        description: 'Who answers for the subject: the only person who may confirm or reject the request.',
+    }),
+    requestedByUserId: z.string().meta({
+        description: 'Who the chain of work started with: the only person who may withdraw the request or run it as themselves.',
+    }),
+    ownerUserId: z.string().nullable(),
+    fireAt: dateTime.nullable().meta({
+        description: 'Its run is not claimed before this moment, as it was asked; null for as soon as it runs.',
+    }),
+    maxAttempts: z.number().int().nullable().meta({
+        description: "Attempts its run may take; null for the agent's default.",
+    }),
+    input: z
+        .object({
+        type: z.enum(RUN_INPUT_TYPES),
+        actor: z.object({
+            kind: z.enum(ACTOR_KINDS),
+            id: z.string(),
+            name: z.string(),
+        }),
+        text: z.string(),
+        payload: z.unknown(),
+    })
+        .meta({
+        description: 'The input as it was when asked, whatever happened to its source since: what confirming runs.',
+    }),
+    status: z.enum(RUN_REQUEST_STATUSES).meta({
+        description: 'Only a `pending` request changes; every other status is final.',
+    }),
+    settledById: z.string().nullable(),
+    settledAt: dateTime.nullable(),
+    note: z.string().nullable(),
+    expiresAt: dateTime,
+    runId: z.string().nullable().meta({
+        description: 'The run it went into: on confirming, or when the person who asked ran it as themselves.',
+    }),
+    supersededById: z.string().nullable().meta({
+        description: "The request that took over when the subject's responsible changed.",
+    }),
+    createdAt: dateTime,
+    updatedAt: dateTime,
+});
+export const RunRequestSchema = runRequestObject.meta({
+    ref: 'AgentsRunRequest',
+});
+export const RunRequestItemSchema = runRequestObject
+    .extend({
+    agentName: z.string().nullable(),
+    responsibleName: z.string().nullable(),
+    requestedByName: z.string().nullable(),
+})
+    .meta({ ref: 'AgentsRunRequestItem' });
+export const RunRequestOutcomeSchema = z
+    .object({
+    request: RunRequestSchema,
+    run: z.object({
+        runId: z.string(),
+        outcome: z.enum(['created', 'merged', 'appended']).meta({
+            description: '`created` a new run, `merged` into a queued one, `appended` to one a runner holds.',
+        }),
+        status: RunStatusSchema,
+        inputId: z.string().meta({
+            description: "The request's input, as the run received it.",
+        }),
+    }),
+})
+    .meta({ ref: 'AgentsRunRequestOutcome' });
 //# sourceMappingURL=schemas.js.map