@capybara-hq/kernel 0.1.0-rc.6 → 0.1.0-rc.8

package/dist/agents/from-template.js

@@ -8,9 +8,9 @@ import { connectorTemplateState } from "../catalog/component-state.js";
 import { invocationOf, PINNED_SKILLS_LIMITS } from "../skills/catalog.js";
 import { usableSkillVersions } from "../skills/usable.js";
 import { CONTROL_OR_HIDDEN_RE } from "../text.js";
-import { AGENT_TOOL, BASH_COMPANION_TOOLS, BUILTIN, BUILTIN_TOOL_NAMES, DEFAULT_AGENT_TOOLS, } from "../tools/builtin-names.js";
+import { AGENT_BUILTIN_NAMES, AGENT_TOOL, BASH_COMPANION_TOOLS, BUILTIN, BUILTIN_TOOL_NAMES, } from "../tools/builtin-names.js";
 import { canonicalJson } from "../tools/canonical-json.js";
-import { AgentDefinitionSchema, SUBAGENT_NAME_RE, SUBAGENT_ROSTER_MAX, } from "./definition.js";
+import { AgentDefinitionSchema, builtinDisabled, canonicalDisabledTools, connectorToolDisabled, extensionToolDisabled, SUBAGENT_NAME_RE, SUBAGENT_ROSTER_MAX, } from "./definition.js";
 import { INSTRUCTION_FILE_LIMITS, INSTRUCTION_FILE_NAME_RE, joinInstructionFiles, } from "./instruction-files.js";
 import { sanitizeEndpoint } from "./org-templates.js";
 import { PROFILE_LIMITS, ProfileInputSchema } from "./profile.js";
@@ -259,34 +259,38 @@ export async function planFromTemplate(db, orgId, row, opts) {
     });
     if (t.maxSteps !== undefined)
         dropped.push("maxSteps");
-    // tools: builtin and plugin keys usable in the org (P4-5)
+    // tools (tools default-on spec §3): the new agent has every tool the org offers; the template
+    // turns off its `disallowedTools` and, with a `tools` allowlist, the builtins it does not list
+    // (extension and connector tools follow the org); its keys are listed for the preview (P4-5)
     const disallowed = new Set(t.disallowedTools ?? []);
-    const tools = [];
+    const disabled = [];
     const builtinNames = new Set(BUILTIN_TOOL_NAMES);
-    if (t.tools === undefined) {
-        for (const ref of DEFAULT_AGENT_TOOLS) {
-            if (ref.kind === "builtin" && !disallowed.has(ref.name)) {
-                tools.push(ref);
-                item("tool", ref.name, "carried", "default");
-            }
+    const agentBuiltins = new Set(AGENT_BUILTIN_NAMES);
+    const offBuiltin = (name) => {
+        if (agentBuiltins.has(name) && !builtinDisabled(disabled, name)) {
+            disabled.push({ kind: "builtin", name });
         }
-    }
-    else {
+    };
+    const offExtensionTool = (plugin, name) => disabled.push({ kind: "plugin", plugin, tools: [name] });
+    // a template that describes sub-agents keeps `Agent` (ruling P4-T3-5) unless it disallows it
+    const sub0 = t.subagents;
+    const describesSubagents = sub0 !== undefined &&
+        ((sub0.types ?? []).length > 0 || (sub0.inline ?? []).length > 0 || sub0.general === true);
+    if (t.tools !== undefined) {
+        const listed = new Set();
         for (const key of t.tools) {
             if (disallowed.has(key))
                 continue;
             const parsed = parseToolKey(key);
             if (parsed?.kind === "builtin" && builtinNames.has(parsed.name)) {
-                tools.push({ kind: "builtin", name: parsed.name });
+                listed.add(parsed.name);
                 item("tool", key, "carried");
             }
             else if (parsed?.kind === "extension") {
                 const ok = opts.enabledPlugins.has(parsed.plugin) &&
                     opts.pluginTools.some((x) => x.plugin === parsed.plugin && x.name === parsed.tool);
-                if (ok) {
-                    tools.push({ kind: "plugin", plugin: parsed.plugin, name: parsed.tool });
+                if (ok)
                     item("tool", key, "carried");
-                }
                 else
                     item("tool", key, "unavailable", "plugin_unavailable");
             }
@@ -296,6 +300,20 @@ export async function planFromTemplate(db, orgId, row, opts) {
             else
                 item("tool", key, "unavailable", "unknown_tool");
         }
+        if (describesSubagents)
+            listed.add(AGENT_TOOL);
+        // `TaskOutput` / `TaskStop` follow `Bash`
+        for (const name of AGENT_BUILTIN_NAMES)
+            if (!listed.has(name))
+                offBuiltin(name);
+    }
+    for (const key of disallowed) {
+        const parsed = parseToolKey(key);
+        if (parsed?.kind === "builtin")
+            offBuiltin(parsed.name);
+        else if (parsed?.kind === "extension")
+            offExtensionTool(parsed.plugin, parsed.tool);
+        // a connector key is matched against the bound connectors below
     }
     // skills: by name against the org's usable skills (P4-5); every name gets its item
     const usable = await usableSkillVersions(db, orgId);
@@ -410,11 +428,14 @@ export async function planFromTemplate(db, orgId, row, opts) {
         // `disallowedTools` naming its tools narrows it (P4-5)
         const allowed = names.filter((n) => !disallowed.has(connectorToolKey(first.slug, n)));
         if (allowed.length === 0) {
+            // the connector is the org's, so it is on by default: its disallowed tools are turned off
+            const off = first.tools.filter((n) => disallowed.has(connectorToolKey(first.slug, n)));
+            if (off.length > 0 && !slugs.has(first.id)) {
+                disabled.push({ kind: "connector", connectorId: first.id, tools: off });
+            }
             item("connector", first.name, "unavailable", "disallowed");
             continue;
         }
-        const narrowed = allowed.length !== names.length;
-        const refTools = entry.tools === undefined && !narrowed ? "all" : allowed;
         for (const [name, p] of Object.entries(entry.policies ?? {})) {
             if (!allowed.includes(name)) {
                 dropped.push(`connectors.${key}.policies.${name}`);
@@ -425,14 +446,20 @@ export async function planFromTemplate(db, orgId, row, opts) {
             if (prev === undefined || RANK[p] > RANK[prev])
                 connectorPolicies[k] = p;
         }
-        const existing = tools.find((r) => r.kind === "connector" && r.connectorId === first.id);
-        if (existing === undefined) {
-            tools.push({ kind: "connector", connectorId: first.id, tools: refTools });
-        }
-        else if (existing.tools !== "all") {
-            existing.tools =
-                refTools === "all" ? "all" : [...new Set([...existing.tools, ...refTools])];
+        // the bound connector's tools the entry leaves out (or the template disallows) are turned off;
+        // a second entry on the same connector turns on what it names (the union of the entries)
+        const prevOn = slugs.has(first.id)
+            ? first.tools.filter((n) => !connectorToolDisabled(disabled, first.id, n))
+            : [];
+        const on = new Set([...prevOn, ...allowed]);
+        const off = first.tools.filter((n) => !on.has(n));
+        for (let i = disabled.length - 1; i >= 0; i--) {
+            const r = disabled[i];
+            if (r?.kind === "connector" && r.connectorId === first.id)
+                disabled.splice(i, 1);
         }
+        if (off.length > 0)
+            disabled.push({ kind: "connector", connectorId: first.id, tools: off });
         slugs.set(first.id, first);
         item("connector", first.name, "carried", made.length > 1 ? "several" : undefined);
     }
@@ -528,32 +555,36 @@ export async function planFromTemplate(db, orgId, row, opts) {
         if (inline.length > 0)
             out.inline = inline;
         subagents = out;
-        // a roster needs the `Agent` tool to be offered (ruling P4-T3-5), unless the template
-        // disallows it
+        // a roster needs the `Agent` tool (ruling P4-T3-5): it is on unless the template disallows
+        // it; a template whose allowlist leaves it out still gets it (kept on above)
         const describes = templateIds.length > 0 || inline.length > 0 || sub.general === true;
         if (describes &&
-            !disallowed.has(AGENT_TOOL) &&
-            !tools.some((r) => r.kind === "builtin" && r.name === AGENT_TOOL)) {
-            tools.push({ kind: "builtin", name: AGENT_TOOL });
+            t.tools !== undefined &&
+            !t.tools.includes(AGENT_TOOL) &&
+            !builtinDisabled(disabled, AGENT_TOOL)) {
             item("tool", AGENT_TOOL, "carried", "subagents");
         }
     }
-    // the tool keys the agent has, for policies and inline allowlists
+    // the tool keys the agent has (of those the template can name), for policies and inline
+    // allowlists: its builtins, the enabled extensions' tools and the bound connectors' tools, each
+    // unless turned off
     const keys = new Set();
-    for (const r of tools) {
-        if (r.kind === "builtin") {
-            keys.add(r.name);
-            if (r.name === BUILTIN.Bash)
-                for (const c of BASH_COMPANION_TOOLS)
-                    keys.add(c);
+    for (const name of AGENT_BUILTIN_NAMES) {
+        if (builtinDisabled(disabled, name))
+            continue;
+        keys.add(name);
+        if (name === BUILTIN.Bash)
+            for (const c of BASH_COMPANION_TOOLS)
+                keys.add(c);
+    }
+    for (const x of opts.pluginTools) {
+        if (opts.enabledPlugins.has(x.plugin) && !extensionToolDisabled(disabled, x.plugin, x.name)) {
+            keys.add(extensionToolKey(x.plugin, x.name));
         }
-        else if (r.kind === "plugin")
-            keys.add(extensionToolKey(r.plugin, r.name));
-        else {
-            const c = slugs.get(r.connectorId);
-            if (!c)
-                continue;
-            for (const n of r.tools === "all" ? c.tools : r.tools)
+    }
+    for (const c of slugs.values()) {
+        for (const n of c.tools) {
+            if (!connectorToolDisabled(disabled, c.id, n))
                 keys.add(connectorToolKey(c.slug, n));
         }
     }
@@ -584,7 +615,7 @@ export async function planFromTemplate(db, orgId, row, opts) {
         ...(instructions === undefined ? { instructionFiles: files } : { instructions }),
         fallback: null,
         fallbackParams: {},
-        tools,
+        disabledTools: canonicalDisabledTools(disabled),
         toolPolicies,
         ...((orgSkills.length > 0 || pinned.length > 0) && {
             skills: { orgSkills, ...(pinned.length > 0 && { pinned }) },

package/dist/agents/from-template.service.d.ts

@@ -54,6 +54,18 @@ export declare class AgentsFromTemplate {
     private template;
     private plan;
     preview(orgId: string, templateId: string): Promise<TemplatePreview>;
+    /**
+     * The template and the plan of a create, read only: 404 `component.not_found` for a template
+     * not usable here, 409 `agent.template_preview_stale` for a hash that no longer matches, and
+     * `agent.model_unavailable` when no model resolves.
+     */
+    private checked;
+    /**
+     * The read-only checks of {@link create}, for the `Platform` tool's precheck (before the card):
+     * throws the `ApiError` the create would for an unknown template, a stale preview hash or no
+     * model.
+     */
+    check(orgId: string, req: Pick<CreateFromTemplateRequest, "templateId" | "previewHash" | "model">): Promise<void>;
     create(orgId: string, actorAccountId: string, req: CreateFromTemplateRequest, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<{
         agent: AgentView;
     }>;

package/dist/agents/from-template.service.js

@@ -99,7 +99,12 @@ let AgentsFromTemplate = class AgentsFromTemplate {
             previewHash: plan.hash,
         };
     }
-    async create(orgId, actorAccountId, req, actorTokenId, auditDetail) {
+    /**
+     * The template and the plan of a create, read only: 404 `component.not_found` for a template
+     * not usable here, 409 `agent.template_preview_stale` for a hash that no longer matches, and
+     * `agent.model_unavailable` when no model resolves.
+     */
+    async checked(orgId, req) {
         const row = await this.template(orgId, req.templateId);
         const plan = await this.plan(orgId, row, req.model);
         // the base part always; the automatic model's part only when the person chose none, so a
@@ -111,12 +116,24 @@ let AgentsFromTemplate = class AgentsFromTemplate {
         if (plan.model === null) {
             throw new ApiError("agent.model_unavailable", "No model is available for the new agent");
         }
+        return { row, plan, model: plan.model };
+    }
+    /**
+     * The read-only checks of {@link create}, for the `Platform` tool's precheck (before the card):
+     * throws the `ApiError` the create would for an unknown template, a stale preview hash or no
+     * model.
+     */
+    async check(orgId, req) {
+        await this.checked(orgId, req);
+    }
+    async create(orgId, actorAccountId, req, actorTokenId, auditDetail) {
+        const { row, plan, model } = await this.checked(orgId, req);
         const { agent, role } = await this.agents.createFromTemplate(orgId, actorAccountId, {
             definition: {
                 ...plan.definition,
                 name: req.name,
-                model: plan.model.ref,
-                modelParams: plan.model.params,
+                model: model.ref,
+                modelParams: model.params,
             },
             visibility: req.visibility ?? "private",
             ...(req.members !== undefined && { memberIds: req.members }),

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

@@ -4,7 +4,7 @@ import { ExtensionDisplayNames } from "../extensions/display-name.js";
 import { type Principal } from "../identity/principal.js";
 import { type OrgContext } from "../orgs/org.guard.js";
 import { type KernelModelInfo, ProviderRegistry, type ProviderStatus } from "../runtime/providers.js";
-declare const ModelsQuery: z.ZodObject<{
+export declare const ModelsQuery: z.ZodObject<{
     kind: z.ZodOptional<z.ZodEnum<{
         chat: "chat";
         embedding: "embedding";
@@ -45,4 +45,3 @@ export declare class ModelsController {
         })[];
     }>;
 }
-export {};

package/dist/agents/models.controller.js

@@ -15,7 +15,7 @@ import { createZodDto } from "../infra/validation/create-zod-dto.js";
 import { ZQuery } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
 import { ProviderRegistry, } from "../runtime/providers.js";
-const ModelsQuery = z.object({
+export const ModelsQuery = z.object({
     kind: z
         .enum([
         "chat",

package/dist/agents/org-templates.d.ts

@@ -4,6 +4,7 @@ import type { KernelSchemaDb } from "../db/kernel-schema.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
 import { OrgLock } from "../orgs/org-lock.js";
+import { ToolRegistry } from "../tools/registry.js";
 import { AgentLookup, type AgentView } from "./agent-lookup.js";
 import { type AgentTemplateView } from "./templates.js";
 /** A template with its definition, as `GET orgs/:orgId/agent-templates/:id` answers. */
@@ -96,7 +97,12 @@ export declare function canonicalEndpoints(template: AgentTemplate): AgentTempla
 export declare function templateFromAgent(db: KernelSchemaDb, orgId: string, agent: AgentView, meta: {
     name: string;
     description: string;
-}): Promise<{
+}, 
+/** The extension tools loaded on this replica (a wholly turned-off extension's tools). */
+extensionTools?: readonly {
+    plugin: string;
+    name: string;
+}[]): Promise<{
     template: AgentTemplate;
     omitted: SaveAsOmission[];
 }>;
@@ -110,7 +116,11 @@ export declare class OrgAgentTemplates {
     private readonly orgLock;
     private readonly agents;
     readonly txHost: TransactionHost;
-    constructor(kdb: KernelDb, orgLock: Pick<OrgLock, "lockAndAuthorize">, agents: Pick<AgentLookup, "view">, txHost: TransactionHost);
+    /** The extension tools loaded here (a wholly turned-off extension saved as its tool keys). */
+    private readonly tools;
+    constructor(kdb: KernelDb, orgLock: Pick<OrgLock, "lockAndAuthorize">, agents: Pick<AgentLookup, "view">, txHost: TransactionHost, 
+    /** The extension tools loaded here (a wholly turned-off extension saved as its tool keys). */
+    tools: Pick<ToolRegistry, "extensionToolSpecs">);
     private get db();
     /**
      * 另存为模板 (ruling P4-9): the org's live agent `agentId` (any one: an org admin may edit every
@@ -154,7 +164,7 @@ export declare class OrgAgentTemplates {
     update(orgId: string, actor: string, id: string, body: {
         definition: Record<string, unknown>;
         expectedVersion: number;
-    }, actorTokenId?: string): Promise<AgentTemplateDetail>;
+    }, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<AgentTemplateDetail>;
     /**
      * The org's own template `id` ({@link readOwnTemplate}, the predicate `OwnedItems` shares), or
      * undefined: another org's, a plugin's, or a copy of a platform template it does not own.

package/dist/agents/org-templates.js

@@ -24,6 +24,7 @@ import { Transactional } from "../infra/database/transactional.decorator.js";
 import { OrgLock } from "../orgs/org-lock.js";
 import { skillVersionsById } from "../skills/usable.js";
 import { canonicalJson } from "../tools/canonical-json.js";
+import { ToolRegistry } from "../tools/registry.js";
 import { AgentLookup } from "./agent-lookup.js";
 import { loadTemplates, putTemplateVersionIn, readOwnTemplate, templateTypeOf, templateViewOf, usableTemplates, } from "./templates.js";
 /**
@@ -129,7 +130,9 @@ export function canonicalEndpoints(template) {
  * The template an agent is saved as (rulings P4-10, P4-11), with what was left out. Pure reads of
  * the org's state through `db`.
  */
-export async function templateFromAgent(db, orgId, agent, meta) {
+export async function templateFromAgent(db, orgId, agent, meta, 
+/** The extension tools loaded on this replica (a wholly turned-off extension's tools). */
+extensionTools = []) {
     const def = agent.definition;
     const omitted = [];
     const L = AGENT_TEMPLATE_LIMITS;
@@ -151,34 +154,57 @@ export async function templateFromAgent(db, orgId, agent, meta) {
             reason: "fallback",
         });
     }
-    // Tools: builtin and plugin tool keys; connector tools become `connectors` entries
-    const tools = [];
-    const connectorRefs = [];
-    // stored definitions are not parsed: fields with schema defaults may be missing
-    for (const r of def.tools ?? []) {
-        if (r.kind === "connector") {
-            connectorRefs.push({ connectorId: r.connectorId, tools: r.tools });
-            continue;
-        }
-        const key = r.kind === "builtin" ? r.name : extensionToolKey(r.plugin, r.name);
-        if (!TOOL_KEY_RE.test(key) || tools.includes(key))
-            continue;
-        if (tools.length >= L.tools) {
+    // Tools (tools default-on spec §3): the template turns off what the agent turns off
+    // (`disallowedTools`, builtin and extension tool keys; a wholly turned-off extension as all its
+    // loaded tools); every connector on for the agent becomes a `connectors` entry
+    const disabled = def.disabledTools ?? [];
+    const disallowedTools = [];
+    const disallow = (key) => {
+        if (!TOOL_KEY_RE.test(key) || disallowedTools.includes(key))
+            return;
+        if (disallowedTools.length >= L.tools) {
             omitted.push({ kind: "tool", name: key, reason: "limit" });
-            continue;
+            return;
+        }
+        disallowedTools.push(key);
+    };
+    for (const r of disabled) {
+        if (r.kind === "builtin")
+            disallow(r.name);
+        else if (r.kind === "plugin") {
+            const names = r.tools === "all"
+                ? extensionTools.filter((x) => x.plugin === r.plugin).map((x) => x.name)
+                : r.tools;
+            for (const n of names)
+                disallow(extensionToolKey(r.plugin, n));
         }
-        tools.push(key);
+    }
+    const liveConnectors = await db
+        .selectFrom("connectors")
+        .select(["id"])
+        .where("org_id", "=", orgId)
+        .where("status", "=", "active")
+        .where("deleted_at", "is", null)
+        .orderBy("created_at")
+        .orderBy("id")
+        .execute();
+    const connectorRefs = [];
+    for (const c of liveConnectors) {
+        const entry = disabled.find((r) => r.kind === "connector" && r.connectorId === c.id);
+        if (entry?.tools === "all")
+            continue;
+        connectorRefs.push({ connectorId: c.id, off: entry === undefined ? [] : entry.tools });
     }
     // builtin / plugin keys stay keys; a connector tool's policy goes to its connector entry by
     // tool name (`policies`), since the key embeds this org's connector slug
     const toolPolicies = {};
     const connectorPolicies = new Map();
     for (const [k, v] of Object.entries(def.toolPolicies ?? {})) {
-        if (tools.includes(k)) {
+        const parsed = parseToolKey(k);
+        if (parsed !== null && parsed.kind !== "connector" && TOOL_KEY_RE.test(k)) {
             toolPolicies[k] = v;
             continue;
         }
-        const parsed = parseToolKey(k);
         if (parsed?.kind === "connector") {
             const list = connectorPolicies.get(parsed.slug) ?? [];
             list.push({ key: k, tool: parsed.tool, policy: v });
@@ -286,10 +312,20 @@ export async function templateFromAgent(db, orgId, agent, meta) {
             omitted.push({ kind: "connector", name: id, id, reason: "unavailable" });
             continue;
         }
-        const refs = connectorRefs.filter((r) => r.connectorId === id);
-        const named = refs.some((r) => r.tools === "all")
+        const off = connectorRefs.find((r) => r.connectorId === id)?.off ?? [];
+        // some tools off: the entry names the connector's enabled tools that stay on
+        const named = off.length === 0
             ? null
-            : [...new Set(refs.flatMap((r) => r.tools))].slice(0, L.connectorTools);
+            : (await db
+                .selectFrom("connector_tools")
+                .select("name")
+                .where("connector_id", "=", id)
+                .where("status", "=", "enabled")
+                .orderBy("name")
+                .execute())
+                .map((x) => x.name)
+                .filter((n) => !off.includes(n))
+                .slice(0, L.connectorTools);
         if (c.template_id !== null) {
             // only the platform connector template is recorded, not this connector: creating an agent
             // from the template rebinds the entry to the org's oldest connector made from that
@@ -463,7 +499,7 @@ export async function templateFromAgent(db, orgId, agent, meta) {
         name: meta.name,
         description: meta.description,
         instructions: def.instructions ?? "",
-        tools,
+        ...(disallowedTools.length > 0 && { disallowedTools }),
         ...(Object.keys(toolPolicies).length > 0 && { toolPolicies }),
         model: "standard",
         modelRef: `${def.model.provider}/${def.model.model}`,
@@ -493,11 +529,15 @@ let OrgAgentTemplates = class OrgAgentTemplates {
     orgLock;
     agents;
     txHost;
-    constructor(kdb, orgLock, agents, txHost) {
+    tools;
+    constructor(kdb, orgLock, agents, txHost, 
+    /** The extension tools loaded here (a wholly turned-off extension saved as its tool keys). */
+    tools) {
         this.kdb = kdb;
         this.orgLock = orgLock;
         this.agents = agents;
         this.txHost = txHost;
+        this.tools = tools;
     }
     get db() {
         return this.kdb.db;
@@ -524,7 +564,7 @@ let OrgAgentTemplates = class OrgAgentTemplates {
             throw agentNotFound();
         const agent = await this.agents.view(agentId);
         await this.assertNameFree(orgId, meta.name);
-        const { template, omitted } = await templateFromAgent(t, orgId, agent, meta);
+        const { template, omitted } = await templateFromAgent(t, orgId, agent, meta, this.tools.extensionToolSpecs().map((x) => ({ plugin: x.plugin, name: x.spec.name })));
         const put = await putTemplateVersionIn(t, { orgId, plugin: null, catalogItemId: null, catalogVersion: null, sourceFormat: "capybara" }, template);
         await audit(t, {
             actorAccountId: actor,
@@ -641,7 +681,7 @@ let OrgAgentTemplates = class OrgAgentTemplates {
      * definition writes nothing. Not the org's own -> 409 `catalog.not_owned`; missing -> 404.
      * Agents created earlier are never touched. Audits `agent_template.updated`.
      */
-    async update(orgId, actor, id, body, actorTokenId) {
+    async update(orgId, actor, id, body, actorTokenId, auditDetail) {
         const t = this.db;
         await this.orgLock.lockAndAuthorize(orgId, actor, "agents.manage");
         const row = await this.ownRow(orgId, id, true);
@@ -671,7 +711,7 @@ let OrgAgentTemplates = class OrgAgentTemplates {
                     orgId,
                     action: "agent_template.updated",
                     target: id,
-                    detail: { name: row.name, from: row.current_version, to: put.version },
+                    detail: { name: row.name, from: row.current_version, to: put.version, ...auditDetail },
                 });
             }
             return this.detail(orgId, id);
@@ -716,7 +756,7 @@ let OrgAgentTemplates = class OrgAgentTemplates {
             orgId,
             action: "agent_template.updated",
             target: id,
-            detail: { name: row.name, platformId: row.link, from: p.current_version, to },
+            detail: { name: row.name, platformId: row.link, from: p.current_version, to, ...auditDetail },
         });
         return this.detail(orgId, id);
     }
@@ -822,6 +862,7 @@ OrgAgentTemplates = __decorate([
     __param(0, Inject(KernelDb)),
     __param(1, Inject(OrgLock)),
     __param(2, Inject(AgentLookup)),
-    __param(3, Inject(TransactionHost))
+    __param(3, Inject(TransactionHost)),
+    __param(4, Inject(ToolRegistry))
 ], OrgAgentTemplates);
 export { OrgAgentTemplates };

package/dist/agents/pending-connector-requests.d.ts

@@ -50,6 +50,8 @@ export declare class PendingConnectorRequests {
         requestedBy: string;
         actor: string;
         actorTokenId?: string | undefined;
+        /** Merged into the audit detail (a write made through the Platform tool). */
+        auditDetail?: Record<string, unknown>;
     }): Promise<{
         id: string;
         created: boolean;

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;
     }>;