create-windy 0.4.1 → 0.5.0

package/template/apps/server/src/license/runtime-audit-reliability.test.ts

@@ -1,3 +1,4 @@
+// @windy-module system.audit begin
 import { generateKeyPairSync, sign } from "node:crypto";
 import { describe, expect, test } from "bun:test";
 import {
@@ -94,3 +95,4 @@ function signedLicense() {
     publicKeyPem: publicKey.export({ type: "spki", format: "pem" }).toString(),
   };
 }
+// @windy-module system.audit end

package/template/apps/server/src/license/runtime-service.test.ts

@@ -12,11 +12,13 @@ import {
   type SignedLicenseV1,
 } from "@southwind-ai/shared";
 import { evaluateAccessGuards } from "../access-guards.js";
+// @windy-module system.agent begin
 import {
   createSystemToolHandlers,
   registerAgentRoutes,
 } from "../agent/routes.js";
 import { GovernedToolRegistry } from "../agent/tool-registry.js";
+// @windy-module system.agent end
 import { runGuardedBackgroundTask } from "../background/task-guard.js";
 import { createFoundationSnapshot, loadSystemModules } from "../foundation.js";
 import {
@@ -61,6 +63,7 @@ describe("客户业务平台 License 运行闭环", () => {
     expect(await status(fixture.app, "GET", "/api/system/users", true)).toBe(
       403,
     );
+    // @windy-module system.agent begin
     expect(
       await status(
         fixture.app,
@@ -69,6 +72,7 @@ describe("客户业务平台 License 运行闭环", () => {
         true,
       ),
     ).toBe(403);
+    // @windy-module system.agent end
     expect(
       await status(fixture.app, "GET", "/api/system/users/export", true),
     ).toBe(403);
@@ -264,6 +268,7 @@ function createFixture(
   const routeAuthorizer = createStaticRouteAuthorizer(runtime, modules);
   registerPlatformLicenseRoutes(app, licenseRuntime, routeAuthorizer);
   registerSystemRoutes(app, repositories, runtime, snapshot.features);
+  // @windy-module system.agent begin
   registerAgentRoutes(
     app,
     new GovernedToolRegistry(
@@ -273,6 +278,7 @@ function createFixture(
     ),
     routeAuthorizer,
   );
+  // @windy-module system.agent end
   return { app, runtime, licenseRuntime };
 }
 

package/template/apps/server/src/module-host/ai-operation-port.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+import { createModuleAiOperationPort } from "./ai-operation-port.js";
+
+describe("Module AI Operation canonical result", () => {
+  test("只把尚未完成的 RUN_CONFLICT 映射为 pending", async () => {
+    const port = agentPort(() =>
+      Response.json(
+        { code: "RUN_CONFLICT", message: "尚未完成" },
+        { status: 409 },
+      ),
+    );
+    await expect(
+      port.result({
+        kind: "agent",
+        operationKey: "analysis.copilot.case",
+        runId: "run-1",
+      }),
+    ).rejects.toMatchObject({ code: "AI_OPERATION_PENDING" });
+  });
+
+  test("failed 与 cancelled 的 409 映射为 canonical failure", async () => {
+    for (const code of ["RUNTIME_UNAVAILABLE", "RUN_CANCELLED"]) {
+      const port = agentPort(() =>
+        Response.json({ code, message: "终态" }, { status: 409 }),
+      );
+      await expect(
+        port.result({
+          kind: "agent",
+          operationKey: "analysis.copilot.case",
+          runId: "run-1",
+        }),
+      ).rejects.toMatchObject({ code: "AI_OPERATION_FAILED" });
+    }
+  });
+
+  test("503 暂不可用不能伪装成 Run 终态", async () => {
+    const port = agentPort(() =>
+      Response.json(
+        { code: "RUNTIME_UNAVAILABLE", message: "暂不可用" },
+        { status: 503 },
+      ),
+    );
+    await expect(
+      port.result({
+        kind: "agent",
+        operationKey: "analysis.copilot.case",
+        runId: "run-1",
+      }),
+    ).rejects.toMatchObject({ code: "AI_OPERATION_UNAVAILABLE" });
+  });
+});
+
+function agentPort(result: () => Response) {
+  return createModuleAiOperationPort(
+    "analysis",
+    {} as never,
+    AbortSignal.timeout(1_000),
+    {
+      agentFacade: { authorizeRun: async () => undefined },
+      agentRemote: { result: async () => result() },
+    } as never,
+  );
+}

package/template/apps/server/src/module-host/ai-operation-port.ts

@@ -49,6 +49,15 @@ export function createModuleAiOperationPort(
         signal,
       );
     },
+    async verifyAgentRun(input) {
+      own(input.operationKey);
+      await services.agentFacade.verifyRunInput(
+        input.operationKey,
+        input.runId,
+        input.input,
+        context,
+      );
+    },
     async startDocument(input) {
       own(input.operationKey);
       return services.documentFacade.start(
@@ -148,22 +157,38 @@ async function responseJson(response: Response): Promise<ModuleAiJsonValue> {
 
 async function responseError(response: Response) {
   let message = `AI Runtime 返回 ${response.status}`;
+  let remoteCode = "";
   try {
     const value = (await response.json()) as Record<string, unknown>;
     if (typeof value.message === "string") message = value.message;
+    if (typeof value.code === "string") remoteCode = value.code;
   } catch {
     // Runtime 正文不受信任；只保留稳定状态。
   }
   return new ModuleAiOperationError(
-    response.status === 404
-      ? "AI_OPERATION_INVALID"
-      : response.status === 409
-        ? "AI_OPERATION_PENDING"
-        : "AI_OPERATION_FAILED",
+    operationErrorCode(response.status, remoteCode),
     message,
   );
 }
 
+function operationErrorCode(status: number, remoteCode: string) {
+  if (status === 403) return "AI_OPERATION_FORBIDDEN" as const;
+  if (status === 404 || status === 400 || status === 422) {
+    return "AI_OPERATION_INVALID" as const;
+  }
+  if (status >= 500) return "AI_OPERATION_UNAVAILABLE" as const;
+  if (status === 409 && remoteCode === "RUN_CONFLICT") {
+    return "AI_OPERATION_PENDING" as const;
+  }
+  if (
+    status === 409 &&
+    (remoteCode === "RUN_CANCELLED" || remoteCode === "RUNTIME_UNAVAILABLE")
+  ) {
+    return "AI_OPERATION_FAILED" as const;
+  }
+  return "AI_OPERATION_INVALID" as const;
+}
+
 function jsonValue(value: unknown): ModuleAiJsonValue {
   return JSON.parse(JSON.stringify(value)) as ModuleAiJsonValue;
 }

package/template/apps/server/src/module-host/debug-session-provider-registration.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, test } from "bun:test";
+import type { ModuleManifest } from "@southwind-ai/modules";
+import {
+  MODULE_DEBUG_SESSION_SCHEMA_VERSION,
+  type ModuleDebugSessionProviderV1,
+} from "@southwind-ai/server-sdk";
+import { featureKey } from "@southwind-ai/shared";
+import { initializeModuleHosts } from "./initialize.js";
+import { manifest } from "./test-fixtures.js";
+
+describe("ADK 调试会话 Provider 注册", () => {
+  test("只接受同模块 Agent Operation 的 Feature 与权限绑定", async () => {
+    const module = debugManifest();
+    const provider = debugProvider();
+    const hosts = await initializeModuleHosts({
+      modules: [module],
+      installations: [
+        {
+          manifest: module,
+          setup(host) {
+            host.registerDebugSessionProviders([provider]);
+          },
+        },
+      ],
+    });
+
+    expect(hosts.debugSessionProviders).toEqual([
+      { moduleName: "known", provider },
+    ]);
+
+    await expect(
+      initializeWith({
+        ...provider,
+        permissionKey: "known.copilot.manage",
+      }),
+    ).rejects.toThrow("必须复用 Operation 的 Feature 与权限");
+    await expect(
+      initializeWith({
+        ...provider,
+        operationKeys: ["known.missing"],
+      }),
+    ).rejects.toThrow("未声明为 Agent");
+  });
+
+  test("协议版本、Manifest 审计动作、命名空间与重复 Key fail closed", async () => {
+    await expect(
+      initializeWith({
+        ...debugProvider(),
+        key: "other.history",
+      }),
+    ).rejects.toThrow("不属于模块 known");
+    await expect(
+      initializeWith({
+        ...debugProvider(),
+        auditAction: "known.missing",
+      }),
+    ).rejects.toThrow("审计动作未在 Manifest 声明");
+    await expect(
+      initializeWith({
+        ...debugProvider(),
+        schemaVersion: 2 as 1,
+      }),
+    ).rejects.toThrow("协议版本不受支持");
+
+    const module = debugManifest();
+    const provider = debugProvider();
+    await expect(
+      initializeModuleHosts({
+        modules: [module],
+        installations: [
+          {
+            manifest: module,
+            setup(host) {
+              host.registerDebugSessionProviders([provider, provider]);
+            },
+          },
+        ],
+      }),
+    ).rejects.toThrow("重复注册");
+  });
+});
+
+async function initializeWith(provider: ModuleDebugSessionProviderV1) {
+  const module = debugManifest();
+  return initializeModuleHosts({
+    modules: [module],
+    installations: [
+      {
+        manifest: module,
+        setup(host) {
+          host.registerDebugSessionProviders([provider]);
+        },
+      },
+    ],
+  });
+}
+
+function debugProvider(): ModuleDebugSessionProviderV1 {
+  return {
+    schemaVersion: MODULE_DEBUG_SESSION_SCHEMA_VERSION,
+    key: "known.copilot.history",
+    operationKeys: ["known.copilot.global"],
+    featureKey: "known.copilot",
+    permissionKey: "known.copilot.execute",
+    auditAction: "known.copilot.history.read",
+    list: async () => ({ sessions: [], truncated: false }),
+    get: async () => undefined,
+  };
+}
+
+function debugManifest(): ModuleManifest {
+  return manifest("known", {
+    features: [
+      {
+        key: featureKey("known.copilot"),
+        label: "Copilot",
+        module: "known",
+        visible: "visible",
+        enabled: true,
+        stage: "stable",
+      },
+    ],
+    permissions: [
+      permission("known.copilot.execute"),
+      permission("known.copilot.manage"),
+    ],
+    aiOperations: [
+      {
+        key: "known.copilot.global",
+        kind: "agent",
+        featureKey: "known.copilot",
+        permissionKey: "known.copilot.execute",
+        auditAction: "known.copilot.execute",
+        inputSchemaKey: "known.copilot.input.v1",
+        outputSchemaKey: "known.copilot.output.v1",
+        requiredCapabilities: ["text-generation"],
+        allowedToolKeys: [],
+        dataClassification: "internal",
+        execution: "streaming",
+        publicNetworkAccess: "forbidden",
+        limits: {
+          maxDurationSeconds: 60,
+          maxInputBytes: 4096,
+          maxOutputBytes: 4096,
+        },
+      },
+    ],
+    auditActions: ["known.copilot.execute", "known.copilot.history.read"],
+  });
+}
+
+function permission(key: string) {
+  return {
+    key,
+    label: key,
+    module: "known",
+    moduleLabel: "Known",
+    resource: "copilot",
+    resourceLabel: "Copilot",
+    action: "execute" as const,
+  };
+}

package/template/apps/server/src/module-host/debug-session-provider-registration.ts

@@ -0,0 +1,84 @@
+import type { ModuleManifest } from "@southwind-ai/modules";
+import {
+  MODULE_DEBUG_SESSION_SCHEMA_VERSION,
+  requireModuleNamespace,
+  type ModuleDebugSessionProviderV1,
+} from "@southwind-ai/server-sdk";
+
+export function validateDebugSessionProviderRegistration(
+  manifest: ModuleManifest,
+  provider: ModuleDebugSessionProviderV1,
+): void {
+  const moduleName = manifest.name;
+  requireModuleNamespace("调试会话 Provider", provider.key, moduleName);
+  requireModuleNamespace(
+    "调试会话 Provider Feature",
+    provider.featureKey,
+    moduleName,
+  );
+  requireModuleNamespace(
+    "调试会话 Provider 权限",
+    provider.permissionKey,
+    moduleName,
+  );
+  requireModuleNamespace(
+    "调试会话 Provider 审计动作",
+    provider.auditAction,
+    moduleName,
+  );
+  if (provider.schemaVersion !== MODULE_DEBUG_SESSION_SCHEMA_VERSION) {
+    throw new Error(`调试会话 Provider 协议版本不受支持：${provider.key}`);
+  }
+  if (!manifest.features.some(({ key }) => key === provider.featureKey)) {
+    throw new Error(
+      `调试会话 Provider Feature 未在 Manifest 声明：${provider.featureKey}`,
+    );
+  }
+  if (!manifest.permissions.some(({ key }) => key === provider.permissionKey)) {
+    throw new Error(
+      `调试会话 Provider 权限未在 Manifest 声明：${provider.permissionKey}`,
+    );
+  }
+  if (!manifestAuditActions(manifest).has(provider.auditAction)) {
+    throw new Error(
+      `调试会话 Provider 审计动作未在 Manifest 声明：${provider.auditAction}`,
+    );
+  }
+  if (provider.operationKeys.length === 0) {
+    throw new Error(
+      `调试会话 Provider 必须绑定至少一个 Operation：${provider.key}`,
+    );
+  }
+  const operationKeys = new Set<string>();
+  for (const operationKey of provider.operationKeys) {
+    requireModuleNamespace("调试会话 Operation", operationKey, moduleName);
+    if (operationKeys.has(operationKey)) {
+      throw new Error(`调试会话 Provider Operation 重复：${operationKey}`);
+    }
+    operationKeys.add(operationKey);
+    const operation = manifest.aiOperations?.find(
+      ({ key }) => key === operationKey,
+    );
+    if (!operation || operation.kind !== "agent") {
+      throw new Error(
+        `调试会话 Provider Operation 未声明为 Agent：${operationKey}`,
+      );
+    }
+    if (
+      operation.featureKey !== provider.featureKey ||
+      operation.permissionKey !== provider.permissionKey
+    ) {
+      throw new Error(
+        `调试会话 Provider 必须复用 Operation 的 Feature 与权限：${operationKey}`,
+      );
+    }
+  }
+}
+
+function manifestAuditActions(manifest: ModuleManifest): ReadonlySet<string> {
+  return new Set(
+    manifest.auditActions.map((action) =>
+      typeof action === "string" ? action : action.key,
+    ),
+  );
+}

package/template/apps/server/src/module-host/initialize-contracts.ts

@@ -3,6 +3,7 @@ import type { ModuleManifest } from "@southwind-ai/modules";
 import type {
   InstallableServerModule,
   ModuleAiOperationHandlerRegistration,
+  ModuleDebugSessionProviderV1,
   ModuleDurableHandlerDefinition,
   ModuleInitializer,
   ModuleGovernedResourceRegistration,
@@ -64,6 +65,11 @@ export interface RegisteredModuleSearchProvider {
   readonly provider: ModuleSearchProvider;
 }
 
+export interface RegisteredModuleDebugSessionProvider {
+  readonly moduleName: string;
+  readonly provider: ModuleDebugSessionProviderV1;
+}
+
 export interface InitializeModuleHostsInput {
   modules: readonly ModuleManifest[];
   /** Manifest 与 setup 由同一业务模块安装单元贡献。 */
@@ -86,6 +92,7 @@ export interface InitializedModuleHosts {
   readonly governedResources: readonly RegisteredModuleGovernedResource[];
   readonly rolePresets: readonly RegisteredModuleRolePreset[];
   readonly searchProviders: readonly RegisteredModuleSearchProvider[];
+  readonly debugSessionProviders: readonly RegisteredModuleDebugSessionProvider[];
   manifestOf(moduleName: string): ModuleManifest;
   /** 该模块经 Host 注册的上传用途集合（不含平台基础用途）。 */
   uploadPurposesOf(moduleName: string): ReadonlySet<string>;

package/template/apps/server/src/module-host/initialize.ts

@@ -1,38 +1,20 @@
-import { DurableHandlerRegistry } from "@southwind-ai/jobs";
-import type { ModuleManifest } from "@southwind-ai/modules";
 import {
-  requireModuleNamespace,
-  type ModuleHost,
   type ModuleResourceFileAccessPolicy,
   type ModuleUploadPolicy,
 } from "@southwind-ai/server-sdk";
 import type {
   InitializedModuleHosts,
   InitializeModuleHostsInput,
-  RegisteredModuleAiOperationHandler,
-  RegisteredModuleDurableHandler,
-  RegisteredModuleGovernedResource,
-  RegisteredModuleRolePreset,
-  RegisteredModuleRoute,
-  RegisteredModuleSearchProvider,
-  RegisteredModuleSandboxToolHandler,
-  RegisteredModuleTaskHandler,
-  RegisteredModuleToolHandler,
 } from "./initialize-contracts.js";
-import { registerModuleDurableHandler } from "./durable-handler-registration.js";
-import { registerGovernedResources } from "./governed-resources.js";
-import {
-  registerResourceFileAccessPolicies,
-  validateResourceFileAccessPurposes,
-} from "./resource-file-policies.js";
-import { validateRouteDeclaration } from "./route-declaration.js";
+import { validateResourceFileAccessPurposes } from "./resource-file-policies.js";
 import { createScopedSandboxHost } from "./sandbox-tool-registration.js";
-import { validateSearchProviderRegistration } from "./search-provider-registration.js";
+import { createScopedHost, type HostCollections } from "./scoped-host.js";
 
 export type {
   InitializedModuleHosts,
   InitializeModuleHostsInput,
   RegisteredModuleAiOperationHandler,
+  RegisteredModuleDebugSessionProvider,
   RegisteredModuleDurableHandler,
   RegisteredModuleGovernedResource,
   RegisteredModuleRolePreset,
@@ -43,8 +25,6 @@ export type {
   RegisteredModuleToolHandler,
 } from "./initialize-contracts.js";
 
-type HandlerInstaller = (registry: DurableHandlerRegistry) => void;
-
 export async function initializeModuleHosts(
   input: InitializeModuleHostsInput,
 ): Promise<InitializedModuleHosts> {
@@ -92,6 +72,8 @@ export async function initializeModuleHosts(
     rolePresetKeys: new Set<string>(),
     searchProviders: [],
     searchProviderKeys: new Set<string>(),
+    debugSessionProviders: [],
+    debugSessionProviderKeys: new Set<string>(),
   };
 
   const installations = [
@@ -149,6 +131,7 @@ export async function initializeModuleHosts(
     governedResources: [...state.governedResources],
     rolePresets: [...state.rolePresets],
     searchProviders: [...state.searchProviders],
+    debugSessionProviders: [...state.debugSessionProviders],
     manifestOf(moduleName) {
       const manifest = manifests.get(moduleName);
       if (!manifest) throw new Error(`模块未安装：${moduleName}`);
@@ -172,177 +155,3 @@ export async function initializeModuleHosts(
     },
   };
 }
-
-interface HostCollections {
-  uploadPolicies: ModuleUploadPolicy[];
-  uploadPurposes: Set<string>;
-  modulePurposes: Map<string, Set<string>>;
-  moduleDependencies: ReadonlyMap<string, readonly string[]>;
-  resourceFileAccessPolicies: ModuleResourceFileAccessPolicy[];
-  moduleResourceFileAccessPolicies: Map<
-    string,
-    ModuleResourceFileAccessPolicy[]
-  >;
-  resourceFileAccessPolicyKeys: Set<string>;
-  handlerKeys: Set<string>;
-  handlerInstallers: HandlerInstaller[];
-  durableHandlers: RegisteredModuleDurableHandler[];
-  routes: RegisteredModuleRoute[];
-  routeKeys: Set<string>;
-  taskHandlers: RegisteredModuleTaskHandler[];
-  taskKeys: Set<string>;
-  toolHandlers: RegisteredModuleToolHandler[];
-  sandboxToolHandlers: RegisteredModuleSandboxToolHandler[];
-  toolKeys: Set<string>;
-  aiOperationHandlers: RegisteredModuleAiOperationHandler[];
-  aiOperationKeys: Set<string>;
-  governedResources: RegisteredModuleGovernedResource[];
-  governedResourceKeys: Set<string>;
-  rolePresets: RegisteredModuleRolePreset[];
-  rolePresetKeys: Set<string>;
-  searchProviders: RegisteredModuleSearchProvider[];
-  searchProviderKeys: Set<string>;
-}
-
-function createScopedHost(
-  manifest: ModuleManifest,
-  state: HostCollections,
-): ModuleHost {
-  const moduleName = manifest.name;
-  return {
-    moduleName,
-    registerUploadPolicy(policy) {
-      requireModuleNamespace("上传用途", policy.purpose, moduleName);
-      if (state.uploadPurposes.has(policy.purpose)) {
-        throw new Error(`上传用途重复注册：${policy.purpose}`);
-      }
-      state.uploadPurposes.add(policy.purpose);
-      state.uploadPolicies.push(policy);
-      const purposes =
-        state.modulePurposes.get(moduleName) ?? new Set<string>();
-      purposes.add(policy.purpose);
-      state.modulePurposes.set(moduleName, purposes);
-    },
-    registerResourceFileAccessPolicies(policies) {
-      registerResourceFileAccessPolicies(manifest, state, policies);
-    },
-    registerDurableHandler(definition) {
-      requireModuleNamespace("任务 handler", definition.key, moduleName);
-      registerModuleDurableHandler(manifest, state, definition);
-    },
-    registerGovernedResources(registrations) {
-      registerGovernedResources(manifest, state, registrations);
-    },
-    registerRoutes(routes) {
-      for (const definition of routes) {
-        requireModuleNamespace(
-          "路由权限",
-          definition.permissionKey,
-          moduleName,
-        );
-        validateRouteDeclaration(manifest, definition);
-        const key = `${definition.method} ${definition.path}`;
-        if (state.routeKeys.has(key)) {
-          throw new Error(`模块路由重复注册：${key}`);
-        }
-        state.routeKeys.add(key);
-        state.routes.push({ moduleName, definition });
-      }
-    },
-    registerTaskHandlers(registrations) {
-      for (const registration of registrations) {
-        requireModuleNamespace("定时任务", registration.taskKey, moduleName);
-        if (!manifest.tasks.some(({ key }) => key === registration.taskKey)) {
-          throw new Error(
-            `定时任务 Handler 未在 Manifest 声明：${registration.taskKey}`,
-          );
-        }
-        if (state.taskKeys.has(registration.taskKey)) {
-          throw new Error(`定时任务 Handler 重复注册：${registration.taskKey}`);
-        }
-        state.taskKeys.add(registration.taskKey);
-        state.taskHandlers.push({ moduleName, registration });
-      }
-    },
-    registerToolHandlers(registrations) {
-      for (const registration of registrations) {
-        requireModuleNamespace("Agent Tool", registration.toolKey, moduleName);
-        if (!manifest.tools.some(({ key }) => key === registration.toolKey)) {
-          throw new Error(
-            `Agent Tool Handler 未在 Manifest 声明：${registration.toolKey}`,
-          );
-        }
-        if (state.toolKeys.has(registration.toolKey)) {
-          throw new Error(
-            `Agent Tool Handler 重复注册：${registration.toolKey}`,
-          );
-        }
-        state.toolKeys.add(registration.toolKey);
-        state.toolHandlers.push({ moduleName, registration });
-      }
-    },
-    registerAiOperationHandlers(registrations) {
-      for (const registration of registrations) {
-        requireModuleNamespace(
-          "AI Operation",
-          registration.operationKey,
-          moduleName,
-        );
-        const operation = manifest.aiOperations?.find(
-          ({ key }) => key === registration.operationKey,
-        );
-        if (!operation) {
-          throw new Error(
-            `AI Operation Handler 未在 Manifest 声明：${registration.operationKey}`,
-          );
-        }
-        if (
-          (operation.kind === "agent" && !registration.prepare) ||
-          (operation.kind === "document" && !registration.prepareDocument) ||
-          (operation.kind === "speech" && !registration.prepareSpeech) ||
-          (operation.kind === "embedding" && !registration.prepareEmbedding)
-        ) {
-          throw new Error(
-            `AI Operation Handler 与 kind 不匹配：${registration.operationKey}`,
-          );
-        }
-        if (state.aiOperationKeys.has(registration.operationKey)) {
-          throw new Error(
-            `AI Operation Handler 重复注册：${registration.operationKey}`,
-          );
-        }
-        state.aiOperationKeys.add(registration.operationKey);
-        state.aiOperationHandlers.push({ moduleName, registration });
-      }
-    },
-    registerRolePresets(presets) {
-      for (const preset of presets) {
-        requireModuleNamespace("角色预设", preset.key, moduleName);
-        if (state.rolePresetKeys.has(preset.key)) {
-          throw new Error(`角色预设重复注册：${preset.key}`);
-        }
-        for (const permissionKey of preset.permissionKeys) {
-          requireModuleNamespace("角色预设权限", permissionKey, moduleName);
-          if (!manifest.permissions.some(({ key }) => key === permissionKey)) {
-            throw new Error(
-              `角色预设引用了模块 ${moduleName} 未声明权限：${permissionKey}`,
-            );
-          }
-        }
-        state.rolePresetKeys.add(preset.key);
-        state.rolePresets.push({ moduleName, preset });
-      }
-    },
-    registerSearchProviders(providers) {
-      for (const provider of providers) {
-        requireModuleNamespace("搜索 Provider", provider.key, moduleName);
-        validateSearchProviderRegistration(manifest, provider);
-        if (state.searchProviderKeys.has(provider.key)) {
-          throw new Error(`搜索 Provider 重复注册：${provider.key}`);
-        }
-        state.searchProviderKeys.add(provider.key);
-        state.searchProviders.push({ moduleName, provider });
-      }
-    },
-  };
-}