@elizaos/plugin-wechat 2.0.0-alpha.537 → 2.0.0-beta.1

package/auto-enable.ts

@@ -0,0 +1,21 @@
+// Auto-enable check for @elizaos/plugin-wechat.
+//
+// Plugin manifest entry-point — referenced by package.json's
+// `elizaos.plugin.autoEnableModule`. Keep this module light: env reads only,
+// no service init, no transitive imports of the full plugin runtime. The
+// auto-enable engine loads dozens of these per boot.
+import type { PluginAutoEnableContext } from "@elizaos/core";
+
+/** Enable when a `wechat` connector block is present and not explicitly disabled. */
+export function shouldEnable(ctx: PluginAutoEnableContext): boolean {
+  const c = (ctx.config?.connectors as Record<string, unknown> | undefined)
+    ?.wechat;
+  if (!c || typeof c !== "object") return false;
+  const config = c as Record<string, unknown>;
+  if (config.enabled === false) return false;
+  // The full per-connector field check (appId/appSecret/encodingAESKey) lives
+  // in the central engine's isConnectorConfigured. We delegate to a simple
+  // "block present + not explicitly disabled" check here; the central
+  // engine's stricter check remains as a fallback during migration.
+  return true;
+}

package/dist/index.d.ts

@@ -98,6 +98,17 @@ declare class WechatChannel {
   stop(): Promise<void>;
   sendText(accountId: string, to: string, text: string): Promise<void>;
   sendImage(accountId: string, to: string, imagePath: string, caption?: string): Promise<void>;
+  getAccountIds(): string[];
+  listContacts(accountId: string): Promise<{
+    friends: Array<{
+      wxid: string;
+      name: string;
+    }>;
+    chatrooms: Array<{
+      wxid: string;
+      name: string;
+    }>;
+  }>;
   private routeIncoming;
   private ensureLoggedIn;
   private doLogin;
@@ -167,6 +178,15 @@ interface Plugin {
   name: string;
   description: string;
   init?: (config: Record<string, unknown>, runtime: unknown) => Promise<void | (() => Promise<void>)>;
+  /**
+   * Declarative auto-enable conditions consumed by the runtime's
+   * plugin-auto-enable engine. Mirrors the shape on `@elizaos/core` Plugin.
+   */
+  autoEnable?: {
+    envKeys?: string[];
+    connectorKeys?: string[];
+    shouldEnable?: (env: Record<string, string | undefined>, config: Record<string, unknown>) => boolean;
+  };
 }
 declare const wechatPlugin: Plugin;
 //#endregion

package/dist/index.js

@@ -1,7 +1,6 @@
+import { getConnectorAccountManager, stringToUuid } from "@elizaos/core";
 import { timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
-import { stringToUuid } from "@elizaos/core";
-
 //#region src/bot.ts
 const DEFAULT_DEDUP_WINDOW_MS = 1800 * 1e3;
 const DEDUP_MAX_ENTRIES = 1e3;
@@ -48,7 +47,6 @@ var Bot = class {
 		this.seen.clear();
 	}
 };
-
 //#endregion
 //#region src/callback-server.ts
 const WECHAT_TYPE_MAP = {
@@ -251,7 +249,6 @@ function normalizePayload(payload) {
 		raw: payload
 	};
 }
-
 //#endregion
 //#region src/proxy-client.ts
 const SUCCESS = 1e3;
@@ -367,7 +364,6 @@ function requireData(response, action) {
 	if (response.data === void 0) throw new Error(`${action} failed: missing response data`);
 	return response.data;
 }
-
 //#endregion
 //#region src/reply-dispatcher.ts
 const DEFAULT_CHUNK_SIZE = 2e3;
@@ -413,7 +409,6 @@ var ReplyDispatcher = class {
 		return chunks;
 	}
 };
-
 //#endregion
 //#region src/utils/qrcode.ts
 /**
@@ -432,7 +427,6 @@ function displayQRUrl(url) {
 	console.log("Open the URL above in your browser to see the QR code.");
 	console.log("");
 }
-
 //#endregion
 //#region src/channel.ts
 const HEALTH_CHECK_INTERVAL_MS = 6e4;
@@ -540,6 +534,14 @@ var WechatChannel = class {
 			} else throw err;
 		}
 	}
+	getAccountIds() {
+		return Array.from(this.accounts.keys());
+	}
+	async listContacts(accountId) {
+		const entry = this.accounts.get(accountId);
+		if (!entry) throw new Error(`Unknown account: ${accountId}`);
+		return entry.client.getContacts();
+	}
 	routeIncoming(accountId, msg) {
 		const entry = this.accounts.get(accountId);
 		if (!entry) {
@@ -619,7 +621,110 @@ var WechatChannel = class {
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
-
+//#endregion
+//#region src/connector-account-provider.ts
+const WECHAT_PROVIDER_ID = "wechat";
+const WECHAT_DEFAULT_ACCOUNT_ID = "default";
+function getWechatConfig(runtime) {
+	const character = runtime.character?.settings;
+	return character?.connectors?.wechat ?? character?.wechat;
+}
+function listWechatAccounts(runtime) {
+	const config = getWechatConfig(runtime);
+	const result = [];
+	if (!config) {
+		const envApiKey = runtime.getSetting?.("WECHAT_API_KEY");
+		const envProxy = runtime.getSetting?.("WECHAT_PROXY_URL");
+		if (envApiKey?.trim() || envProxy?.trim()) result.push({
+			id: WECHAT_DEFAULT_ACCOUNT_ID,
+			enabled: true,
+			apiKeyConfigured: Boolean(envApiKey?.trim()),
+			proxyUrl: envProxy?.trim() || void 0
+		});
+		return result;
+	}
+	if (config.enabled === false) {
+		if (config.apiKey?.trim() || config.accounts) result.push({
+			id: WECHAT_DEFAULT_ACCOUNT_ID,
+			enabled: false,
+			apiKeyConfigured: Boolean(config.apiKey?.trim()),
+			proxyUrl: config.proxyUrl
+		});
+		return result;
+	}
+	if (config.apiKey?.trim()) result.push({
+		id: WECHAT_DEFAULT_ACCOUNT_ID,
+		enabled: true,
+		apiKeyConfigured: true,
+		proxyUrl: config.proxyUrl
+	});
+	if (config.accounts && typeof config.accounts === "object") for (const [id, account] of Object.entries(config.accounts)) {
+		if (!id) continue;
+		result.push({
+			id: id.trim().toLowerCase(),
+			enabled: account.enabled !== false,
+			apiKeyConfigured: Boolean(account.apiKey?.trim()),
+			proxyUrl: account.proxyUrl,
+			wcId: account.wcId,
+			nickName: account.nickName,
+			name: account.name
+		});
+	}
+	return result;
+}
+function toConnectorAccount(account) {
+	const now = Date.now();
+	return {
+		id: account.id,
+		provider: WECHAT_PROVIDER_ID,
+		label: account.name ?? account.nickName ?? account.id,
+		role: "AGENT",
+		purpose: ["messaging"],
+		accessGate: "open",
+		status: account.enabled && account.apiKeyConfigured ? "connected" : "disabled",
+		externalId: account.wcId || void 0,
+		displayHandle: account.nickName || void 0,
+		createdAt: now,
+		updatedAt: now,
+		metadata: {
+			proxyUrl: account.proxyUrl ?? "",
+			wcId: account.wcId ?? "",
+			nickName: account.nickName ?? ""
+		}
+	};
+}
+function createWechatConnectorAccountProvider(runtime) {
+	return {
+		provider: WECHAT_PROVIDER_ID,
+		label: "WeChat",
+		listAccounts: async (_manager) => {
+			const accounts = listWechatAccounts(runtime);
+			if (accounts.length === 0) return [toConnectorAccount({
+				id: WECHAT_DEFAULT_ACCOUNT_ID,
+				enabled: false,
+				apiKeyConfigured: false
+			})];
+			return accounts.map(toConnectorAccount);
+		},
+		createAccount: async (input, _manager) => {
+			return {
+				...input,
+				provider: WECHAT_PROVIDER_ID,
+				role: input.role ?? "AGENT",
+				purpose: input.purpose ?? ["messaging"],
+				accessGate: input.accessGate ?? "open",
+				status: input.status ?? "pending"
+			};
+		},
+		patchAccount: async (_accountId, patch, _manager) => {
+			return {
+				...patch,
+				provider: WECHAT_PROVIDER_ID
+			};
+		},
+		deleteAccount: async (_accountId, _manager) => {}
+	};
+}
 //#endregion
 //#region src/runtime-bridge.ts
 async function deliverIncomingWechatMessage(options) {
@@ -775,7 +880,6 @@ async function maybeHandleResponseContent(result, replyDelivered, onResponse) {
 	if (replyDelivered || !result?.responseContent) return;
 	await onResponse(result.responseContent);
 }
-
 //#endregion
 //#region src/index.ts
 const WECHAT_PLUGIN_PACKAGE = "@elizaos/plugin-wechat";
@@ -790,11 +894,154 @@ function isWechatConnectorConfigured(config) {
 	return false;
 }
 let channel = null;
+function readRuntimeSetting(runtime, key) {
+	const value = runtime.getSetting?.(key);
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function resolveWechatConfig(config, runtime) {
+	const explicit = config?.connectors?.wechat;
+	if (explicit) return explicit;
+	const apiKey = readRuntimeSetting(runtime, "WECHAT_API_KEY");
+	const proxyUrl = readRuntimeSetting(runtime, "WECHAT_PROXY_URL");
+	if (!apiKey && !proxyUrl) return void 0;
+	return {
+		apiKey,
+		proxyUrl
+	};
+}
+function normalizeConnectorLimit(limit, fallback = 50) {
+	if (!Number.isFinite(limit) || !limit || limit <= 0) return fallback;
+	return Math.min(Math.floor(limit), 200);
+}
+function getConfiguredAccountIds(config) {
+	if (config.accounts && typeof config.accounts === "object") return Object.entries(config.accounts).filter(([, account]) => account.enabled !== false && Boolean(account.apiKey)).map(([id]) => id);
+	return config.apiKey ? ["default"] : [];
+}
+function resolveWechatAccountId(config, target) {
+	const metadata = target?.metadata;
+	const accountId = typeof metadata?.accountId === "string" && metadata.accountId.trim() ? metadata.accountId.trim() : void 0;
+	if (accountId) return accountId;
+	return channel?.getAccountIds()[0] ?? getConfiguredAccountIds(config)[0] ?? "default";
+}
+function wechatTarget(accountId, wxid, name, kind, score = .55) {
+	return {
+		target: {
+			source: "wechat",
+			channelId: wxid,
+			roomId: stringToUuid(`wechat:room:${accountId}:${wxid}`),
+			metadata: { accountId }
+		},
+		label: name || wxid,
+		kind,
+		score,
+		contexts: ["social", "connectors"],
+		metadata: {
+			accountId,
+			wxid
+		}
+	};
+}
+async function listWechatTargets(config) {
+	if (!channel) return [];
+	const targets = [];
+	for (const accountId of channel.getAccountIds()) {
+		const contacts = await channel.listContacts(accountId).catch(() => null);
+		if (!contacts) continue;
+		targets.push(...contacts.friends.map((friend) => wechatTarget(accountId, friend.wxid, friend.name, "user")), ...contacts.chatrooms.map((chatroom) => wechatTarget(accountId, chatroom.wxid, chatroom.name, "group")));
+	}
+	if (targets.length > 0) return targets;
+	return getConfiguredAccountIds(config).map((accountId) => wechatTarget(accountId, accountId, `WeChat account ${accountId}`, "user", .25));
+}
+function filterMemoriesByQuery(memories, query, limit) {
+	const normalized = query.trim().toLowerCase();
+	if (!normalized) return memories.slice(0, limit);
+	return memories.filter((memory) => {
+		return (typeof memory.content?.text === "string" ? memory.content.text : "").toLowerCase().includes(normalized);
+	}).slice(0, limit);
+}
+function registerWechatMessageConnector(runtime, config) {
+	const connectorRuntime = runtime;
+	const sendHandler = async (_runtime, target, content) => {
+		if (!channel) throw new Error("[wechat] Channel is not available");
+		const text = typeof content.text === "string" ? content.text.trim() : "";
+		if (!text) return;
+		const accountId = resolveWechatAccountId(config, target);
+		const to = String(target.channelId ?? target.entityId ?? "").trim();
+		if (!to) throw new Error("[wechat] target is missing channelId/entityId");
+		await channel.sendText(accountId, to, text);
+	};
+	if (typeof connectorRuntime.registerMessageConnector === "function") {
+		connectorRuntime.registerMessageConnector({
+			source: "wechat",
+			label: "WeChat",
+			description: "WeChat connector for sending and reading stored DM/group messages.",
+			capabilities: [
+				"send_message",
+				"resolve_targets",
+				"list_rooms",
+				"chat_context"
+			],
+			supportedTargetKinds: [
+				"user",
+				"group",
+				"room"
+			],
+			contexts: ["social", "connectors"],
+			resolveTargets: async (query) => {
+				const normalized = query.trim().toLowerCase();
+				return (await listWechatTargets(config)).map((target) => {
+					const haystack = `${target.label ?? ""} ${target.target.channelId ?? ""}`.toLowerCase();
+					return {
+						...target,
+						score: normalized && haystack.includes(normalized) ? .8 : target.score ?? .4
+					};
+				}).filter((target) => !normalized || (target.score ?? 0) >= .8).slice(0, 25);
+			},
+			listRecentTargets: async () => (await listWechatTargets(config)).slice(0, 10),
+			listRooms: async () => listWechatTargets(config),
+			fetchMessages: async (context, params) => {
+				const limit = normalizeConnectorLimit(params?.limit);
+				const target = params?.target ?? context.target;
+				if (target?.roomId) return context.runtime.getMemories({
+					tableName: "messages",
+					roomId: target.roomId,
+					limit,
+					orderBy: "createdAt",
+					orderDirection: "desc"
+				});
+				const targets = (await listWechatTargets(config)).slice(0, 10);
+				return (await Promise.all(targets.map((candidate) => candidate.target.roomId).filter((roomId) => Boolean(roomId)).map((roomId) => context.runtime.getMemories({
+					tableName: "messages",
+					roomId,
+					limit,
+					orderBy: "createdAt",
+					orderDirection: "desc"
+				})))).flat().sort((left, right) => (right.createdAt ?? 0) - (left.createdAt ?? 0)).slice(0, limit);
+			},
+			searchMessages: async (context, params) => {
+				const limit = normalizeConnectorLimit(params.limit);
+				return filterMemoriesByQuery(await (connectorRuntime.getMessageConnectors?.().find((connector) => connector.source === "wechat"))?.fetchMessages?.(context, {
+					target: params.target ?? context.target,
+					limit: Math.max(limit, 100)
+				}) ?? [], params.query, limit);
+			},
+			sendHandler
+		});
+		return;
+	}
+	connectorRuntime.registerSendHandler?.("wechat", sendHandler);
+}
 const wechatPlugin = {
 	name: "wechat",
 	description: "WeChat messaging via proxy API",
+	autoEnable: { connectorKeys: ["wechat"] },
 	async init(config, runtime) {
-		const wechatConfig = config?.connectors?.wechat;
+		try {
+			getConnectorAccountManager(runtime).registerProvider(createWechatConnectorAccountProvider(runtime));
+		} catch (err) {
+			console.warn("[wechat] Failed to register provider with ConnectorAccountManager:", err instanceof Error ? err.message : String(err));
+		}
+		const wechatConfig = resolveWechatConfig(config, runtime);
 		if (!wechatConfig) {
 			console.warn("[wechat] No wechat config found in connectors — skipping");
 			return;
@@ -818,6 +1065,7 @@ const wechatPlugin = {
 			}
 		});
 		await channel.start();
+		registerWechatMessageConnector(runtime, wechatConfig);
 		console.log("[wechat] Plugin initialized");
 		return async () => {
 			if (channel) {
@@ -828,6 +1076,5 @@ const wechatPlugin = {
 		};
 	}
 };
-
 //#endregion
-export { Bot, ProxyClient, ReplyDispatcher, WECHAT_PLUGIN_PACKAGE, WechatChannel, wechatPlugin as default, wechatPlugin, deliverIncomingWechatMessage, isWechatConnectorConfigured };
+export { Bot, ProxyClient, ReplyDispatcher, WECHAT_PLUGIN_PACKAGE, WechatChannel, wechatPlugin as default, wechatPlugin, deliverIncomingWechatMessage, isWechatConnectorConfigured };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/plugin-wechat",
-  "version": "2.0.0-alpha.537",
+  "version": "2.0.0-beta.1",
   "description": "WeChat connector plugin for elizaOS via proxy API",
   "type": "module",
   "license": "MIT",
@@ -22,25 +22,34 @@
   },
   "files": [
     "dist",
-    "src"
+    "src",
+    "auto-enable.ts"
   ],
+  "elizaos": {
+    "plugin": {
+      "autoEnableModule": "./auto-enable.ts",
+      "capabilities": [
+        "messaging"
+      ]
+    }
+  },
   "scripts": {
-    "build": "tsdown src/index.ts --format esm --dts --clean && mv dist/index-*.d.ts dist/index.d.ts 2>/dev/null || true",
+    "build": "tsdown && mv dist/index-*.d.ts dist/index.d.ts 2>/dev/null || true",
     "check": "tsc --noEmit",
     "test": "vitest run --config ./vitest.config.ts",
     "test:watch": "vitest --config ./vitest.config.ts",
     "clean": "rm -rf dist"
   },
   "peerDependencies": {
-    "@elizaos/core": "^2.0.0-alpha.537"
+    "@elizaos/core": "2.0.0-beta.1"
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@elizaos/core": "workspace:*",
-    "tsdown": "^0.21.0",
-    "typescript": "^6.0.0",
+    "@elizaos/core": "2.0.0-beta.1",
+    "tsdown": "^0.21.10",
+    "typescript": "^6.0.3",
     "vitest": "^4.0.18"
   },
   "agentConfig": {

package/src/channel.ts

@@ -184,6 +184,19 @@ export class WechatChannel {
     }
   }
 
+  getAccountIds(): string[] {
+    return Array.from(this.accounts.keys());
+  }
+
+  async listContacts(accountId: string): Promise<{
+    friends: Array<{ wxid: string; name: string }>;
+    chatrooms: Array<{ wxid: string; name: string }>;
+  }> {
+    const entry = this.accounts.get(accountId);
+    if (!entry) throw new Error(`Unknown account: ${accountId}`);
+    return entry.client.getContacts();
+  }
+
   private routeIncoming(accountId: string, msg: WechatMessageContext): void {
     const entry = this.accounts.get(accountId);
     if (!entry) {

package/src/connector-account-provider.ts

@@ -0,0 +1,180 @@
+/**
+ * WeChat ConnectorAccountManager provider.
+ *
+ * Adapts the multi-account scaffolding (`WechatConfig.accounts`) to the
+ * `ConnectorAccountProvider` contract from
+ * `@elizaos/core/connectors/account-manager`.
+ *
+ * Source of truth is the wechat config block (proxy URL + API key per account).
+ * AccountKey is the proxy account id (the key in `WechatConfig.accounts`) or
+ * `default` for single-account env-only deployments. Role is `AGENT` since
+ * wechat proxy creds authenticate the bot, not the user.
+ */
+
+import type {
+  ConnectorAccount,
+  ConnectorAccountManager,
+  ConnectorAccountPatch,
+  ConnectorAccountProvider,
+  IAgentRuntime,
+} from "@elizaos/core";
+import type { WechatConfig } from "./types";
+
+export const WECHAT_PROVIDER_ID = "wechat";
+export const WECHAT_DEFAULT_ACCOUNT_ID = "default";
+
+function getWechatConfig(runtime: IAgentRuntime): WechatConfig | undefined {
+  const character = runtime.character?.settings as
+    | { connectors?: { wechat?: WechatConfig }; wechat?: WechatConfig }
+    | undefined;
+  return character?.connectors?.wechat ?? character?.wechat;
+}
+
+interface WechatResolvedAccount {
+  id: string;
+  enabled: boolean;
+  apiKeyConfigured: boolean;
+  proxyUrl?: string;
+  wcId?: string;
+  nickName?: string;
+  name?: string;
+}
+
+function listWechatAccounts(runtime: IAgentRuntime): WechatResolvedAccount[] {
+  const config = getWechatConfig(runtime);
+  const result: WechatResolvedAccount[] = [];
+
+  if (!config) {
+    // Single-account env-only fallback
+    const envApiKey = runtime.getSetting?.("WECHAT_API_KEY") as
+      | string
+      | undefined;
+    const envProxy = runtime.getSetting?.("WECHAT_PROXY_URL") as
+      | string
+      | undefined;
+    if (envApiKey?.trim() || envProxy?.trim()) {
+      result.push({
+        id: WECHAT_DEFAULT_ACCOUNT_ID,
+        enabled: true,
+        apiKeyConfigured: Boolean(envApiKey?.trim()),
+        proxyUrl: envProxy?.trim() || undefined,
+      });
+    }
+    return result;
+  }
+
+  if (config.enabled === false) {
+    // Plugin disabled — still surface the account as `disabled`.
+    if (config.apiKey?.trim() || config.accounts) {
+      result.push({
+        id: WECHAT_DEFAULT_ACCOUNT_ID,
+        enabled: false,
+        apiKeyConfigured: Boolean(config.apiKey?.trim()),
+        proxyUrl: config.proxyUrl,
+      });
+    }
+    return result;
+  }
+
+  if (config.apiKey?.trim()) {
+    result.push({
+      id: WECHAT_DEFAULT_ACCOUNT_ID,
+      enabled: true,
+      apiKeyConfigured: true,
+      proxyUrl: config.proxyUrl,
+    });
+  }
+
+  if (config.accounts && typeof config.accounts === "object") {
+    for (const [id, account] of Object.entries(config.accounts)) {
+      if (!id) continue;
+      result.push({
+        id: id.trim().toLowerCase(),
+        enabled: account.enabled !== false,
+        apiKeyConfigured: Boolean(account.apiKey?.trim()),
+        proxyUrl: account.proxyUrl,
+        wcId: account.wcId,
+        nickName: account.nickName,
+        name: account.name,
+      });
+    }
+  }
+
+  return result;
+}
+
+function toConnectorAccount(account: WechatResolvedAccount): ConnectorAccount {
+  const now = Date.now();
+  return {
+    id: account.id,
+    provider: WECHAT_PROVIDER_ID,
+    label: account.name ?? account.nickName ?? account.id,
+    role: "AGENT",
+    purpose: ["messaging"],
+    accessGate: "open",
+    status:
+      account.enabled && account.apiKeyConfigured ? "connected" : "disabled",
+    externalId: account.wcId || undefined,
+    displayHandle: account.nickName || undefined,
+    createdAt: now,
+    updatedAt: now,
+    metadata: {
+      proxyUrl: account.proxyUrl ?? "",
+      wcId: account.wcId ?? "",
+      nickName: account.nickName ?? "",
+    },
+  };
+}
+
+export function createWechatConnectorAccountProvider(
+  runtime: IAgentRuntime,
+): ConnectorAccountProvider {
+  return {
+    provider: WECHAT_PROVIDER_ID,
+    label: "WeChat",
+    listAccounts: async (
+      _manager: ConnectorAccountManager,
+    ): Promise<ConnectorAccount[]> => {
+      const accounts = listWechatAccounts(runtime);
+      if (accounts.length === 0) {
+        // No accounts configured — surface a placeholder default so the
+        // connector is visible in the manager UI.
+        return [
+          toConnectorAccount({
+            id: WECHAT_DEFAULT_ACCOUNT_ID,
+            enabled: false,
+            apiKeyConfigured: false,
+          }),
+        ];
+      }
+      return accounts.map(toConnectorAccount);
+    },
+    createAccount: async (
+      input: ConnectorAccountPatch,
+      _manager: ConnectorAccountManager,
+    ) => {
+      return {
+        ...input,
+        provider: WECHAT_PROVIDER_ID,
+        role: input.role ?? "AGENT",
+        purpose: input.purpose ?? ["messaging"],
+        accessGate: input.accessGate ?? "open",
+        status: input.status ?? "pending",
+      };
+    },
+    patchAccount: async (
+      _accountId: string,
+      patch: ConnectorAccountPatch,
+      _manager: ConnectorAccountManager,
+    ) => {
+      return { ...patch, provider: WECHAT_PROVIDER_ID };
+    },
+    deleteAccount: async (
+      _accountId: string,
+      _manager: ConnectorAccountManager,
+    ) => {
+      // No-op at provider layer — runtime credentials live in character
+      // settings; deletion of those is out of band.
+    },
+  };
+}