@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.3

package/dist/tools/registry.js

@@ -1,38 +1,31 @@
+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 { createHash } from "node:crypto";
+import { connectorToolKey, extensionToolKey } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
+import { ExtensionHost } from "../extensions/host.js";
+import { ExtensionRegistry } from "../extensions/registry.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
 import { readOrgSettings } from "../orgs/settings.service.js";
 import { estimateTokens } from "../runtime/context/tokens.js";
 import { SUBAGENT_LIMIT_DEFAULTS, subagentLimits } from "../runtime/subagents/limits.js";
 import { resolveRoster } from "../runtime/subagents/roster.js";
-import { AGENT_TOOL, agentToolSpec } from "./builtins/agent.js";
-import { SANDBOX_TOOL_NAMES } from "./builtins/sandbox/names.js";
-import { toolKey, toolKeyIssue } from "./naming.js";
-/**
- * 内核内置工具的名字（Task 10 / Task 19 实现；M5 T8 加沙箱工具）。保存 agent 时内置工具引用按这份清单校验，
- * 不依赖当前是否已注册，避免实现落地顺序影响已保存的定义；运行时未注册的照常报不可用。
- * `skill_write`（M5 T15）由 agent 定义显式引用才可用（负责人决定 agent 能否改自己的技能）。
- */
-export const BUILTIN_TOOL_NAMES = [
-    "ask_user",
-    "read_tool_output",
-    "tool_search",
-    "skill_load",
-    "skill_write",
-    ...SANDBOX_TOOL_NAMES,
-    // phase C: dispatches sub-agents; its description is built per agent from the roster
-    "agent",
-];
-/** 键排序、去掉 undefined 的 JSON（jsonb 不保留键顺序，指纹必须与顺序无关）。 */
-export function canonicalJson(v) {
-    if (Array.isArray(v))
-        return `[${v.map(canonicalJson).join(",")}]`;
-    if (v !== null && typeof v === "object") {
-        const entries = Object.entries(v)
-            .filter(([, x]) => x !== undefined)
-            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
-        return `{${entries.map(([k, x]) => `${JSON.stringify(k)}:${canonicalJson(x)}`).join(",")}}`;
-    }
-    return JSON.stringify(v);
-}
+import { AGENT_TOOL, BUILTIN_TOOL_NAMES, SKILL_LOAD, TOOL_SEARCH } from "./builtin-names.js";
+import { agentToolSpec } from "./builtins/agent.js";
+import { BuiltinTools } from "./builtins/builtin-tools.js";
+import { canonicalJson } from "./canonical-json.js";
+import { legacyKeySaveText } from "./legacy-keys.js";
+import { toolKeyIssue } from "./naming.js";
+export { BUILTIN_TOOL_NAMES } from "./builtin-names.js";
+export { canonicalJson } from "./canonical-json.js";
 /** The first 16 hex digits of sha256(canonicalJson(v)): a fingerprint independent of key order. */
 export function contentHash(v) {
     return createHash("sha256").update(canonicalJson(v)).digest("hex").slice(0, 16);
@@ -63,10 +56,8 @@ export function specHash(spec) {
 export function policyFromAnnotations(a) {
     return a?.readOnlyHint === true ? "allow" : "ask";
 }
-/** 内置 `tool_search` 的名字（由注册表按组织设置与阈值自动加入，不进 agent 定义）。 */
-const TOOL_SEARCH = "tool_search";
-/** 内置 `skill_load` 的名字（对话日志里有技能目录快照时由注册表自动加入，不进 agent 定义）。 */
-const SKILL_LOAD = "skill_load";
+// `ToolSearch` is added by the registry by org setting and threshold, `Skill` when the log has a
+// skills catalog snapshot; neither comes from agent definitions (`./builtin-names.ts`).
 /** 工具定义（模型可见三项）的估算 token 数（与请求估算同一口径）。 */
 function estimateToolTokens(tools) {
     return estimateTokens([], [], tools.map((t) => ({
@@ -97,14 +88,35 @@ const sourceId = (s) => s.kind === "builtin"
  * Only the first of a key is kept; the same source referenced twice is deduplicated silently,
  * different sources with the same key report a duplicate.
  */
-export class ToolRegistry {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
+let ToolRegistry = class ToolRegistry {
+    db;
+    host;
+    extensions;
+    builtinTools;
+    config;
+    constructor(db, 
+    /** Extension tools and the organization's enabled extensions. */
+    host, 
+    /** The installed connectors (`connector@1`, from the extension registry). */
+    extensions, builtinTools, 
+    /**
+     * `tools.searchThreshold*` and the sub-agent limits. Absent (some tests): `ToolSearch` is never
+     * offered and the sub-agent limits are the schema defaults.
+     */
+    config) {
+        this.db = db;
+        this.host = host;
+        this.extensions = extensions;
+        this.builtinTools = builtinTools;
+        this.config = config;
+    }
+    /** The kernel's builtin tools (`ToolSearch` is added by {@link forAgent}, not by definitions). */
+    get builtins() {
+        return this.builtinTools.list();
     }
     /** `host.list("connector")` 中 `kind` 匹配的第一个实现；未安装返回 undefined。 */
     findConnector(kind) {
-        for (const e of this.deps.host.list("connector")) {
+        for (const e of this.extensions.list("connector")) {
             const impl = e.impl;
             if (impl?.kind === kind)
                 return impl;
@@ -127,10 +139,10 @@ export class ToolRegistry {
      */
     handler(source) {
         if (source.kind === "builtin") {
-            return this.deps.builtins.find((b) => b.spec.name === source.name)?.run;
+            return this.builtins.find((b) => b.spec.name === source.name)?.run;
         }
         if (source.kind === "plugin") {
-            const t = this.deps.host
+            const t = this.host
                 .tools()
                 .find((x) => x.plugin === source.plugin && x.spec.name === source.name);
             if (!t)
@@ -141,15 +153,15 @@ export class ToolRegistry {
     }
     /** The registered builtin tools' specs (display metadata for `tools/info.ts`). */
     builtinSpecs() {
-        return this.deps.builtins.map((b) => b.spec);
+        return this.builtins.map((b) => b.spec);
     }
     /** The loaded extensions' registered tool specs, with their extension's name. */
     extensionToolSpecs() {
-        return this.deps.host.tools().map((t) => ({ plugin: t.plugin, spec: t.spec }));
+        return this.host.tools().map((t) => ({ plugin: t.plugin, spec: t.spec }));
     }
     /** 已安装连接器的 kind 列表（去重，按加载顺序）。 */
     connectorKinds() {
-        return [...new Set(this.deps.host.list("connector").map((e) => e.impl.kind))];
+        return [...new Set(this.extensions.list("connector").map((e) => e.impl.kind))];
     }
     /**
      * 保存 agent 时校验工具引用（只看「存在」，停用 / 待复核 / 插件未启用等运行时状态不拒绝，由 `forAgent` 报不可用）：
@@ -162,7 +174,7 @@ export class ToolRegistry {
     async checkRefs(orgId, refs) {
         const issues = [];
         const owner = new Map();
-        const pluginTools = this.deps.host.tools();
+        const pluginTools = this.host.tools();
         const connectorIds = [
             ...new Set(refs.flatMap((r) => (r.kind === "connector" ? [r.connectorId] : []))),
         ];
@@ -179,13 +191,19 @@ export class ToolRegistry {
             const path = `tools.${i}`;
             if (ref.kind === "builtin") {
                 if (!BUILTIN_TOOL_NAMES.includes(ref.name)) {
-                    issues.push({ path, message: `Built-in tool "${ref.name}" does not exist` });
+                    const renamed = legacyKeySaveText(ref.name);
+                    issues.push({
+                        path,
+                        message: renamed === null
+                            ? `Built-in tool "${ref.name}" does not exist`
+                            : `Built-in tool ${renamed}`,
+                    });
                     return;
                 }
                 claim(path, ref.name, `builtin:${ref.name}`);
             }
             else if (ref.kind === "plugin") {
-                const key = toolKey(ref.plugin, ref.name);
+                const key = extensionToolKey(ref.plugin, ref.name);
                 if (!pluginTools.some((x) => x.plugin === ref.plugin && x.spec.name === ref.name)) {
                     issues.push({ path, message: `Plugin tool "${key}" does not exist` });
                     return;
@@ -212,22 +230,22 @@ export class ToolRegistry {
                         });
                         continue;
                     }
-                    claim(path, toolKey(app.slug, name), `connector:${app.id}:${name}`);
+                    claim(path, connectorToolKey(app.slug, name), `connector:${app.id}:${name}`);
                 }
             }
         });
         return { keys: new Set(owner.keys()), issues };
     }
     /**
-     * 解析 agent 引用的工具（见类注释），再判定是否启用 `tool_search`：组织设置 `toolSearch === "on"`，且
+     * 解析 agent 引用的工具（见类注释），再判定是否启用 `ToolSearch`：组织设置 `toolSearch === "on"`，且
      * 可用工具数 > `tools.searchThresholdTools` 或其定义的估算 token > `tools.searchThresholdTokens`。
-     * 启用时把内置 `tool_search` 追加到末尾。定义里显式引用的 `tool_search` 忽略（由这里按设置管理）。
-     * `skillLoad`：对话日志里有技能目录快照（`skills_catalog`，Ruling M17）→ 加入内置 `skill_load`（始终完整加载）；
-     * 定义里显式引用的 `skill_load` 同样忽略。
+     * 启用时把内置 `ToolSearch` 追加到末尾。定义里显式引用的 `ToolSearch` 忽略（由这里按设置管理）。
+     * `skillLoad`：对话日志里有技能目录快照（`skills_catalog`，Ruling M17）→ 加入内置 `Skill`（始终完整加载）；
+     * 定义里显式引用的 `Skill` 同样忽略。
      */
     async forAgent(orgId, def) {
         const { tools, unavailable, hidden } = await this.resolve(orgId, def);
-        const sl = def.skillLoad === true && this.deps.builtins.find((x) => x.spec.name === SKILL_LOAD);
+        const sl = def.skillLoad === true && this.builtins.find((x) => x.spec.name === SKILL_LOAD);
         if (sl) {
             tools.push({
                 key: SKILL_LOAD,
@@ -240,7 +258,7 @@ export class ToolRegistry {
         }
         const toolSearch = await this.searchActive(orgId, tools);
         if (toolSearch) {
-            const b = this.deps.builtins.find((x) => x.spec.name === TOOL_SEARCH);
+            const b = this.builtins.find((x) => x.spec.name === TOOL_SEARCH);
             tools.push({
                 key: TOOL_SEARCH,
                 source: { kind: "builtin", name: TOOL_SEARCH },
@@ -251,16 +269,16 @@ export class ToolRegistry {
         }
         return { tools, unavailable, hidden, toolSearch };
     }
-    /** 是否启用 `tool_search`（见 {@link forAgent}）；先比阈值，超过才读组织设置。 */
+    /** 是否启用 `ToolSearch`（见 {@link forAgent}）；先比阈值，超过才读组织设置。 */
     async searchActive(orgId, tools) {
-        const cfg = this.deps.config?.().tools;
-        if (!cfg || !this.deps.builtins.some((b) => b.spec.name === TOOL_SEARCH))
+        const cfg = this.config?.get().tools;
+        if (!cfg || !this.builtins.some((b) => b.spec.name === TOOL_SEARCH))
             return false;
         const over = tools.length > cfg.searchThresholdTools ||
             estimateToolTokens(tools) > cfg.searchThresholdTokens;
         if (!over)
             return false;
-        return (await readOrgSettings(this.deps.db, orgId)).toolSearch === "on";
+        return (await readOrgSettings(this.db.db, orgId)).toolSearch === "on";
     }
     async resolve(orgId, def) {
         const tools = [];
@@ -288,12 +306,12 @@ export class ToolRegistry {
             ...new Set(def.tools.flatMap((r) => (r.kind === "connector" ? [r.connectorId] : []))),
         ];
         const apps = await this.loadConnectors(orgId, connectorIds);
-        const pluginTools = this.deps.host.tools();
+        const pluginTools = this.host.tools();
         for (const ref of def.tools) {
             if (ref.kind === "builtin") {
                 if (ref.name === TOOL_SEARCH || ref.name === SKILL_LOAD)
                     continue;
-                const b = this.deps.builtins.find((x) => x.spec.name === ref.name);
+                const b = this.builtins.find((x) => x.spec.name === ref.name);
                 if (!b) {
                     unavailable.push({ ref: ref.name, reason: "Built-in tool does not exist" });
                     continue;
@@ -303,11 +321,11 @@ export class ToolRegistry {
                     unavailable.push({ ref: ref.name, reason: why });
                     continue;
                 }
-                // `agent`: the description lists this definition's roster (sub-agents spec §4.3); with an
+                // `Agent`: the description lists this definition's roster (sub-agents spec §4.3); with an
                 // empty roster there is nothing to dispatch, so the tool is not offered at all
                 let spec = b.spec;
                 if (b.spec.name === AGENT_TOOL) {
-                    const roster = await resolveRoster(this.deps.db, orgId, { subagents: def.subagents });
+                    const roster = await resolveRoster(this.db.db, orgId, { subagents: def.subagents });
                     if (roster.length === 0)
                         continue;
                     spec = agentToolSpec(roster, await this.maxConcurrentSubagents(orgId));
@@ -323,7 +341,7 @@ export class ToolRegistry {
                 });
             }
             else if (ref.kind === "plugin") {
-                const key = toolKey(ref.plugin, ref.name);
+                const key = extensionToolKey(ref.plugin, ref.name);
                 const t = pluginTools.find((x) => x.plugin === ref.plugin && x.spec.name === ref.name);
                 if (!t) {
                     unavailable.push({ ref: key, reason: "Plugin tool does not exist" });
@@ -355,7 +373,7 @@ export class ToolRegistry {
                     unavailable.push({ ref: `app:${ref.connectorId}`, reason: "App does not exist" });
                     continue;
                 }
-                const all = toolKey(app.slug, "*");
+                const all = connectorToolKey(app.slug, "*");
                 if (app.deleted) {
                     unavailable.push({ ref: all, reason: `App ${app.slug} was deleted` });
                     continue;
@@ -377,7 +395,7 @@ export class ToolRegistry {
                 // 「all」里未启用的工具不算 agent 点名要的，不进 unavailable（不提醒），只记进 hidden 备查
                 const notEnabled = ref.tools === "all" ? hidden : unavailable;
                 for (const t of wanted) {
-                    const key = toolKey(app.slug, t.name);
+                    const key = connectorToolKey(app.slug, t.name);
                     // 远端已不再提供（漂移检测置停用并标记，见 drift.ts）：与「没有这一行」同一个事实
                     if ("missing" in t || t.gone) {
                         notEnabled.push({ ref: key, reason: `Tool no longer exists in app ${app.slug}` });
@@ -414,25 +432,26 @@ export class ToolRegistry {
         return { tools, unavailable, hidden };
     }
     /**
-     * `subagents.maxConcurrentPerRun` with the organization's override, for the `agent` tool's
+     * `subagents.maxConcurrentPerRun` with the organization's override, for the `Agent` tool's
      * description (§4.3). A change of the limit changes the tool's spec hash; replays read the
      * definition logged by hash, so no drift reason is involved. Without config (some tests): the
      * schema default.
      */
     async maxConcurrentSubagents(orgId) {
-        const config = this.deps.config ?? (() => ({ subagents: SUBAGENT_LIMIT_DEFAULTS }));
-        return (await subagentLimits(this.deps.db, config, orgId)).maxConcurrentPerRun;
+        const cfg = this.config;
+        const config = cfg ?? { get: () => ({ subagents: SUBAGENT_LIMIT_DEFAULTS }) };
+        return (await subagentLimits(this.db.db, config, orgId)).maxConcurrentPerRun;
     }
     /** Plugins the organization enabled (built-in plugins always count as enabled, C14). */
     async enabledPlugins(orgId) {
-        return this.deps.host.enabledPlugins(orgId);
+        return this.host.enabledPlugins(orgId);
     }
     async loadConnectors(orgId, ids) {
         const out = new Map();
         if (ids.length === 0)
             return out;
         // 软删除的连接器也读出来，只为给出「已删除」这个更准确的原因（slug 可能已被新连接器复用，按 id 区分）
-        const apps = await this.deps.db
+        const apps = await this.db
             .selectFrom("connectors")
             .select(["id", "slug", "connector", "status", "deleted_at"])
             .where("org_id", "=", orgId)
@@ -441,7 +460,7 @@ export class ToolRegistry {
         const live = apps.filter((a) => a.deleted_at === null).map((a) => a.id);
         const toolRows = live.length === 0
             ? []
-            : await this.deps.db
+            : await this.db
                 .selectFrom("connector_tools")
                 .select([
                 "connector_id",
@@ -478,4 +497,13 @@ export class ToolRegistry {
         }
         return out;
     }
-}
+};
+ToolRegistry = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(ExtensionHost)),
+    __param(2, Inject(ExtensionRegistry)),
+    __param(3, Inject(BuiltinTools)),
+    __param(4, Inject(KernelConfigService))
+], ToolRegistry);
+export { ToolRegistry };

package/dist/tools/resources.d.ts

@@ -1,6 +1,6 @@
 import { type ConnectorSession, type ToolResult, type ToolSpec } from "@capybara-hq/plugin-sdk";
 /**
- * 连接器 resources 的两个内核工具（brief：`<connectorSlug>__list_resources`、`<connectorSlug>__read_resource {uri}`）。
+ * 连接器 resources 的两个内核工具（brief：`mcp__<slug>__list_resources`、`mcp__<slug>__read_resource {uri}`）。
  *
  * 设计：安装 / 刷新连接器时，连接器会话带 `listResources` 方法即视为支持 resources（不额外调用，免得多一次外连
  * 和多一种失败），内核把这两个工具作为 `source = 'resources'` 的行写进 `connector_tools`（迁移 0013）。这样它们和

package/dist/tools/resources.js

@@ -1,6 +1,6 @@
 import { ToolError, } from "@capybara-hq/plugin-sdk";
 /**
- * 连接器 resources 的两个内核工具（brief：`<connectorSlug>__list_resources`、`<connectorSlug>__read_resource {uri}`）。
+ * 连接器 resources 的两个内核工具（brief：`mcp__<slug>__list_resources`、`mcp__<slug>__read_resource {uri}`）。
  *
  * 设计：安装 / 刷新连接器时，连接器会话带 `listResources` 方法即视为支持 resources（不额外调用，免得多一次外连
  * 和多一种失败），内核把这两个工具作为 `source = 'resources'` 的行写进 `connector_tools`（迁移 0013）。这样它们和

package/dist/tools/specs.d.ts

@@ -1,14 +1,15 @@
 import type { ToolSpec } from "@capybara-hq/plugin-sdk";
-import type { Transaction } from "kysely";
-import type { KernelDatabase, KernelDb } from "../db/kernel-schema.js";
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
 /**
  * 把工具定义按指纹存进 `capybara.tool_specs`（内容寻址：同一指纹只存一次，已存在不改）。
  * `model_call` 只记 `{key, specHash}`，定义本身存这里——连接器刷新 / 插件升级改了定义之后，早先请求用过的定义
  * 仍可按指纹取回，模型请求可由日志还原。
  */
-export declare function recordToolSpecs(db: KernelDb | Transaction<KernelDatabase>, specs: readonly {
+export declare function recordToolSpecs(
+/** The pool or a transaction (a transaction is a Kysely handle too). */
+db: KernelSchemaDb, specs: readonly {
     specHash: string;
     spec: ToolSpec;
 }[]): Promise<void>;
 /** 按指纹取回工具定义；没有记录 → null。 */
-export declare function loadToolSpec(db: KernelDb, specHash: string): Promise<ToolSpec | null>;
+export declare function loadToolSpec(db: KernelSchemaDb, specHash: string): Promise<ToolSpec | null>;

package/dist/tools/specs.js

@@ -3,7 +3,9 @@
  * `model_call` 只记 `{key, specHash}`，定义本身存这里——连接器刷新 / 插件升级改了定义之后，早先请求用过的定义
  * 仍可按指纹取回，模型请求可由日志还原。
  */
-export async function recordToolSpecs(db, specs) {
+export async function recordToolSpecs(
+/** The pool or a transaction (a transaction is a Kysely handle too). */
+db, specs) {
     const unique = new Map();
     for (const s of specs)
         if (!unique.has(s.specHash))

package/dist/tools/tools.module.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tools and connectors: credentials, output archives, the builtin tools and the registry,
+ * approvals and questions (their decisions are the domain events `approval.decided` /
+ * `question.answered`), drift detection (the producer of the one-off `drift-connector` jobs the
+ * maintenance processor consumes), the breaker, connector content, the execution pipeline, org
+ * connectors and the OAuth connect flow. The periodic jobs (`ToolJobs`: the drift scan and the
+ * output cleanup) are the worker role's (`WorkerModule`).
+ */
+export declare class ToolsModule {
+}

package/dist/tools/tools.module.js

@@ -0,0 +1,91 @@
+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;
+};
+import { Module } from "@nestjs/common";
+import { ConversationAccessModule } from "../conversations/access.js";
+import { AttachmentsModule } from "../conversations/attachments.module.js";
+import { EventLogModule } from "../conversations/event-log.js";
+import { ExtensionsModule } from "../extensions/extensions.module.js";
+import { QueueModule } from "../infra/queue/queue.module.js";
+import { OrgLockModule } from "../orgs/org-lock.js";
+import { MAINTENANCE_QUEUE_NAME } from "../runtime/maintenance-queue.js";
+import { SubagentsModule } from "../runtime/subagents/subagents.service.js";
+import { SandboxModule } from "../sandbox/sandbox.module.js";
+import { SkillsModule } from "../skills/skills.module.js";
+import { StorageModule } from "../storage/storage.module.js";
+import { ApprovalsService } from "./approvals.service.js";
+import { Breaker } from "./breaker.js";
+import { BuiltinTools } from "./builtins/builtin-tools.js";
+import { ConnectorContent } from "./connector-content.js";
+import { ConnectorsService } from "./connectors.service.js";
+import { Credentials } from "./credentials.js";
+import { ToolDrift } from "./drift.js";
+import { ConversationToolInfo } from "./info.js";
+import { OAuthFlow } from "./oauth/flow.js";
+import { ToolOutputs } from "./outputs.js";
+import { ToolPipeline } from "./pipeline.js";
+import { QuestionsService } from "./questions.service.js";
+import { ToolRegistry } from "./registry.js";
+/**
+ * Tools and connectors: credentials, output archives, the builtin tools and the registry,
+ * approvals and questions (their decisions are the domain events `approval.decided` /
+ * `question.answered`), drift detection (the producer of the one-off `drift-connector` jobs the
+ * maintenance processor consumes), the breaker, connector content, the execution pipeline, org
+ * connectors and the OAuth connect flow. The periodic jobs (`ToolJobs`: the drift scan and the
+ * output cleanup) are the worker role's (`WorkerModule`).
+ */
+let ToolsModule = class ToolsModule {
+};
+ToolsModule = __decorate([
+    Module({
+        imports: [
+            EventLogModule,
+            AttachmentsModule,
+            ExtensionsModule,
+            StorageModule,
+            SkillsModule,
+            OrgLockModule,
+            // the `Agent` tool's dispatch
+            SubagentsModule,
+            // the builtin sandbox and skill tools run in the conversation's sandbox
+            SandboxModule,
+            // the conversation page's tool metadata reads only what the viewer may see
+            ConversationAccessModule,
+            QueueModule.registerQueue(MAINTENANCE_QUEUE_NAME),
+        ],
+        providers: [
+            Credentials,
+            ToolOutputs,
+            BuiltinTools,
+            ToolRegistry,
+            ApprovalsService,
+            QuestionsService,
+            ToolDrift,
+            Breaker,
+            ConnectorContent,
+            ToolPipeline,
+            ConnectorsService,
+            OAuthFlow,
+            ConversationToolInfo,
+        ],
+        exports: [
+            Credentials,
+            ToolOutputs,
+            BuiltinTools,
+            ToolRegistry,
+            ApprovalsService,
+            QuestionsService,
+            ToolDrift,
+            Breaker,
+            ConnectorContent,
+            ToolPipeline,
+            ConnectorsService,
+            OAuthFlow,
+            ConversationToolInfo,
+        ],
+    })
+], ToolsModule);
+export { ToolsModule };

package/dist/ui/call-extension.d.ts

@@ -0,0 +1,16 @@
+import type { Logger } from "@capybara-hq/plugin-sdk";
+/**
+ * Calls an extension with a time limit and an abort signal (plugin views, actions and file
+ * previewers): over the limit the signal aborts and the call is 504 `ui.timeout`; a throw is
+ * `failCode` (502) without echoing the extension's message. An `ApiError` thrown by `fn` passes.
+ */
+export declare function callExtension<T>(o: {
+    log: Pick<Logger, "warn">;
+    plugin: string;
+    what: string;
+    fields: Record<string, unknown>;
+    timeoutMs: number;
+    failCode: "ui.render_failed" | "ui.action_failed";
+    failMessage: string;
+    fn: (signal: AbortSignal) => Promise<T>;
+}): Promise<T>;

package/dist/ui/call-extension.js

@@ -0,0 +1,38 @@
+import { ApiError } from "../errors.js";
+/**
+ * Calls an extension with a time limit and an abort signal (plugin views, actions and file
+ * previewers): over the limit the signal aborts and the call is 504 `ui.timeout`; a throw is
+ * `failCode` (502) without echoing the extension's message. An `ApiError` thrown by `fn` passes.
+ */
+export async function callExtension(o) {
+    const ac = new AbortController();
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            ac.abort(new Error(`plugin ui ${o.what} timed out`));
+            resolve("timeout");
+        }, o.timeoutMs);
+    });
+    try {
+        const r = await Promise.race([
+            Promise.resolve()
+                .then(() => o.fn(ac.signal))
+                .then((value) => ({ value })),
+            timeout,
+        ]);
+        if (r === "timeout") {
+            o.log.warn(`plugin ui ${o.what} timed out`, { ...o.fields, timeoutMs: o.timeoutMs });
+            throw new ApiError("ui.timeout", `Plugin ${o.plugin} did not respond within ${o.timeoutMs / 1000}s`);
+        }
+        return r.value;
+    }
+    catch (e) {
+        if (e instanceof ApiError)
+            throw e;
+        o.log.warn(`plugin ui ${o.what} failed`, { ...o.fields, err: e });
+        throw new ApiError(o.failCode, o.failMessage);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/ui/embed-token.d.ts

@@ -6,20 +6,21 @@ export declare const EMBED_TOKEN_TTL_SECONDS = 300;
 export declare const EMBED_TOKEN_SKEW_SECONDS = 30;
 /** HKDF 用途（keyring 派生时 info 为 `capybara:capybara-embed/1`），也是签名输入的域前缀。 */
 export declare const EMBED_KEY_INFO = "capybara-embed/1";
+/** Optional provider: the clock {@link EmbedTokens} issues and checks with (default `Date.now`; tests). */
+export declare const EMBED_TOKEN_CLOCK: unique symbol;
 /**
  * 嵌入令牌：`base64url(JSON 声明).base64url(HMAC-SHA256(key, "capybara-embed/1." + 第一段))`。
  * - 格式固定、没有头（没有 alg 可混淆）；密钥由主密钥环经 HKDF 派生，轮换后上一把主密钥签的令牌仍可校验到过期；
  * - 校验：严格 base64url、常量时间比较签名、逐字段核对声明、`exp` 容许 {@link EMBED_TOKEN_SKEW_SECONDS} 秒偏差、
  *   `exp` 不得超过「现在 + 有效期 + 偏差」、`plugin` 必须是调用方插件；任何一项不过都返回 null（不说明原因）。
- * 无状态（不落库、不进 Redis）：各副本用同一主密钥即可校验，不需要共享状态。
+ * 无状态（不落库、不进 Redis）：各副本用同一主密钥即可校验，不需要共享状态。One provider: the UI
+ * routes issue tokens with it and every extension's `ctx` verifies them with it.
  */
 export declare class EmbedTokens {
+    private readonly now;
     private readonly current;
     private readonly keys;
-    private readonly now;
-    constructor(keyring: Keyring, opts?: {
-        now?: () => number;
-    });
+    constructor(keyring: Keyring, now?: () => number);
     /** 签发：`exp` = 现在 + {@link EMBED_TOKEN_TTL_SECONDS}。 */
     issue(c: Omit<EmbedClaims, "exp">): {
         token: string;
@@ -29,3 +30,6 @@ export declare class EmbedTokens {
     /** 校验令牌并要求它签给 `plugin`；不通过返回 null。 */
     verify(token: unknown, plugin: string): EmbedClaims | null;
 }
+/** {@link EmbedTokens} on its own: the extension host (`ctx`) and the UI routes import it. */
+export declare class EmbedTokensModule {
+}