@capybara-hq/kernel 0.1.0-rc.5 → 0.1.0-rc.7

package/dist/agents/pending-connector-requests.js

@@ -122,7 +122,7 @@ let PendingConnectorRequests = class PendingConnectorRequests {
                     orgId: a.orgId,
                     action: "catalog.requested",
                     target: id,
-                    detail: { kind: "connector_setup", agentId: a.agentId, keys },
+                    detail: { kind: "connector_setup", agentId: a.agentId, keys, ...a.auditDetail },
                 });
                 return { id, created: true };
             }

package/dist/agents/pending-connectors.controller.d.ts

@@ -1,5 +1,5 @@
 import type { FastifyReply } from "fastify";
-import { z } from "zod";
+import type { z } from "zod";
 import { CatalogRequestsService, type CatalogRequestView } from "../catalog/requests.service.js";
 import { type Principal } from "../identity/principal.js";
 import { type OrgContext } from "../orgs/org.guard.js";

package/dist/agents/pending-connectors.controller.js

@@ -8,15 +8,15 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Controller, Get, HttpCode, Inject, Param, Post, Res } from "@nestjs/common";
-import { z } from "zod";
 import { CatalogRequestsService } from "../catalog/requests.service.js";
 import { CurrentPrincipal, patTokenId, requireUser, } from "../identity/principal.js";
 import { createZodDto } from "../infra/validation/create-zod-dto.js";
 import { ZBody } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
+import { PendingConnectorBindBody as BindBodySchema } from "./agents.schemas.js";
 import { AgentsService } from "./agents.service.js";
 import { PendingConnectorsService } from "./pending-connectors.service.js";
-const BindBody = z.object({ connectorId: z.string().min(1).max(100) }).strict();
+const BindBody = BindBodySchema;
 class PendingConnectorBindBody extends createZodDto(BindBody, "PendingConnectorBindBody") {
 }
 /**

package/dist/agents/pending-connectors.service.d.ts

@@ -41,14 +41,14 @@ export declare class PendingConnectorsService {
      * authorized) or none of the entry's tools -> 400 `agent.pending_connector_mismatch`.
      * Audits `agent.pending_connector_bound`.
      */
-    bind(orgId: string, agentId: string, key: string, connectorId: string, actor: string, actorTokenId?: string): Promise<BindResult>;
+    bind(orgId: string, agentId: string, key: string, connectorId: string, actor: string, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<BindResult>;
     /**
      * (Re-)opens the agent's connector setup request (ruling P4-T6-7; the owner or an org admin+):
      * the pending one when it has one (`created` false), else a new one for the current pending
      * keys, requested by the agent's owner (P4-T6-4). No pending connectors -> 409
      * `agent.no_pending_connectors`.
      */
-    reopen(orgId: string, agentId: string, actor: string, actorTokenId?: string): Promise<{
+    reopen(orgId: string, agentId: string, actor: string, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<{
         id: string;
         created: boolean;
     }>;

package/dist/agents/pending-connectors.service.js

@@ -18,7 +18,7 @@ import { Transactional } from "../infra/database/transactional.decorator.js";
 import { roleAtLeast } from "../orgs/roles.js";
 import { AgentLookup, isAgentVisibleTo } from "./agent-lookup.js";
 import { AgentsService } from "./agents.service.js";
-import { normalizeStoredDefinition, } from "./definition.js";
+import { canonicalDisabledTools, normalizeStoredDefinition, } from "./definition.js";
 import { PendingConnectorRequests } from "./pending-connector-requests.js";
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const RANK = { ask: 1, deny: 2 };
@@ -71,7 +71,7 @@ let PendingConnectorsService = class PendingConnectorsService {
      * authorized) or none of the entry's tools -> 400 `agent.pending_connector_mismatch`.
      * Audits `agent.pending_connector_bound`.
      */
-    async bind(orgId, agentId, key, connectorId, actor, actorTokenId) {
+    async bind(orgId, agentId, key, connectorId, actor, actorTokenId, auditDetail) {
         const t = this.kdb.db;
         const before = await this.agents.lockForWrite(orgId, agentId, actor);
         const def = await this.currentDefinition(agentId, before.current_version);
@@ -137,25 +137,18 @@ let PendingConnectorsService = class PendingConnectorsService {
             if (prev === undefined || RANK[p] > RANK[prev])
                 toolPolicies[k] = p;
         }
-        let merged = false;
-        const tools = def.tools.map((r) => {
-            if (r.kind !== "connector" || r.connectorId !== c.id || merged)
-                return r;
-            merged = true;
-            if (r.tools === "all")
-                return r;
-            return {
-                ...r,
-                tools: names === "all" ? "all" : [...new Set([...r.tools, ...names])],
-            };
-        });
-        if (!merged)
-            tools.push({ kind: "connector", connectorId: c.id, tools: names });
+        // tools are on by default (tools default-on spec §3): binding an entry that names some tools
+        // turns the connector's other tools off for this agent; one taking them all leaves it all on
+        const off = names === "all" ? [] : offered.filter((n) => !names.includes(n));
+        const disabledTools = [
+            ...(def.disabledTools ?? []).filter((r) => r.kind !== "connector" || r.connectorId !== c.id),
+            ...(off.length > 0 ? [{ kind: "connector", connectorId: c.id, tools: off }] : []),
+        ];
         const left = pending.filter((x) => x.key !== key);
         const { pendingConnectors: _old, ...rest } = def;
         const next = {
             ...rest,
-            tools,
+            disabledTools: canonicalDisabledTools(disabledTools),
             toolPolicies,
             ...(left.length > 0 && { pendingConnectors: left }),
         };
@@ -180,7 +173,13 @@ let PendingConnectorsService = class PendingConnectorsService {
             orgId,
             action: "agent.pending_connector_bound",
             target: agentId,
-            detail: { key, connectorId: c.id, fromVersion: before.current_version, toVersion },
+            detail: {
+                key,
+                connectorId: c.id,
+                fromVersion: before.current_version,
+                toVersion,
+                ...auditDetail,
+            },
         });
         await this.requests.settleIn({
             orgId,
@@ -198,7 +197,7 @@ let PendingConnectorsService = class PendingConnectorsService {
      * keys, requested by the agent's owner (P4-T6-4). No pending connectors -> 409
      * `agent.no_pending_connectors`.
      */
-    async reopen(orgId, agentId, actor, actorTokenId) {
+    async reopen(orgId, agentId, actor, actorTokenId, auditDetail) {
         const before = await this.agents.lockForWrite(orgId, agentId, actor);
         const def = await this.currentDefinition(agentId, before.current_version);
         const keys = (def.pendingConnectors ?? []).map((c) => c.key);
@@ -216,6 +215,7 @@ let PendingConnectorsService = class PendingConnectorsService {
             requestedBy: owner.owner_account_id,
             actor,
             actorTokenId,
+            ...(auditDetail !== undefined && { auditDetail }),
         });
         // the agent row is locked above, so the keys read there are still pending
         if (r === null)

package/dist/agents/profile.d.ts

@@ -44,6 +44,22 @@ export declare const QuickActionsSchema: z.ZodArray<z.ZodObject<{
     body: z.ZodString;
 }, z.core.$strict>>;
 /** What a client may write (`external` is migrated data only). */
+/** A preset avatar: the only kind the `Platform` tool sets (an upload is the web's). */
+export declare const PresetAvatarSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"preset">;
+    id: z.ZodEnum<{
+        "black-bear": "black-bear";
+        capybara: "capybara";
+        elephant: "elephant";
+        fox: "fox";
+        owl: "owl";
+        panda: "panda";
+        penguin: "penguin";
+        rabbit: "rabbit";
+        turtle: "turtle";
+        whale: "whale";
+    }>;
+}, z.core.$strict>;
 export declare const AvatarInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"preset">;
     id: z.ZodEnum<{
@@ -88,6 +104,8 @@ export declare const ProfileInputSchema: z.ZodObject<{
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type ProfileInput = z.infer<typeof ProfileInputSchema>;
+/** What `PATCH …/profile` writes: the description is saved with the definition (run context §3.5). */
+export type ProfilePatch = Omit<ProfileInput, "description">;
 export interface AgentProfile {
     avatar: AgentAvatar;
     description: string;

package/dist/agents/profile.js

@@ -38,8 +38,12 @@ export const QuickActionSchema = z
 export const DescriptionSchema = z.string().max(PROFILE_LIMITS.description);
 export const QuickActionsSchema = z.array(QuickActionSchema).max(PROFILE_LIMITS.quickActions);
 /** What a client may write (`external` is migrated data only). */
+/** A preset avatar: the only kind the `Platform` tool sets (an upload is the web's). */
+export const PresetAvatarSchema = z
+    .object({ kind: z.literal("preset"), id: z.enum(PRESET_IDS) })
+    .strict();
 export const AvatarInputSchema = z.discriminatedUnion("kind", [
-    z.object({ kind: z.literal("preset"), id: z.enum(PRESET_IDS) }).strict(),
+    PresetAvatarSchema,
     z.object({ kind: z.literal("upload"), uploadId: z.string().min(1).max(200) }).strict(),
 ]);
 export const ProfileInputSchema = z

package/dist/agents/readiness.controller.d.ts

@@ -9,11 +9,11 @@ import { AgentsService } from "./agents.service.js";
  * a vendor call; `agents` is the number of agents the caller can see (the agent list's
  * visibility). Humans and service tokens (`org.read`).
  *
- * `modelProvider` is deployment-wide, not about this org: model providers are not org-scoped
- * (an org's model purposes map onto the deployment's providers but cannot add one), so every org
- * of the deployment reads the same value. It is read from this replica's provider registry, which
- * follows the per-replica extension reconcile: right after a provider is enabled, a replica that
- * has not reconciled yet may still answer `none` for a moment.
+ * `modelProvider` counts the deployment's providers whose effective config is valid in this org
+ * (spec B §5.5: a provider the platform installed without a key needs each org's own). It is read
+ * from this replica's provider registry, which follows the per-replica extension reconcile: right
+ * after a provider is enabled, a replica that has not reconciled yet may still answer `none` for
+ * a moment.
  */
 export declare class ReadinessController {
     private readonly registry;

package/dist/agents/readiness.controller.js

@@ -21,11 +21,11 @@ const viewerOf = (p) => (p.kind === "user" ? p.account.id : null);
  * a vendor call; `agents` is the number of agents the caller can see (the agent list's
  * visibility). Humans and service tokens (`org.read`).
  *
- * `modelProvider` is deployment-wide, not about this org: model providers are not org-scoped
- * (an org's model purposes map onto the deployment's providers but cannot add one), so every org
- * of the deployment reads the same value. It is read from this replica's provider registry, which
- * follows the per-replica extension reconcile: right after a provider is enabled, a replica that
- * has not reconciled yet may still answer `none` for a moment.
+ * `modelProvider` counts the deployment's providers whose effective config is valid in this org
+ * (spec B §5.5: a provider the platform installed without a key needs each org's own). It is read
+ * from this replica's provider registry, which follows the per-replica extension reconcile: right
+ * after a provider is enabled, a replica that has not reconciled yet may still answer `none` for
+ * a moment.
  */
 let ReadinessController = class ReadinessController {
     registry;
@@ -37,7 +37,7 @@ let ReadinessController = class ReadinessController {
     async get(principal, org) {
         const visible = await this.agents.listVisible(org.orgId, viewerOf(principal));
         return {
-            modelProvider: this.registry.hasProvider() ? "ready" : "none",
+            modelProvider: (await this.registry.hasProvider(org.orgId)) ? "ready" : "none",
             agents: visible.length,
         };
     }

package/dist/agents/templates.controller.d.ts

@@ -1,22 +1,13 @@
-import { z } from "zod";
+import type { z } from "zod";
 import { OwnedItems, type OwnedSkillDeletePreview } from "../catalog/owned-items.js";
 import { type Principal } from "../identity/principal.js";
 import { type OrgContext } from "../orgs/org.guard.js";
 import { type AgentTemplateDetail, OrgAgentTemplates, type SaveAsOmission } from "./org-templates.js";
 import { AgentTemplatesService, type AgentTemplateView } from "./templates.js";
-declare const IdParams: z.ZodObject<{
-    id: z.ZodString;
-}, z.core.$strip>;
-declare const AgentIdParams: z.ZodObject<{
-    agentId: z.ZodString;
-}, z.core.$strip>;
+import { AgentTemplateIdParams, SaveAsAgentIdParams, SaveAsTemplateBody } from "./templates.schemas.js";
 declare const ShareableBody: z.ZodObject<{
     shareable: z.ZodBoolean;
 }, z.core.$strict>;
-declare const SaveAsBody: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodString;
-}, z.core.$strict>;
 declare const UpdateBody: z.ZodObject<{
     definition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     expectedVersion: z.ZodNumber;
@@ -42,7 +33,7 @@ export declare class AgentTemplatesController {
      * the org) with its definition, owner and the org's flags (`owned`, `shareable`, `promoted`).
      * Not usable here -> 404 `component.not_found`.
      */
-    get(principal: Principal, org: OrgContext, params: z.infer<typeof IdParams>): Promise<{
+    get(principal: Principal, org: OrgContext, params: z.infer<typeof AgentTemplateIdParams>): Promise<{
         template: AgentTemplateDetail;
     }>;
     /**
@@ -50,7 +41,7 @@ export declare class AgentTemplatesController {
      * 200 `{ template }`; a stale version -> 409 `agent_template.version_conflict`; a template the
      * org does not own -> 409 `catalog.not_owned`.
      */
-    update(principal: Principal, org: OrgContext, params: z.infer<typeof IdParams>, body: z.infer<typeof UpdateBody>): Promise<{
+    update(principal: Principal, org: OrgContext, params: z.infer<typeof AgentTemplateIdParams>, body: z.infer<typeof UpdateBody>): Promise<{
         template: AgentTemplateDetail;
     }>;
     /**
@@ -58,12 +49,12 @@ export declare class AgentTemplatesController {
      * was shared and another org uses it (`orgs`), else `removed`; `agents` the org's agents whose
      * roster loses it.
      */
-    deletePreview(principal: Principal, org: OrgContext, params: z.infer<typeof IdParams>): Promise<OwnedSkillDeletePreview>;
+    deletePreview(principal: Principal, org: OrgContext, params: z.infer<typeof AgentTemplateIdParams>): Promise<OwnedSkillDeletePreview>;
     /**
      * Deletes the org's own template (the P3 owner rules, ruling P4-12): one it shared that another
      * org uses becomes the platform's (platform notice `ownership_transferred`). 200 `{ outcome }`.
      */
-    remove(principal: Principal, org: OrgContext, params: z.infer<typeof IdParams>): Promise<{
+    remove(principal: Principal, org: OrgContext, params: z.infer<typeof AgentTemplateIdParams>): Promise<{
         outcome: "transferred" | "removed";
     }>;
     /**
@@ -71,7 +62,7 @@ export declare class AgentTemplatesController {
      * template, ruling P4-13): a plugin's template or a copy of another owner's platform template
      * -> 409 `catalog.not_owned`; one the org promoted writes its platform row too (ruling P3-2).
      */
-    setShareable(principal: Principal, org: OrgContext, params: z.infer<typeof IdParams>, body: z.infer<typeof ShareableBody>): Promise<{
+    setShareable(principal: Principal, org: OrgContext, params: z.infer<typeof AgentTemplateIdParams>, body: z.infer<typeof ShareableBody>): Promise<{
         id: string;
         shareable: boolean;
     }>;
@@ -88,7 +79,7 @@ export declare class AgentTemplatesController {
 export declare class AgentSaveAsTemplateController {
     private readonly orgTemplates;
     constructor(orgTemplates: OrgAgentTemplates);
-    saveAs(principal: Principal, org: OrgContext, params: z.infer<typeof AgentIdParams>, body: z.infer<typeof SaveAsBody>): Promise<{
+    saveAs(principal: Principal, org: OrgContext, params: z.infer<typeof SaveAsAgentIdParams>, body: z.infer<typeof SaveAsTemplateBody>): Promise<{
         template: AgentTemplateDetail;
         omitted: SaveAsOmission[];
     }>;

package/dist/agents/templates.controller.js

@@ -7,9 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { AGENT_TEMPLATE_NAME_RE } from "@capybara-hq/plugin-sdk";
 import { Controller, Delete, Get, Inject, Post, Put } from "@nestjs/common";
-import { z } from "zod";
 import { OwnedItems } from "../catalog/owned-items.js";
 import { CurrentPrincipal, patTokenId, requireUser, } from "../identity/principal.js";
 import { createZodDto } from "../infra/validation/create-zod-dto.js";
@@ -17,32 +15,16 @@ import { ZBody, ZParam } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
 import { OrgAgentTemplates, } from "./org-templates.js";
 import { AgentTemplatesService } from "./templates.js";
-const IdParams = z.object({ id: z.string().min(1).max(100) });
-const AgentIdParams = z.object({ agentId: z.string().min(1).max(100) });
-const ShareableBody = z.object({ shareable: z.boolean() }).strict();
-const SaveAsBody = z
-    .object({
-    /** The bare template name (the template name rule); unique in the org's usable set. */
-    name: z.string().regex(AGENT_TEMPLATE_NAME_RE),
-    /** When to use it (trimmed, as a template file's). */
-    description: z.string().trim().min(1).max(4096),
-})
-    .strict();
-const UpdateBody = z
-    .object({
-    /** The whole definition (the `AgentTemplate` shape), validated like a template file. */
-    definition: z.record(z.string(), z.unknown()),
-    /** The `version` the editor read; another one -> 409 `agent_template.version_conflict`. */
-    expectedVersion: z.number().int().min(1),
-})
-    .strict();
-class AgentTemplateIdParams extends createZodDto(IdParams, "AgentTemplateIdParams") {
+import { AgentTemplateIdParams, SaveAsAgentIdParams, SaveAsTemplateBody, AgentTemplateShareableBody as ShareableBodySchema, AgentTemplateUpdateBody as UpdateBodySchema, } from "./templates.schemas.js";
+const ShareableBody = ShareableBodySchema;
+const UpdateBody = UpdateBodySchema;
+class AgentTemplateIdParamsDto extends createZodDto(AgentTemplateIdParams, "AgentTemplateIdParams") {
 }
-class SaveAsAgentIdParams extends createZodDto(AgentIdParams, "SaveAsAgentIdParams") {
+class SaveAsAgentIdParamsDto extends createZodDto(SaveAsAgentIdParams, "SaveAsAgentIdParams") {
 }
 class AgentTemplateShareableBody extends createZodDto(ShareableBody, "AgentTemplateShareableBody") {
 }
-class SaveAsTemplateBody extends createZodDto(SaveAsBody, "SaveAsTemplateBody") {
+class SaveAsTemplateBodyDto extends createZodDto(SaveAsTemplateBody, "SaveAsTemplateBody") {
 }
 class AgentTemplateUpdateBody extends createZodDto(UpdateBody, "AgentTemplateUpdateBody") {
 }
@@ -128,14 +110,14 @@ __decorate([
     OrgAction("agents.create"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, ZParam(AgentTemplateIdParams))
+    __param(2, ZParam(AgentTemplateIdParamsDto))
 ], AgentTemplatesController.prototype, "get", null);
 __decorate([
     Put(":id"),
     OrgAction("agents.manage"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, ZParam(AgentTemplateIdParams)),
+    __param(2, ZParam(AgentTemplateIdParamsDto)),
     __param(3, ZBody(AgentTemplateUpdateBody))
 ], AgentTemplatesController.prototype, "update", null);
 __decorate([
@@ -143,21 +125,21 @@ __decorate([
     OrgAction("agents.manage"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, ZParam(AgentTemplateIdParams))
+    __param(2, ZParam(AgentTemplateIdParamsDto))
 ], AgentTemplatesController.prototype, "deletePreview", null);
 __decorate([
     Delete(":id"),
     OrgAction("agents.manage"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, ZParam(AgentTemplateIdParams))
+    __param(2, ZParam(AgentTemplateIdParamsDto))
 ], AgentTemplatesController.prototype, "remove", null);
 __decorate([
     Put(":id/shareable"),
     OrgAction("agents.manage"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, ZParam(AgentTemplateIdParams)),
+    __param(2, ZParam(AgentTemplateIdParamsDto)),
     __param(3, ZBody(AgentTemplateShareableBody))
 ], AgentTemplatesController.prototype, "setShareable", null);
 AgentTemplatesController = __decorate([
@@ -191,8 +173,8 @@ __decorate([
     OrgAction("agents.manage"),
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
-    __param(2, ZParam(SaveAsAgentIdParams)),
-    __param(3, ZBody(SaveAsTemplateBody))
+    __param(2, ZParam(SaveAsAgentIdParamsDto)),
+    __param(3, ZBody(SaveAsTemplateBodyDto))
 ], AgentSaveAsTemplateController.prototype, "saveAs", null);
 AgentSaveAsTemplateController = __decorate([
     Controller("api/v1/orgs/:orgId/agents"),

package/dist/agents/templates.schemas.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import type { RouteSchemas } from "../platform/route-schemas.js";
+export declare const AgentTemplateIdParams: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const SaveAsAgentIdParams: z.ZodObject<{
+    agentId: z.ZodString;
+}, z.core.$strip>;
+export declare const SaveAsTemplateBody: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strict>;
+export declare const AgentTemplateShareableBody: z.ZodObject<{
+    shareable: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const AgentTemplateUpdateBody: z.ZodObject<{
+    definition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    expectedVersion: z.ZodNumber;
+}, z.core.$strict>;
+export declare const AGENT_TEMPLATE_ROUTES: readonly RouteSchemas[];

package/dist/agents/templates.schemas.js

@@ -0,0 +1,45 @@
+import { AGENT_TEMPLATE_NAME_RE } from "@capybara-hq/plugin-sdk";
+import { z } from "zod";
+export const AgentTemplateIdParams = z.object({ id: z.string().min(1).max(100) });
+export const SaveAsAgentIdParams = z.object({ agentId: z.string().min(1).max(100) });
+export const SaveAsTemplateBody = z
+    .object({
+    /** The bare template name (the template name rule); unique in the org's usable set. */
+    name: z.string().regex(AGENT_TEMPLATE_NAME_RE),
+    /** When to use it (trimmed, as a template file's). */
+    description: z.string().trim().min(1).max(4096),
+})
+    .strict();
+export const AgentTemplateShareableBody = z.object({ shareable: z.boolean() }).strict();
+export const AgentTemplateUpdateBody = z
+    .object({
+    /** The whole definition (the `AgentTemplate` shape), validated like a template file. */
+    definition: z.record(z.string(), z.unknown()),
+    /** The `version` the editor read; another one -> 409 `agent_template.version_conflict`. */
+    expectedVersion: z.number().int().min(1),
+})
+    .strict();
+export const AGENT_TEMPLATE_ROUTES = [
+    { route: "GET /api/v1/orgs/:orgId/agent-templates" },
+    { route: "GET /api/v1/orgs/:orgId/agent-templates/:id", params: AgentTemplateIdParams },
+    {
+        route: "POST /api/v1/orgs/:orgId/agents/:agentId/save-as-template",
+        params: SaveAsAgentIdParams,
+        body: SaveAsTemplateBody,
+    },
+    {
+        route: "PUT /api/v1/orgs/:orgId/agent-templates/:id",
+        params: AgentTemplateIdParams,
+        body: AgentTemplateUpdateBody,
+    },
+    {
+        route: "GET /api/v1/orgs/:orgId/agent-templates/:id/delete-preview",
+        params: AgentTemplateIdParams,
+    },
+    { route: "DELETE /api/v1/orgs/:orgId/agent-templates/:id", params: AgentTemplateIdParams },
+    {
+        route: "PUT /api/v1/orgs/:orgId/agent-templates/:id/shareable",
+        params: AgentTemplateIdParams,
+        body: AgentTemplateShareableBody,
+    },
+];

package/dist/background/background.controller.js

@@ -13,9 +13,10 @@ import { CurrentPrincipal, patTokenId, requireUser, } from "../identity/principa
 import { createZodDto } from "../infra/validation/create-zod-dto.js";
 import { ZParam, ZQuery } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
+import { BackgroundConversationParams, BackgroundTaskParams } from "./background.schemas.js";
 import { BackgroundTasks, OUTPUT_TAIL_MAX_BYTES, } from "./tasks.service.js";
-const ConversationParams = z.object({ id: z.string().min(1).max(100) });
-const TaskParams = z.object({ id: z.string().min(1).max(100), taskId: z.string().min(1).max(100) });
+const ConversationParams = BackgroundConversationParams;
+const TaskParams = BackgroundTaskParams;
 const OutputQuery = z.object({
     tail: z.coerce.number().int().min(1).max(OUTPUT_TAIL_MAX_BYTES).default(OUTPUT_TAIL_MAX_BYTES),
 });

package/dist/background/background.schemas.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import type { RouteSchemas } from "../platform/route-schemas.js";
+export declare const BackgroundConversationParams: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const BackgroundTaskParams: z.ZodObject<{
+    id: z.ZodString;
+    taskId: z.ZodString;
+}, z.core.$strip>;
+export declare const BACKGROUND_ROUTES: readonly RouteSchemas[];

package/dist/background/background.schemas.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export const BackgroundConversationParams = z.object({ id: z.string().min(1).max(100) });
+export const BackgroundTaskParams = z.object({
+    id: z.string().min(1).max(100),
+    taskId: z.string().min(1).max(100),
+});
+export const BACKGROUND_ROUTES = [
+    {
+        route: "GET /api/v1/orgs/:orgId/conversations/:id/background-tasks",
+        params: BackgroundConversationParams,
+    },
+    {
+        route: "POST /api/v1/orgs/:orgId/conversations/:id/background-tasks/:taskId/stop",
+        params: BackgroundTaskParams,
+    },
+];

package/dist/background/tasks.service.d.ts

@@ -61,7 +61,7 @@ export declare class BackgroundTasks {
      * stop already claimed the task (or the task is a reservation still launching, which its launch
      * then kills); a stop that fails throws. Writes the `background_task.stopped` audit event.
      */
-    stop(orgId: string, conversationId: string, accountId: string, taskId: string, actorTokenId?: string): Promise<BackgroundTaskView>;
+    stop(orgId: string, conversationId: string, accountId: string, taskId: string, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<BackgroundTaskView>;
     /**
      * Whether the task's environment may still be used by its conversation's owner (the access
      * re-check every sandbox tool call makes); when it may not, the live read is skipped.

package/dist/background/tasks.service.js

@@ -100,7 +100,7 @@ let BackgroundTasks = class BackgroundTasks {
      * stop already claimed the task (or the task is a reservation still launching, which its launch
      * then kills); a stop that fails throws. Writes the `background_task.stopped` audit event.
      */
-    async stop(orgId, conversationId, accountId, taskId, actorTokenId) {
+    async stop(orgId, conversationId, accountId, taskId, actorTokenId, auditDetail) {
         const task = await this.owned(orgId, conversationId, accountId, taskId);
         const after = await this.stopper.stop(task, "person");
         await audit(this.db.db, {
@@ -109,7 +109,12 @@ let BackgroundTasks = class BackgroundTasks {
             orgId,
             action: "background_task.stopped",
             target: task.id,
-            detail: { taskId: task.id, conversationId: task.conversationId, status: after.status },
+            detail: {
+                taskId: task.id,
+                conversationId: task.conversationId,
+                status: after.status,
+                ...auditDetail,
+            },
         });
         return this.view(after, conversationId);
     }