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

package/dist/platform/ops/agent-templates.ops.js

@@ -12,21 +12,29 @@ import { z } from "zod";
 import { AgentsService } from "../../agents/agents.service.js";
 import { OrgAgentTemplates } from "../../agents/org-templates.js";
 import { AgentTemplatesService } from "../../agents/templates.js";
+import { AgentTemplateIdParams, AgentTemplateShareableBody, AgentTemplateUpdateBody, SaveAsAgentIdParams, SaveAsTemplateBody, } from "../../agents/templates.schemas.js";
+import { OwnedItems } from "../../catalog/owned-items.js";
 import { defineOperation } from "../operation.js";
 import { PlatformOperations } from "../registry.js";
-import { asToolError, viaAgent } from "./errors.js";
+import { precheckBy, viaAgent } from "./errors.js";
 import { named, orElse } from "./summary.js";
+const TemplateId = AgentTemplateIdParams.shape.id;
 /** Agent template operations of the `Platform` tool (spec §7). */
 let AgentTemplatesOperations = class AgentTemplatesOperations {
     registry;
     templates;
     orgTemplates;
     agents;
-    constructor(registry, templates, orgTemplates, agents) {
+    owned;
+    constructor(registry, templates, orgTemplates, agents, owned) {
         this.registry = registry;
         this.templates = templates;
         this.orgTemplates = orgTemplates;
         this.agents = agents;
+        this.owned = owned;
+    }
+    templateName(ctx, id) {
+        return orElse(async () => named((await this.orgTemplates.detail(ctx.orgId, id)).name), id);
     }
     onModuleInit() {
         this.registry.register([
@@ -43,25 +51,23 @@ let AgentTemplatesOperations = class AgentTemplatesOperations {
             defineOperation({
                 id: "agent-templates.get",
                 description: "Read one agent template with its definition (model tier, tools, skills, connectors it needs). Takes the template id from agent-templates.list.",
-                input: z.object({ templateId: z.string().min(1).max(100) }).strict(),
+                input: z.object({ templateId: AgentTemplateIdParams.shape.id }).strict(),
                 example: { templateId: "5d0c7a52-3a0e-4f0a-bd0a-0f8c3d2a9e10" },
                 authz: { orgAction: "agents.create" },
                 mirrors: ["GET /api/v1/orgs/:orgId/agent-templates/:id"],
+                renames: { templateId: "id" },
                 confirm: "read",
-                run: async (input, ctx) => asToolError(async () => ({
+                run: async (input, ctx) => ({
                     template: await this.orgTemplates.detail(ctx.orgId, input.templateId),
-                })),
+                }),
             }),
             defineOperation({
                 id: "agent-templates.save",
                 description: "Save an agent of the org as an org agent template under a new name, so members can create their own copy from it. Credentials and per-person settings are not carried over; the result lists what was omitted.",
-                input: z
-                    .object({
-                    agentId: z.string().min(1).max(100),
-                    name: z.string().min(1).max(80),
-                    description: z.string().min(1).max(1024),
-                })
-                    .strict(),
+                input: SaveAsAgentIdParams.extend({
+                    name: SaveAsTemplateBody.shape.name.min(1).max(80),
+                    description: SaveAsTemplateBody.shape.description.max(1024),
+                }).strict(),
                 example: {
                     agentId: "7c1a5b0e-9a53-4c6b-8d64-2f5a1b0c3e77",
                     name: "support-triage",
@@ -77,7 +83,180 @@ let AgentTemplatesOperations = class AgentTemplatesOperations {
                         en: `Save agent "${source}" as org template "${named(i.name)}"`,
                     };
                 },
-                run: async (input, ctx) => asToolError(() => this.orgTemplates.saveAs(ctx.orgId, ctx.actorAccountId, input.agentId, { name: input.name, description: input.description }, undefined, viaAgent("agent-templates.save", ctx))),
+                run: async (input, ctx) => this.orgTemplates.saveAs(ctx.orgId, ctx.actorAccountId, input.agentId, { name: input.name, description: input.description }, undefined, viaAgent("agent-templates.save", ctx)),
+            }),
+            defineOperation({
+                id: "agent-templates.update",
+                description: "Save a new version of an org agent template (org admins): send the whole definition as agent-templates.get returned it, changed as wanted, and the version you read. The name cannot change. Agents already created from the template keep their definition. A version that is no longer current is refused: read the template again first.",
+                input: z
+                    .object({
+                    templateId: TemplateId,
+                    version: AgentTemplateUpdateBody.shape.expectedVersion,
+                    definition: z
+                        .record(z.string().max(200), z.unknown())
+                        .refine((v) => JSON.stringify(v).length <= 500_000, {
+                        message: "The definition is too large",
+                    }),
+                })
+                    .strict(),
+                example: {
+                    templateId: "5d0c7a52-3a0e-4f0a-bd0a-0f8c3d2a9e10",
+                    version: 2,
+                    definition: { name: "support-triage", description: "Triages support requests." },
+                },
+                authz: { orgAction: "agents.manage" },
+                mirrors: ["PUT /api/v1/orgs/:orgId/agent-templates/:id"],
+                renames: { templateId: "id", version: "expectedVersion" },
+                confirm: "org",
+                errors: [
+                    {
+                        code: "agent_template.version_conflict",
+                        next: "The template changed since you read it: read it again with agent-templates.get, then send its current version.",
+                    },
+                    {
+                        code: "catalog.not_owned",
+                        next: "Only an agent template the org created can be changed here; a plugin's template or a copy of another owner's is not the org's to change.",
+                    },
+                    {
+                        code: "component.not_found",
+                        next: "Check the template id with agent-templates.list; this org cannot use that template.",
+                    },
+                    {
+                        code: "validation_failed",
+                        next: "The definition is not a valid agent template, or its name changed; fix it as the message says.",
+                    },
+                ],
+                precheck: async (i, ctx) => {
+                    const found = await precheckBy(() => this.orgTemplates.detail(ctx.orgId, i.templateId));
+                    if (!found.ok)
+                        return found;
+                    const t = await this.orgTemplates.detail(ctx.orgId, i.templateId);
+                    return t.owned
+                        ? { ok: true }
+                        : {
+                            ok: false,
+                            code: "catalog.not_owned",
+                            message: "The org does not own this template",
+                        };
+                },
+                summary: async (i, ctx) => {
+                    const n = await this.templateName(ctx, i.templateId);
+                    return {
+                        zh: `保存组织智能体模板「${n}」的新版本（基于版本 ${i.version}）`,
+                        en: `Save a new version of org agent template "${n}" (from version ${i.version})`,
+                    };
+                },
+                run: async (input, ctx) => ({
+                    template: await this.orgTemplates.update(ctx.orgId, ctx.actorAccountId, input.templateId, { definition: input.definition, expectedVersion: input.version }, undefined, viaAgent("agent-templates.update", ctx)),
+                }),
+            }),
+            defineOperation({
+                id: "agent-templates.delete-preview",
+                description: "Preview deleting an org agent template (org admins): whether it is removed or handed to the platform because another org uses it, and which of the org's agents were created from it. Show it to the person before agent-templates.delete.",
+                input: z.object({ templateId: TemplateId }).strict(),
+                example: { templateId: "5d0c7a52-3a0e-4f0a-bd0a-0f8c3d2a9e10" },
+                authz: { orgAction: "agents.manage" },
+                mirrors: ["GET /api/v1/orgs/:orgId/agent-templates/:id/delete-preview"],
+                renames: { templateId: "id" },
+                confirm: "read",
+                errors: [
+                    {
+                        code: "catalog.not_owned",
+                        next: "Only an agent template the org created can be changed here; a plugin's template or a copy of another owner's is not the org's to change.",
+                    },
+                    {
+                        code: "component.not_found",
+                        next: "Check the template id with agent-templates.list; this org cannot use that template.",
+                    },
+                ],
+                run: async (input, ctx) => ({
+                    preview: await this.owned.previewAgentTemplateDelete(ctx.orgId, input.templateId),
+                }),
+            }),
+            defineOperation({
+                id: "agent-templates.delete",
+                description: "Delete an org agent template (org admins). A template another org uses is handed to the platform instead of removed; agents created from it keep working. Read agent-templates.delete-preview first and show it to the person.",
+                input: z.object({ templateId: TemplateId }).strict(),
+                example: { templateId: "5d0c7a52-3a0e-4f0a-bd0a-0f8c3d2a9e10" },
+                authz: { orgAction: "agents.manage" },
+                mirrors: ["DELETE /api/v1/orgs/:orgId/agent-templates/:id"],
+                renames: { templateId: "id" },
+                confirm: "org",
+                errors: [
+                    {
+                        code: "catalog.not_owned",
+                        next: "Only an agent template the org created can be changed here; a plugin's template or a copy of another owner's is not the org's to change.",
+                    },
+                    {
+                        code: "component.not_found",
+                        next: "Check the template id with agent-templates.list; this org cannot use that template.",
+                    },
+                ],
+                precheck: (i, ctx) => precheckBy(() => this.owned.previewAgentTemplateDelete(ctx.orgId, i.templateId)),
+                summary: async (i, ctx) => {
+                    const n = await this.templateName(ctx, i.templateId);
+                    const p = await orElse(() => this.owned.previewAgentTemplateDelete(ctx.orgId, i.templateId), null);
+                    const handed = p?.outcome === "transferred";
+                    return {
+                        zh: `删除组织智能体模板「${n}」${handed ? "；其他组织在用，将转为平台模板" : ""}`,
+                        en: `Delete org agent template "${n}"${handed ? "; another org uses it, so it becomes a platform template" : ""}`,
+                    };
+                },
+                run: async (input, ctx) => ({
+                    id: input.templateId,
+                    outcome: await this.owned.deleteAgentTemplate(ctx.orgId, ctx.actorAccountId, input.templateId, { auditDetail: viaAgent("agent-templates.delete", ctx) }),
+                }),
+            }),
+            defineOperation({
+                id: "agent-templates.set-shareable",
+                description: "Set whether an org agent template may be shared with other orgs (org admins). Only the org's own templates can be changed; a plugin's template cannot.",
+                input: z
+                    .object({ templateId: TemplateId, shareable: AgentTemplateShareableBody.shape.shareable })
+                    .strict(),
+                example: { templateId: "5d0c7a52-3a0e-4f0a-bd0a-0f8c3d2a9e10", shareable: true },
+                authz: { orgAction: "agents.manage" },
+                mirrors: ["PUT /api/v1/orgs/:orgId/agent-templates/:id/shareable"],
+                renames: { templateId: "id" },
+                confirm: "org",
+                errors: [
+                    {
+                        code: "catalog.not_owned",
+                        next: "Only an agent template the org created can be changed here; a plugin's template or a copy of another owner's is not the org's to change.",
+                    },
+                    {
+                        code: "component.not_found",
+                        next: "Check the template id with agent-templates.list; this org cannot use that template.",
+                    },
+                ],
+                precheck: async (i, ctx) => {
+                    const found = await precheckBy(() => this.orgTemplates.detail(ctx.orgId, i.templateId));
+                    if (!found.ok)
+                        return found;
+                    const t = await this.orgTemplates.detail(ctx.orgId, i.templateId);
+                    return t.owned
+                        ? { ok: true }
+                        : {
+                            ok: false,
+                            code: "catalog.not_owned",
+                            message: "The org does not own this template",
+                        };
+                },
+                summary: async (i, ctx) => {
+                    const n = await this.templateName(ctx, i.templateId);
+                    return i.shareable
+                        ? {
+                            zh: `允许把组织智能体模板「${n}」共享给其他组织`,
+                            en: `Allow org agent template "${n}" to be shared with other orgs`,
+                        }
+                        : {
+                            zh: `不再把组织智能体模板「${n}」共享给其他组织`,
+                            en: `Stop sharing org agent template "${n}" with other orgs`,
+                        };
+                },
+                run: async (input, ctx) => {
+                    await this.owned.setShareable(ctx.orgId, ctx.actorAccountId, { kind: "agent_template", id: input.templateId }, input.shareable, { auditDetail: viaAgent("agent-templates.set-shareable", ctx) });
+                    return { id: input.templateId, shareable: input.shareable };
+                },
             }),
         ]);
     }
@@ -87,6 +266,7 @@ AgentTemplatesOperations = __decorate([
     __param(0, Inject(PlatformOperations)),
     __param(1, Inject(AgentTemplatesService)),
     __param(2, Inject(OrgAgentTemplates)),
-    __param(3, Inject(AgentsService))
+    __param(3, Inject(AgentsService)),
+    __param(4, Inject(OwnedItems))
 ], AgentTemplatesOperations);
 export { AgentTemplatesOperations };

package/dist/platform/ops/agents.ops.d.ts

@@ -1,15 +1,33 @@
 import { type OnModuleInit } from "@nestjs/common";
+import { AgentProfileService } from "../../agents/agent-profile.service.js";
 import { AgentsService } from "../../agents/agents.service.js";
 import { AgentsFromTemplate } from "../../agents/from-template.service.js";
 import { OrgAgentTemplates } from "../../agents/org-templates.js";
+import { PendingConnectorsService } from "../../agents/pending-connectors.service.js";
+import { CatalogRequestsService } from "../../catalog/requests.service.js";
+import { KernelDb } from "../../infra/database/kernel-db.js";
+import { ProviderRegistry } from "../../runtime/providers.js";
+import { ConnectorsService } from "../../tools/connectors.service.js";
 import { PlatformOperations } from "../registry.js";
 /** Agent operations of the `Platform` tool (spec §7); visibility is the person's own agents. */
 export declare class AgentsOperations implements OnModuleInit {
     private readonly registry;
     private readonly agents;
+    private readonly profiles;
     private readonly fromTemplate;
     private readonly orgTemplates;
-    constructor(registry: PlatformOperations, agents: AgentsService, fromTemplate: AgentsFromTemplate, orgTemplates: OrgAgentTemplates);
+    private readonly pending;
+    private readonly requests;
+    private readonly connectors;
+    private readonly providers;
+    private readonly kdb;
+    constructor(registry: PlatformOperations, agents: AgentsService, profiles: AgentProfileService, fromTemplate: AgentsFromTemplate, orgTemplates: OrgAgentTemplates, pending: PendingConnectorsService, requests: CatalogRequestsService, connectors: ConnectorsService, providers: ProviderRegistry, kdb: KernelDb);
+    /**
+     * The edit rule the service enforces, read before the card: the agent is visible, and the actor
+     * owns it or is an org admin. Returns the agent too for the checks that follow.
+     */
+    private editCheck;
+    private agentName;
     /**
      * `agents.update`'s class (spec §13): `personal` (may be remembered) only on a private agent the
      * actor owns; any other agent the actor may edit is shared, so each change is confirmed.