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

package/dist/platform/ops/org-settings.ops.js

@@ -0,0 +1,102 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { z } from "zod";
+import { OrgSettingsPatchSchema, OrgSettingsService } from "../../orgs/settings.service.js";
+import { defineOperation } from "../operation.js";
+import { PlatformOperations } from "../registry.js";
+import { precheckBy, viaAgent } from "./errors.js";
+const PLATFORM_TOOL_NOTE = {
+    off: "The Platform tool is now off for this org: from the next call on, no Platform operation is available, including this one. An org admin can switch it back on in the organization settings on the web.",
+    "read-only": "The Platform tool is now read-only for this org: from the next call on, writes are unavailable and only reads run. An org admin can change it in the organization settings on the web.",
+};
+const show = (v) => (v === null ? "default" : JSON.stringify(v));
+/**
+ * Org settings operations of the `Platform` tool (spec §14): read the settings every member sees,
+ * and change them (org admins). The `platformTool` setting is included. A write that turns it
+ * off or to read-only is allowed once the person confirms it, and it applies to later calls: the
+ * tool reads the setting on every call, so the current run is cut off from the next call on. The
+ * result and the card say so.
+ */
+let OrgSettingsOperations = class OrgSettingsOperations {
+    registry;
+    settings;
+    constructor(registry, settings) {
+        this.registry = registry;
+        this.settings = settings;
+    }
+    onModuleInit() {
+        this.registry.register([
+            defineOperation({
+                id: "org-settings.get",
+                description: "Read this org's settings: toolSearch, locale, sandboxToolPolicy, platformTool (on, read-only or off), sandboxEgress and wakeOnBackgroundTask (absent means it follows the deployment), the deployment's sandbox egress default and the sandbox cpu / memory limits in effect.",
+                input: z.object({}).strict(),
+                example: {},
+                authz: { orgAction: "org.read" },
+                mirrors: ["GET /api/v1/orgs/:orgId/settings"],
+                confirm: "read",
+                run: async (_input, ctx) => ({
+                    settings: await this.settings.get(ctx.orgId),
+                    deployment: this.settings.deployment(),
+                    sandboxLimits: await this.settings.sandboxLimits(ctx.orgId),
+                }),
+            }),
+            defineOperation({
+                id: "org-settings.update",
+                description: "Change this org's settings (org admins). Give only the settings to change; null clears sandboxEgress or wakeOnBackgroundTask so they follow the deployment again. Setting platformTool to off or read-only takes effect from the next call and cuts this Platform tool off in the org, so say so before asking; an org admin switches it back on in the web settings.",
+                input: OrgSettingsPatchSchema.refine((i) => Object.values(i).some((v) => v !== undefined), {
+                    message: "give at least one setting",
+                }),
+                example: { toolSearch: "on" },
+                authz: { orgAction: "org.update" },
+                mirrors: ["PATCH /api/v1/orgs/:orgId/settings"],
+                confirm: "org",
+                errors: [
+                    {
+                        code: "org.sandbox_egress_not_allowed",
+                        next: "This deployment disables sandbox network access, so the org can only set sandboxEgress to none; ask the super admin to change sandbox.limits.egress.",
+                    },
+                    {
+                        code: "validation_failed",
+                        next: "Fix the setting as the message says (org-settings.get shows the current values).",
+                    },
+                ],
+                precheck: (i) => precheckBy(async () => this.settings.check(i)),
+                summary: (i) => {
+                    const parts = Object.entries(i)
+                        .filter(([, v]) => v !== undefined)
+                        .map(([k, v]) => `${k} → ${show(v)}`);
+                    const warn = i.platformTool === "off" || i.platformTool === "read-only";
+                    return {
+                        zh: `修改组织设置：${parts.join("，")}${warn
+                            ? "（之后智能体不能再用平台工具" + (i.platformTool === "off" ? "" : "写入") + "）"
+                            : ""}`,
+                        en: `Update the org settings: ${parts.join(", ")}${warn
+                            ? `; from the next call the Platform tool is ${i.platformTool === "off" ? "off" : "read-only"} in this org`
+                            : ""}`,
+                    };
+                },
+                run: async (input, ctx) => {
+                    const settings = await this.settings.update(ctx.orgId, input, ctx.actorAccountId, undefined, viaAgent("org-settings.update", ctx));
+                    const note = input.platformTool === undefined
+                        ? undefined
+                        : PLATFORM_TOOL_NOTE[settings.platformTool];
+                    return { settings, ...(note !== undefined && { note }) };
+                },
+            }),
+        ]);
+    }
+};
+OrgSettingsOperations = __decorate([
+    Injectable(),
+    __param(0, Inject(PlatformOperations)),
+    __param(1, Inject(OrgSettingsService))
+], OrgSettingsOperations);
+export { OrgSettingsOperations };

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

@@ -0,0 +1,28 @@
+import { type OnModuleInit } from "@nestjs/common";
+import { AccountsService } from "../../identity/accounts.js";
+import { SettingsService } from "../../identity/settings.js";
+import { KernelConfigService } from "../../infra/config/kernel-config.service.js";
+import { KernelDb } from "../../infra/database/kernel-db.js";
+import { MembersService } from "../../orgs/members.service.js";
+import { OrgsService } from "../../orgs/orgs.service.js";
+import { PlatformOperations } from "../registry.js";
+/**
+ * Org operations of the `Platform` tool (spec §14.2): the super admin's view of every org (list,
+ * get, the per-org limits) through their own private agent, and the conversation's org for its
+ * members (read, rename, member list). Creating, deleting and transferring an org, invitations,
+ * member role changes and removal stay on the web (human-only).
+ */
+export declare class OrgsOperations implements OnModuleInit {
+    private readonly registry;
+    private readonly orgs;
+    private readonly members;
+    private readonly settings;
+    private readonly accounts;
+    private readonly config;
+    private readonly kdb;
+    constructor(registry: PlatformOperations, orgs: OrgsService, members: MembersService, settings: SettingsService, accounts: AccountsService, config: KernelConfigService, kdb: KernelDb);
+    private org;
+    /** The actor as `OrgsService.update` takes it (it re-checks the role under the org lock). */
+    private actor;
+    onModuleInit(): void;
+}

package/dist/platform/ops/orgs.ops.js

@@ -0,0 +1,295 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { z } from "zod";
+import { limitDefaults } from "../../admin/limit-defaults.js";
+import { ApiError } from "../../errors.js";
+import { AccountsService } from "../../identity/accounts.js";
+import { DEPLOYMENT_SETTINGS_PATCH, SettingsService } from "../../identity/settings.js";
+import { KernelConfigService } from "../../infra/config/kernel-config.service.js";
+import { KernelDb } from "../../infra/database/kernel-db.js";
+import { MembersService } from "../../orgs/members.service.js";
+import { OrgUpdateBody } from "../../orgs/orgs.schemas.js";
+import { OrgsService } from "../../orgs/orgs.service.js";
+import { defineOperation } from "../operation.js";
+import { PlatformOperations } from "../registry.js";
+import { precheckBy, viaAgent } from "./errors.js";
+import { Cursor, pageOf, startOf } from "./paging.js";
+import { roleOf } from "./role.js";
+import { named, orElse } from "./summary.js";
+const PAGE = 50;
+const OrgId = z.string().min(1).max(100).describe("The org id (orgs.list).");
+/** The value types of the per-org override records of `PUT /api/v1/admin/settings`. */
+const OVERRIDES = DEPLOYMENT_SETTINGS_PATCH.shape;
+const RunConcurrency = OVERRIDES.runConcurrencyOverrides.unwrap().valueType;
+const SandboxLimits = OVERRIDES.sandboxLimitOverrides.unwrap().valueType;
+const SubagentLimits = OVERRIDES.subagentLimitOverrides.unwrap().valueType;
+/** The org's own limits (the overrides; a missing one follows the deployment default). */
+async function limitsOf(settings, orgId) {
+    const s = await settings.get();
+    return {
+        runConcurrency: s.runConcurrencyOverrides[orgId] ?? null,
+        sandbox: s.sandboxLimitOverrides[orgId] ?? null,
+        subagents: s.subagentLimitOverrides[orgId] ?? null,
+    };
+}
+/**
+ * Org operations of the `Platform` tool (spec §14.2): the super admin's view of every org (list,
+ * get, the per-org limits) through their own private agent, and the conversation's org for its
+ * members (read, rename, member list). Creating, deleting and transferring an org, invitations,
+ * member role changes and removal stay on the web (human-only).
+ */
+let OrgsOperations = class OrgsOperations {
+    registry;
+    orgs;
+    members;
+    settings;
+    accounts;
+    config;
+    kdb;
+    constructor(registry, orgs, members, settings, accounts, config, kdb) {
+        this.registry = registry;
+        this.orgs = orgs;
+        this.members = members;
+        this.settings = settings;
+        this.accounts = accounts;
+        this.config = config;
+        this.kdb = kdb;
+    }
+    async org(orgId) {
+        const o = await this.orgs.get(orgId);
+        if (!o)
+            throw new ApiError("org.not_found", "Organization not found");
+        return o;
+    }
+    /** The actor as `OrgsService.update` takes it (it re-checks the role under the org lock). */
+    async actor(ctx) {
+        const a = await this.accounts.get(ctx.actorAccountId);
+        if (!a)
+            throw new ApiError("forbidden", "Your account no longer exists");
+        return a;
+    }
+    onModuleInit() {
+        this.registry.register([
+            defineOperation({
+                id: "orgs.list",
+                description: "List every org on the platform (super admin), one compact row each: id, name, slug, member count and whether it has limits of its own. Also returns the deployment's default limits. Pages by 50: pass the returned next as params.cursor. Details and limits of one org come from orgs.get.",
+                input: z.object({ cursor: Cursor.optional() }).strict(),
+                example: {},
+                authz: { superAdmin: true },
+                mirrors: ["GET /api/v1/admin/orgs"],
+                extras: ["cursor"],
+                confirm: "read",
+                run: async (input) => {
+                    const [orgs, s] = await Promise.all([this.orgs.listAll(), this.settings.get()]);
+                    const own = (id) => id in s.runConcurrencyOverrides ||
+                        id in s.sandboxLimitOverrides ||
+                        id in s.subagentLimitOverrides;
+                    return {
+                        ...pageOf(orgs.map((o) => ({
+                            id: o.id,
+                            name: o.name,
+                            slug: o.slug,
+                            memberCount: o.memberCount,
+                            ownLimits: own(o.id),
+                        })), startOf(input.cursor), PAGE),
+                        limitDefaults: limitDefaults(this.config),
+                    };
+                },
+            }),
+            defineOperation({
+                id: "orgs.get",
+                description: "Read one org on the platform (super admin): name, slug, member count, when it was created, its own limits (null where it follows the deployment default) and the deployment defaults.",
+                input: z.object({ orgId: OrgId }).strict(),
+                example: { orgId: "00000000-0000-4000-8000-000000000000" },
+                authz: { superAdmin: true },
+                mirrors: [],
+                confirm: "read",
+                errors: [
+                    {
+                        code: "org.not_found",
+                        next: "Look the org up with orgs.list and pass its id.",
+                    },
+                ],
+                run: async (input) => {
+                    const all = await this.orgs.listAll();
+                    const o = all.find((x) => x.id === input.orgId);
+                    if (!o)
+                        throw new ApiError("org.not_found", "Organization not found");
+                    return {
+                        org: o,
+                        limits: await limitsOf(this.settings, o.id),
+                        limitDefaults: limitDefaults(this.config),
+                    };
+                },
+            }),
+            defineOperation({
+                id: "orgs.set-limits",
+                description: "Set an org's own limits (super admin): runConcurrency (concurrent runs), sandbox ({cpu, memoryMb} for sandboxes created from now on) and subagents ({maxDepth, maxConcurrentPerConversation, maxDispatchesPerRun, maxTokensPerRun}; 0 means no limit for the last two). Give only the limits to change; null drops the org's own value so it follows the deployment default (orgs.get shows both). A sandbox or subagents object replaces the org's whole entry.",
+                input: z
+                    .object({
+                    orgId: OrgId,
+                    runConcurrency: RunConcurrency.optional(),
+                    sandbox: SandboxLimits.optional(),
+                    subagents: SubagentLimits.optional(),
+                })
+                    .strict()
+                    .refine((i) => i.runConcurrency !== undefined ||
+                    i.sandbox !== undefined ||
+                    i.subagents !== undefined, { message: "give runConcurrency, sandbox or subagents" }),
+                example: { orgId: "00000000-0000-4000-8000-000000000000", runConcurrency: 8 },
+                authz: { superAdmin: true },
+                mirrors: ["PUT /api/v1/admin/settings"],
+                // one org's entries of the three override records, keyed by orgId; the deployment-wide
+                // settings are admin.update-settings
+                omits: [
+                    "orgCreation",
+                    "runConcurrencyOverrides",
+                    "priceCurrency",
+                    "sandboxLimitOverrides",
+                    "subagentLimitOverrides",
+                    "customConnectors",
+                    "customSkills",
+                    "orgMarketplaceBrowse",
+                ],
+                extras: ["orgId", "runConcurrency", "sandbox", "subagents"],
+                confirm: "platform",
+                errors: [
+                    {
+                        code: "org.not_found",
+                        next: "Look the org up with orgs.list and pass its id.",
+                    },
+                    {
+                        code: "validation_failed",
+                        next: "Fix the limits as the message says (orgs.get shows the current ones).",
+                    },
+                ],
+                precheck: (i) => precheckBy(() => this.org(i.orgId)),
+                summary: async (i) => {
+                    const name = await orElse(async () => named((await this.org(i.orgId)).name), i.orgId);
+                    const parts = [
+                        i.runConcurrency !== undefined && `runConcurrency=${i.runConcurrency ?? "default"}`,
+                        i.sandbox !== undefined &&
+                            `sandbox=${i.sandbox === null ? "default" : JSON.stringify(i.sandbox)}`,
+                        i.subagents !== undefined &&
+                            `subagents=${i.subagents === null ? "default" : JSON.stringify(i.subagents)}`,
+                    ].filter((p) => typeof p === "string");
+                    return {
+                        zh: `修改组织「${name}」的限额：${parts.join("，")}`,
+                        en: `Set the limits of org "${name}": ${parts.join(", ")}`,
+                    };
+                },
+                run: async (input, ctx) => {
+                    await this.org(input.orgId);
+                    await this.settings.update({
+                        ...(input.runConcurrency !== undefined && {
+                            runConcurrencyOverrides: { [input.orgId]: input.runConcurrency },
+                        }),
+                        ...(input.sandbox !== undefined && {
+                            sandboxLimitOverrides: { [input.orgId]: input.sandbox },
+                        }),
+                        ...(input.subagents !== undefined && {
+                            subagentLimitOverrides: { [input.orgId]: input.subagents },
+                        }),
+                    }, ctx.actorAccountId, undefined, viaAgent("orgs.set-limits", ctx));
+                    return {
+                        limits: await limitsOf(this.settings, input.orgId),
+                        limitDefaults: limitDefaults(this.config),
+                    };
+                },
+            }),
+            defineOperation({
+                id: "orgs.current",
+                description: "Read this conversation's org: its id, name, slug, when it was created, and your role in it.",
+                input: z.object({}).strict(),
+                example: {},
+                authz: { orgAction: "org.read" },
+                mirrors: ["GET /api/v1/orgs/:orgId"],
+                confirm: "read",
+                run: async (_input, ctx) => ({
+                    org: await this.org(ctx.orgId),
+                    role: await roleOf(this.kdb.db, ctx.orgId, ctx.actorAccountId),
+                }),
+            }),
+            defineOperation({
+                id: "orgs.update",
+                description: "Rename this conversation's org or change its slug (org admins). The slug is part of the org's links, so changing it breaks links people saved.",
+                input: OrgUpdateBody.strict().refine((i) => i.name !== undefined || i.slug !== undefined, {
+                    message: "give name or slug",
+                }),
+                example: { name: "Acme Research" },
+                authz: { orgAction: "org.update" },
+                mirrors: ["PATCH /api/v1/orgs/:orgId"],
+                confirm: "org",
+                errors: [
+                    {
+                        code: "org.slug_taken",
+                        next: "Choose another slug; another org uses this one.",
+                    },
+                    {
+                        code: "validation_failed",
+                        next: "Fix the name or slug as the message says (slug: lower-case letters, digits and -).",
+                    },
+                ],
+                precheck: async (i, ctx) => {
+                    if (i.slug === undefined)
+                        return { ok: true };
+                    const taken = (await this.orgs.listAll()).find((o) => o.slug === i.slug && o.id !== ctx.orgId);
+                    return taken === undefined
+                        ? { ok: true }
+                        : { ok: false, code: "org.slug_taken", message: `The slug "${i.slug}" is taken` };
+                },
+                summary: async (i, ctx) => {
+                    const name = await orElse(async () => named((await this.org(ctx.orgId)).name), ctx.orgId);
+                    const parts = [
+                        i.name !== undefined && `name → "${named(i.name)}"`,
+                        i.slug !== undefined && `slug → ${named(i.slug)}`,
+                    ].filter((p) => typeof p === "string");
+                    return {
+                        zh: `修改组织「${name}」：${parts.join("，")}`,
+                        en: `Update org "${name}": ${parts.join(", ")}`,
+                    };
+                },
+                run: async (input, ctx) => ({
+                    org: await this.orgs.update(ctx.orgId, input, await this.actor(ctx), undefined, viaAgent("orgs.update", ctx)),
+                }),
+            }),
+            defineOperation({
+                id: "orgs.members",
+                description: "List the members of this conversation's org, one compact row each: account id, display name, role, email and when they joined. Changing roles and removing members is done on the web. Pages by 50: pass the returned next as params.cursor.",
+                input: z.object({ cursor: Cursor.optional() }).strict(),
+                example: {},
+                authz: { orgAction: "org.members.read" },
+                mirrors: ["GET /api/v1/orgs/:orgId/members"],
+                extras: ["cursor"],
+                confirm: "read",
+                run: async (input, ctx) => pageOf((await this.members.list(ctx.orgId)).map((m) => ({
+                    id: m.account.id,
+                    name: m.account.displayName,
+                    state: m.role,
+                    email: m.account.email,
+                    joinedAt: m.joinedAt,
+                    ...(m.anonymous && { anonymous: true }),
+                })), startOf(input.cursor), PAGE),
+            }),
+        ]);
+    }
+};
+OrgsOperations = __decorate([
+    Injectable(),
+    __param(0, Inject(PlatformOperations)),
+    __param(1, Inject(OrgsService)),
+    __param(2, Inject(MembersService)),
+    __param(3, Inject(SettingsService)),
+    __param(4, Inject(AccountsService)),
+    __param(5, Inject(KernelConfigService)),
+    __param(6, Inject(KernelDb))
+], OrgsOperations);
+export { OrgsOperations };

package/dist/platform/ops/other-orgs.d.ts

@@ -0,0 +1,20 @@
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
+export declare const OTHER_ORG = "This plugin belongs to another org; use the admin console.";
+/**
+ * Refuses a super-admin operation on a catalog item another org owns (spec §6.1, §14.5 item 1):
+ * its results would describe that org's private plugin in this org's log. Platform items and the
+ * conversation org's own pass; an id that is no uuid passes too (the service answers not found).
+ */
+export declare function assertNotOtherOrgs(db: KernelSchemaDb, itemId: string, orgId: string): Promise<void>;
+/** How many live catalog items other orgs own (left out of the platform lists). */
+export declare function otherOrgItems(db: KernelSchemaDb, orgId: string): Promise<number>;
+/**
+ * The extensions (by name) that only other orgs' own plugins bring: an org upload's extension the
+ * super admin confirmed is installed on the deployment, but it is that org's private plugin
+ * (spec §14.5 item 1): counted, never described or changed through this org's agent. An extension
+ * that a live platform plugin or the conversation org's own plugin also brings is not one of
+ * them; deleted catalog items count on neither side.
+ */
+export declare function otherOrgExtensions(db: KernelSchemaDb, orgId: string, names?: readonly string[]): Promise<Set<string>>;
+/** Refuses an extension only other orgs' own plugins bring ({@link otherOrgExtensions}). */
+export declare function assertExtensionNotOtherOrgs(db: KernelSchemaDb, name: string, orgId: string): Promise<void>;

package/dist/platform/ops/other-orgs.js

@@ -0,0 +1,72 @@
+import { ToolError } from "@capybara-hq/plugin-sdk";
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export const OTHER_ORG = "This plugin belongs to another org; use the admin console.";
+/**
+ * Refuses a super-admin operation on a catalog item another org owns (spec §6.1, §14.5 item 1):
+ * its results would describe that org's private plugin in this org's log. Platform items and the
+ * conversation org's own pass; an id that is no uuid passes too (the service answers not found).
+ */
+export async function assertNotOtherOrgs(db, itemId, orgId) {
+    if (!UUID_RE.test(itemId))
+        return;
+    const row = await db
+        .selectFrom("catalog_items")
+        .select("owner_org_id")
+        .where("id", "=", itemId)
+        .executeTakeFirst();
+    if (row?.owner_org_id != null && row.owner_org_id !== orgId)
+        throw new ToolError(OTHER_ORG);
+}
+/** How many live catalog items other orgs own (left out of the platform lists). */
+export async function otherOrgItems(db, orgId) {
+    const r = await db
+        .selectFrom("catalog_items")
+        .select((eb) => eb.fn.countAll().as("n"))
+        .where("deleted_at", "is", null)
+        .where("owner_org_id", "is not", null)
+        .where("owner_org_id", "!=", orgId)
+        .executeTakeFirstOrThrow();
+    return Number(r.n);
+}
+/**
+ * The extensions (by name) that only other orgs' own plugins bring: an org upload's extension the
+ * super admin confirmed is installed on the deployment, but it is that org's private plugin
+ * (spec §14.5 item 1): counted, never described or changed through this org's agent. An extension
+ * that a live platform plugin or the conversation org's own plugin also brings is not one of
+ * them; deleted catalog items count on neither side.
+ */
+export async function otherOrgExtensions(db, orgId, names) {
+    if (names !== undefined && names.length === 0)
+        return new Set();
+    let sources = db
+        .selectFrom("extension_catalog_sources as s")
+        .innerJoin("catalog_items as i", "i.id", "s.item_id")
+        .select(["s.plugin as plugin", "i.owner_org_id as owner"])
+        .where("i.deleted_at", "is", null);
+    let installs = db
+        .selectFrom("extension_installs as e")
+        .innerJoin("catalog_items as i", "i.id", "e.catalog_item_id")
+        .select(["e.name as plugin", "i.owner_org_id as owner"])
+        .where("i.deleted_at", "is", null);
+    if (names !== undefined) {
+        sources = sources.where("s.plugin", "in", names);
+        installs = installs.where("e.name", "in", names);
+    }
+    const rows = await sources.unionAll(installs).execute();
+    const theirs = new Set();
+    const ours = new Set();
+    for (const r of rows) {
+        if (r.owner === null || r.owner === orgId)
+            ours.add(r.plugin);
+        else
+            theirs.add(r.plugin);
+    }
+    for (const n of ours)
+        theirs.delete(n);
+    return theirs;
+}
+/** Refuses an extension only other orgs' own plugins bring ({@link otherOrgExtensions}). */
+export async function assertExtensionNotOtherOrgs(db, name, orgId) {
+    if ((await otherOrgExtensions(db, orgId, [name])).has(name))
+        throw new ToolError(OTHER_ORG);
+}

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

@@ -13,10 +13,10 @@ export declare class PlatformOperationsProvider implements OnModuleInit {
     private readonly tools;
     constructor(registry: PlatformOperations, actor: PlatformActor, agents: AgentsService, settings: OrgSettingsService, tools: ToolRegistry);
     /**
-     * The agent's tools by the keys the model sees: builtins by name, plugin tools as
-     * `plugin__<plugin>__<tool>`, and each connector reference expanded to its live tools'
-     * `mcp__<slug>__<tool>` keys as the registry resolves them for a run; connector tools that
-     * cannot load now are listed with the registry's reason.
+     * The agent's tools by the keys the model sees, as the registry resolves them for a run (tools
+     * default-on spec §8): every tool the org offers that the definition does not turn off, builtins
+     * by name, extension tools as `plugin__<plugin>__<tool>`, connector tools as
+     * `mcp__<slug>__<tool>`; the ones that cannot load now are listed with the registry's reason.
      */
     private toolKeys;
     onModuleInit(): void;

package/dist/platform/ops/platform.ops.js

@@ -7,7 +7,6 @@ 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 { extensionToolKey } from "@capybara-hq/plugin-sdk";
 import { Inject, Injectable } from "@nestjs/common";
 import { z } from "zod";
 import { AgentsService } from "../../agents/agents.service.js";
@@ -18,7 +17,6 @@ import { ToolRegistry } from "../../tools/registry.js";
 import { PlatformActor } from "../actor.js";
 import { defineOperation } from "../operation.js";
 import { PlatformOperations } from "../registry.js";
-import { asToolError } from "./errors.js";
 /** What a role may build, as the model says it to the person: the action and its plain words. */
 const BUILDS = [
     { action: "agents.create", what: "create private agents and edit the agents you own" },
@@ -51,28 +49,23 @@ let PlatformOperationsProvider = class PlatformOperationsProvider {
         this.tools = tools;
     }
     /**
-     * The agent's tools by the keys the model sees: builtins by name, plugin tools as
-     * `plugin__<plugin>__<tool>`, and each connector reference expanded to its live tools'
-     * `mcp__<slug>__<tool>` keys as the registry resolves them for a run; connector tools that
-     * cannot load now are listed with the registry's reason.
+     * The agent's tools by the keys the model sees, as the registry resolves them for a run (tools
+     * default-on spec §8): every tool the org offers that the definition does not turn off, builtins
+     * by name, extension tools as `plugin__<plugin>__<tool>`, connector tools as
+     * `mcp__<slug>__<tool>`; the ones that cannot load now are listed with the registry's reason.
      */
     async toolKeys(orgId, d) {
-        const connectors = d.tools.filter((r) => r.kind === "connector");
-        const resolved = connectors.length === 0
-            ? { tools: [], unavailable: [] }
-            : await this.tools.forAgent(orgId, { tools: connectors });
-        const live = new Map();
-        for (const t of resolved.tools) {
-            if (t.source.kind !== "connector")
-                continue;
-            live.set(t.source.connectorId, [...(live.get(t.source.connectorId) ?? []), t.key]);
-        }
-        const keys = d.tools.flatMap((r) => r.kind === "connector"
-            ? (live.get(r.connectorId) ?? [])
-            : [r.kind === "builtin" ? r.name : extensionToolKey(r.plugin, r.name)]);
+        const resolved = await this.tools.forAgent(orgId, {
+            disabledTools: d.disabledTools ?? [],
+            subagentTools: d.subagentTools,
+            subagents: d.subagents,
+        });
         return {
-            keys: [...new Set(keys)],
-            unavailable: resolved.unavailable.map((u) => ({ tool: u.ref, reason: u.reason })),
+            keys: [...new Set(resolved.tools.map((t) => t.key))],
+            unavailable: [...resolved.unavailable, ...(resolved.hidden ?? [])].map((u) => ({
+                tool: u.ref,
+                reason: u.reason,
+            })),
         };
     }
     onModuleInit() {
@@ -111,13 +104,13 @@ let PlatformOperationsProvider = class PlatformOperationsProvider {
             }),
             defineOperation({
                 id: "platform.me",
-                description: "Show this agent as configured: its model, tools by the keys you call them by (connector tools as mcp__<connector>__<tool>, with those that cannot load now and why), skills (org and pinned), sub-agents, whether it runs in a sandbox, and the sandbox network mode. Secrets are never shown.",
+                description: "Show this agent as configured: its model, the tools it has now by the keys you call them by (every tool the org offers unless the agent turns it off; connector tools as mcp__<connector>__<tool>, with those that cannot load now and why), the tools it turns off (disabledTools), skills (org and pinned), sub-agents, whether it runs in a sandbox, the sandbox network mode, and its profile (avatar, description, quick actions). Secrets are never shown.",
                 input: EMPTY,
                 example: {},
                 authz: { orgAction: "agents.use" },
                 mirrors: [],
                 confirm: "read",
-                run: async (_input, ctx) => asToolError(async () => {
+                run: async (_input, ctx) => {
                     const agent = await this.agents.get(ctx.orgId, ctx.agentId, ctx.actorAccountId);
                     const d = agent.definition;
                     const { keys: toolKeys, unavailable } = await this.toolKeys(ctx.orgId, d);
@@ -134,6 +127,7 @@ let PlatformOperationsProvider = class PlatformOperationsProvider {
                         fallback: d.fallback,
                         tools: toolKeys,
                         ...(unavailable.length > 0 && { unavailableTools: unavailable }),
+                        disabledTools: d.disabledTools ?? [],
                         toolPolicies: d.toolPolicies,
                         skills: {
                             orgSkills: d.skills?.orgSkills ?? [],
@@ -141,8 +135,13 @@ let PlatformOperationsProvider = class PlatformOperationsProvider {
                         },
                         subagents: d.subagents ?? null,
                         sandbox: sandbox ? { enabled: true, egress: egress.egress } : { enabled: false },
+                        profile: {
+                            avatar: agent.profile.avatar,
+                            description: agent.profile.description,
+                            quickActions: agent.profile.quickActions,
+                        },
                     };
-                }),
+                },
             }),
         ]);
     }