@epoch-agent/plugin-mcp 0.1.0 → 0.2.0

package/dist/index.js

@@ -9,7 +9,6 @@ function configFingerprint(config) {
     args: config.args ?? [],
     url: config.url ?? null,
     streamable: config.streamable ?? false,
-    // header 的值可能是 token，指纹只取键名 + 值的哈希，不落明文
     headers: Object.keys(config.headers ?? {}).sort(),
     headersDigest: hash(JSON.stringify(config.headers ?? {})),
     env: Object.keys(config.env ?? {}).sort()
@@ -20,34 +19,25 @@ function hash(input) {
   return createHash("sha256").update(input, "utf-8").digest("hex");
 }
 var McpSchemaCache = class {
-  /** @param cacheFile 磁盘缓存文件路径；传 null 表示只用内存（测试 / 无家目录场景） */
   constructor(cacheFile = null) {
     this.cacheFile = cacheFile;
   }
   cacheFile;
   memory = /* @__PURE__ */ new Map();
   disk = null;
-  /** 内存命中才算「新鲜」—— 磁盘的走 {@link getPersisted} */
   getFresh(name, fingerprint) {
     const entry = this.memory.get(name);
     return entry && entry.fingerprint === fingerprint ? entry.tools : null;
   }
-  /** 上次成功落盘的 schema，仅在 live 调用失败时作为降级使用 */
   getPersisted(name, fingerprint) {
     const entry = this.loadDisk()[name];
     return entry && entry.fingerprint === fingerprint ? entry.tools : null;
   }
-  /** live 拉取成功后写入两层 */
   set(name, fingerprint, tools) {
     const entry = { fingerprint, tools };
     this.memory.set(name, entry);
     this.writeDisk(name, entry);
   }
-  /**
-   * 显式失效。不传 name 清全部。
-   *
-   * 调用方：`McpRegistry.reconnect()`，以及将来的 `notifications/tools/list_changed`。
-   */
   invalidate(name) {
     if (name === void 0) {
       this.memory.clear();
@@ -55,7 +45,6 @@ var McpSchemaCache = class {
     }
     this.memory.delete(name);
   }
-  // ---- 磁盘 ----
   loadDisk() {
     if (this.disk) return this.disk;
     if (!this.cacheFile) {
@@ -90,11 +79,9 @@ function isDiskShape(value) {
     (entry) => typeof entry === "object" && entry !== null && typeof entry.fingerprint === "string" && Array.isArray(entry.tools)
   );
 }
-
 // src/client.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { ToolListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
-
 // src/content.ts
 var DEFAULT_MEDIA_TYPE = "application/octet-stream";
 function str(v) {
@@ -143,8 +130,8 @@ function convertMcpContent(content) {
     const type = typeof item?.type === "string" ? item.type : void 0;
     switch (type) {
       case "text": {
-        const t = str(item.text);
-        if (t) texts.push(t);
+        const t10 = str(item.text);
+        if (t10) texts.push(t10);
         break;
       }
       case "image":
@@ -170,45 +157,40 @@ function convertMcpContent(content) {
   }
   return { text: texts.join("\n"), artifacts };
 }
-
 // src/oauth/attach.ts
 import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
-
+import { t as t3 } from "@epoch-agent/infra";
 // src/oauth/provider.ts
 import { randomBytes } from "crypto";
-
+import { t as t2 } from "@epoch-agent/infra";
 // src/oauth/types.ts
+import { t } from "@epoch-agent/infra";
 var McpLoginRequiredError = class extends Error {
   constructor(server, detail) {
     super(
-      `MCP server "${server}" \u9700\u8981 OAuth \u767B\u5F55\uFF1A\u5148\u8DD1 epoch mcp login ${server}` + (detail ? `\uFF08${detail}\uFF09` : "")
+      t("mcp_oauth.needs_login", { server }) + (detail ? t("mcp_oauth.needs_login_detail", { detail }) : "")
     );
     this.server = server;
     this.name = "McpLoginRequiredError";
   }
   server;
 };
-
 // src/oauth/provider.ts
 var CLIENT_NAME = "epoch-agent";
 var CLIENT_URI = "https://gitlab.linkworld.cn/chenboxuan/epoch-agent";
 var PLACEHOLDER_REDIRECT_URI = "http://127.0.0.1:0/callback";
 var McpOAuthProvider = class {
   opts;
-  /** 本次流程生成的 state，回调时用来验 CSRF */
   currentState;
   constructor(opts) {
     this.opts = opts;
   }
-  /** 本次授权流程用的 state，回调服务器拿它比对 */
   get expectedState() {
     return this.currentState;
   }
-  /** 见 `PLACEHOLDER_REDIRECT_URI`：这里返回 undefined 会让 SDK 跳过 refresh */
   get redirectUrl() {
     return this.opts.redirectUri ?? PLACEHOLDER_REDIRECT_URI;
   }
-  /** 真的能跳转吗（交互式登录才能）。占位地址不算 */
   get interactive() {
     return this.opts.onRedirect !== void 0;
   }
@@ -223,13 +205,6 @@ var McpOAuthProvider = class {
       ...this.opts.scope ? { scope: this.opts.scope } : {}
     };
   }
-  /**
-   * OAuth 的 `state` 参数。
-   *
-   * SDK 把它当**生成器**调（每次授权一个新值），不是「读一个固定值」——
-   * opencode `src/mcp/oauth-provider.ts` 里踩过这个：写成只读缓存的话，
-   * 两次登录会拿到同一个 state，回调分不清是哪一次。
-   */
   state() {
     this.currentState = randomBytes(32).toString("base64url");
     return this.currentState;
@@ -245,13 +220,6 @@ var McpOAuthProvider = class {
   tokens() {
     return this.entry()?.tokens;
   }
-  /**
-   * 存 token。
-   *
-   * 顺手把 `expires_in`（相对秒数）换算成绝对时刻落盘 —— 相对值一重启就是错的。
-   * 同时清掉 `codeVerifier`：它只在「跳转了、还没换到 token」那段窗口有用，
-   * 换到了就是一份没有用处的秘密，留着只是多一处泄漏点。
-   */
   saveTokens(tokens) {
     const expiresAt = typeof tokens.expires_in === "number" && tokens.expires_in > 0 ? Date.now() + tokens.expires_in * 1e3 : void 0;
     this.opts.store.update(this.opts.server, this.opts.serverUrl, {
@@ -263,7 +231,7 @@ var McpOAuthProvider = class {
   }
   async redirectToAuthorization(url) {
     if (!this.opts.onRedirect) {
-      throw new McpLoginRequiredError(this.opts.server, "\u5DF2\u6709\u51ED\u636E\u65E0\u6CD5\u7EED\u671F\u6216\u5C1A\u672A\u6388\u6743");
+      throw new McpLoginRequiredError(this.opts.server, t2("mcp_oauth.no_refresh"));
     }
     await this.opts.onRedirect(url);
   }
@@ -273,16 +241,10 @@ var McpOAuthProvider = class {
   codeVerifier() {
     const verifier = this.entry()?.codeVerifier;
     if (!verifier) {
-      throw new McpLoginRequiredError(this.opts.server, "PKCE code_verifier \u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55");
+      throw new McpLoginRequiredError(this.opts.server, t2("mcp_oauth.pkce_lost"));
     }
     return verifier;
   }
-  /**
-   * 服务端说凭据不好使了，SDK 调这里让我们删掉。
-   *
-   * 不实现的话用户要自己去删 `~/.epoch/mcp-auth.json` —— 而「client 注册
-   * 被服务端撤销」这种情况下，不删就会一直拿同一个失效 client_id 重试。
-   */
   invalidateCredentials(scope) {
     if (scope === "all") {
       this.opts.store.remove(this.opts.server);
@@ -308,7 +270,6 @@ var McpOAuthProvider = class {
     return this.opts.store.get(this.opts.server, this.opts.serverUrl);
   }
 };
-
 // src/oauth/attach.ts
 function createAuthProvider(config, store) {
   if (config.transport === "stdio" || !config.url) return void 0;
@@ -319,7 +280,6 @@ function createAuthProvider(config, store) {
     serverUrl: config.url,
     store,
     scope: config.oauth?.scope
-    // 刻意不给 onRedirect：连接期绝不弹浏览器，需要授权就抛「请先 login」
   });
 }
 function hasAuthorizationHeader(headers) {
@@ -329,13 +289,12 @@ function hasAuthorizationHeader(headers) {
 function describeAuthFailure(err, server) {
   if (err instanceof McpLoginRequiredError) return err.message;
   if (err instanceof UnauthorizedError) {
-    return new McpLoginRequiredError(server, err.message || "token \u5DF2\u5931\u6548\u4E14\u65E0\u6CD5\u7EED\u671F").message;
+    return new McpLoginRequiredError(server, err.message || t3("mcp_oauth.token_dead")).message;
   }
   const cause = err?.cause;
   if (cause !== void 0 && cause !== err) return describeAuthFailure(cause, server);
   return null;
 }
-
 // src/oauth/store.ts
 import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
 import { dirname as dirname2 } from "path";
@@ -344,42 +303,33 @@ import {
   isEnvelope,
   mcpAuthPath,
   openEnvelope,
-  sealEnvelope
+  sealEnvelope,
+  t as t4
 } from "@epoch-agent/infra";
 var FILE_VERSION = 1;
 var REFRESH_SKEW_MS = 3e4;
 var McpAuthStore = class {
   filePath;
   cache = null;
-  /** 磁盘上是密文、但本次运行拿不到数据密钥。此时**只读不写**，见 load() / save() */
   locked = false;
-  /** @param filePath 显式路径（测试用）；不传走 infra 的路径真源 */
   constructor(filePath, homeDir) {
     this.filePath = filePath ?? mcpAuthPath(homeDir);
   }
   get path() {
     return this.filePath;
   }
-  /**
-   * 读一个 server 的凭据。
-   *
-   * @param serverUrl 当前配置里的 URL。和落盘时记的对不上就返回 undefined ——
-   *                  换了地址的 token 不能拿去打新地址。
-   */
   get(server, serverUrl) {
     const entry = this.load().servers[server];
     if (!entry) return void 0;
     if (serverUrl !== void 0 && !sameEndpoint(entry.serverUrl, serverUrl)) return void 0;
     return entry;
   }
-  /** 不比对 URL 的读法，只给 `epoch mcp status` 展示用 */
   getRaw(server) {
     return this.load().servers[server];
   }
   list() {
     return Object.entries(this.load().servers);
   }
-  /** 局部更新一个 server 的条目；`serverUrl` 变了会先清空旧凭据 */
   update(server, serverUrl, patch) {
     const file = this.load();
     this.assertWritable();
@@ -388,7 +338,6 @@ var McpAuthStore = class {
     file.servers[server] = { ...base, ...patch, serverUrl };
     this.save(file);
   }
-  /** 删掉一个 server 的全部凭据。@returns 之前是否存在 */
   remove(server) {
     const file = this.load();
     this.assertWritable();
@@ -397,11 +346,9 @@ var McpAuthStore = class {
     this.save(file);
     return true;
   }
-  /** 强制下次 `get` 重新读盘。外部改过文件（另一个进程登录过）时用 */
   invalidate() {
     this.cache = null;
   }
-  // ---- 内部 ----
   load() {
     if (this.cache) return this.cache;
     if (!existsSync(this.filePath)) {
@@ -417,18 +364,9 @@ var McpAuthStore = class {
     }
     return this.cache;
   }
-  /**
-   * 磁盘上是密文而当前解不开时，任何写操作都必须**当场失败**。
-   *
-   * 在改动内存状态之前就拦（而不是等到 save()）：`update()` 是先改缓存再落盘的，
-   * 到 save() 才抛会留下一个「内存里改了、盘上没改」的错位状态，
-   * 下一次读会拿到一份不存在于磁盘的凭据。
-   */
   assertWritable() {
     if (!this.locked) return;
-    throw new Error(
-      `${this.filePath} \u662F\u52A0\u5BC6\u7684\uFF0C\u4F46\u5F53\u524D\u62FF\u4E0D\u5230\u6570\u636E\u5BC6\u94A5\uFF0C\u62D2\u7EDD\u5199\u5165\u4EE5\u514D\u8986\u76D6\u5DF2\u6709\u51ED\u636E\u3002\u8DD1 epoch doctor \u770B Secret \u90A3\u4E00\u884C\u662F\u4EC0\u4E48\u539F\u56E0\u3002`
-    );
+    throw new Error(t4("mcp_oauth.store_encrypted_no_key", { path: this.filePath }));
   }
   save(file) {
     this.assertWritable();
@@ -443,7 +381,11 @@ var McpAuthStore = class {
     } catch (err) {
       rmSync(tmp, { force: true });
       throw new Error(
-        `MCP \u51ED\u636E ${this.filePath} \u5199\u5165\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`
+        t4("mcp_oauth.store_write_failed", {
+          label: t4("mcp_oauth.store_label"),
+          path: this.filePath,
+          reason: err instanceof Error ? err.message : String(err)
+        })
       );
     }
     this.cache = file;
@@ -456,7 +398,7 @@ function encrypt(json) {
 function decrypt(raw) {
   if (!isEnvelope(raw)) return raw;
   const key = getDataKey();
-  if (!key) throw new Error("mcp-auth.json \u662F\u5BC6\u6587\uFF0C\u4F46\u5F53\u524D\u6CA1\u6709\u53EF\u7528\u7684\u6570\u636E\u5BC6\u94A5");
+  if (!key) throw new Error(t4("mcp_oauth.store_read_no_key"));
   return openEnvelope(key, raw);
 }
 function isExpired(entry, now = Date.now()) {
@@ -483,15 +425,15 @@ function normalize(parsed) {
   }
   return { version: FILE_VERSION, servers: out };
 }
-
 // src/transport/index.ts
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import {
-  collectProcessTree,
+  collectProcessTreeStamped,
   createStreamDecoder,
-  killPids
+  killStampedPids,
+  t as t5
 } from "@epoch-agent/infra";
 function createStdioTransport(config, onStderr) {
   const transport = new StdioClientTransport({
@@ -516,7 +458,7 @@ function createHttpTransport(config, authProvider) {
   try {
     parsedUrl = new URL(config.url ?? "");
   } catch {
-    throw new Error(`\u65E0\u6548\u7684 MCP URL: ${config.url}`);
+    throw new Error(t5("mcp_config_parse.invalid_mcp_url", { url: config.url ?? "" }));
   }
   const requestInit = config.headers ? { headers: config.headers } : void 0;
   const opts = { requestInit, authProvider };
@@ -529,14 +471,13 @@ function stdioChildPid(transport) {
 }
 async function closeTransportAndReap(transport) {
   const pid = stdioChildPid(transport);
-  const orphans = pid === null ? [] : await collectProcessTree(pid);
+  const orphans = pid === null ? [] : await collectProcessTreeStamped(pid);
   try {
     await transport.close();
   } catch {
   }
-  if (orphans.length > 0) await killPids(orphans, { escalate: true });
+  if (orphans.length > 0) await killStampedPids(orphans, { escalate: true });
 }
-
 // src/types.ts
 var DEFAULTS = {
   timeout: 300,
@@ -547,7 +488,6 @@ var DEFAULTS = {
   supportsParallel: false,
   skipPreflight: false
 };
-
 // src/client.ts
 var MAX_RECONNECT = 3;
 var RECONNECT_BACKOFF = [1e3, 2e3, 4e3];
@@ -564,31 +504,13 @@ var McpClient = class {
   lastError = null;
   toolCount = 0;
   stderrTail = [];
-  /** 上一个 chunk 末尾那截还没等到换行的文本，见 {@link collectStderr} */
   stderrPartial = "";
-  /** 主动 disconnect 时置位，避免自己触发的 onclose 又去排一次重连 */
   closingIntentionally = false;
-  /** 认证过不去。重连解决不了这个问题，只有 `epoch mcp login` 能 */
   needsLogin = false;
   cache;
   fingerprint;
   authProvider;
-  /**
-   * 收到 `notifications/tools/list_changed` 时的回调。
-   *
-   * McpRegistry 用它把「工具表已经不是启动时那份了」冒泡给宿主。
-   * 注意**这不是热更新**：AgentLoop 的工具集是构造参数，本进程内换不掉。
-   * 详见 registry 的 `refresh()`。
-   */
   onToolsChanged;
-  /**
-   * 这台是谁带进来的（方案 44 PR-2）。
-   *
-   * **由 `McpRegistry.connectAll()` 那一侧说了算，不从 `config` 里读** ——
-   * `McpServerConfig` 是用户手写的 `mcp.json` 解析出来的形状，来源要是它的一个
-   * 字段，用户就能在自己的文件里写 `"source": "host"` 给自己那台贴上宿主的标。
-   * 判据同角色那条「命名空间由装配层拼，宿主自己写的不算数」。
-   */
   source;
   constructor(config, cache, authStore, source = "user") {
     this.config = { ...DEFAULTS, ...config };
@@ -608,7 +530,6 @@ var McpClient = class {
       source: this.source
     };
   }
-  /** 底层 SDK client，`null` 表示没连上。resources / prompts 那几个原语要用 */
   get raw() {
     return this.client;
   }
@@ -622,12 +543,6 @@ var McpClient = class {
       this.startLifetime();
     }
   }
-  /**
-   * 取本 server 的工具 schema —— 缓存优先。
-   *
-   * 三级：内存缓存 → live `tools/list` → 上次落盘的 schema（降级）。
-   * 详见 [cache.ts](./cache.ts) 里两层分工的说明。
-   */
   async getToolSchemas() {
     const name = this.config.name;
     const cached = this.cache.getFresh(name, this.fingerprint);
@@ -649,7 +564,6 @@ var McpClient = class {
     }
     return [];
   }
-  /** live 拉取；失败返回 null（错误记进 lastError，由调用方决定降不降级） */
   async fetchToolSchemas() {
     if (!this.client) return null;
     this.resetIdle();
@@ -658,8 +572,8 @@ var McpClient = class {
         this.client.listTools(),
         (this.config.timeout ?? DEFAULTS.timeout) * 1e3
       );
-      return (result.tools ?? []).map((t) => {
-        const tool = t;
+      return (result.tools ?? []).map((t10) => {
+        const tool = t10;
         return {
           name: tool.name,
           description: tool.description,
@@ -673,13 +587,6 @@ var McpClient = class {
       return null;
     }
   }
-  /**
-   * 调用工具。
-   *
-   * **断线不在这里等重连**：以前这里 `await this.reconnect()`，而 reconnect 是
-   * 1s + 2s + 4s 的 backoff 循环 —— 工具执行路径上最多阻塞 7 秒，用户看到的是
-   * agent 卡住。现在改成排一次后台重连、立刻返回一条可重试的错误。
-   */
   async callTool(name, args) {
     if (!this.client) {
       this.scheduleReconnect();
@@ -717,17 +624,6 @@ var McpClient = class {
     this.client = null;
     this.closingIntentionally = false;
   }
-  // ---- 内部 ----
-  /**
-   * 建连。**握手成功之前不写 this.client**。
-   *
-   * 以前是先 `this.client = new Client(...)` 再 await 握手，于是
-   * `status.connected`（判据就是 `client !== null`）在握手还没跑完时就报 true ——
-   * 调用方据此以为能用了，实际 SDK 会抛 "Not connected"。
-   *
-   * 失败路径也补上了 `transport.close()`：以前 connect 超时只是把字段置 null，
-   * stdio 已经起来的子进程没人收，直接漏成孤儿进程。
-   */
   async connectInner() {
     const transport = this.config.transport === "stdio" || !this.config.url ? createStdioTransport(this.config, (text) => this.collectStderr(text)) : createHttpTransport(this.config, this.authProvider);
     const client = new Client({ name: "epoch-agent", version: "0.0.0" }, { capabilities: {} });
@@ -759,18 +655,6 @@ var McpClient = class {
     this.lastError = null;
     this.needsLogin = false;
   }
-  /**
-   * 攒起 stderr 的尾部若干**行**。
-   *
-   * ⚠️ **`text` 是一个 chunk，不是一行。** 一行长过一个 chunk（管道一次 64 KB）
-   * 时它会被切开，而不留半截的话每一截都变成尾部里独立的一条 —— 既占掉好几个
-   * 名额，`stderrHint()` 拼出来还像是好几件事（`……前半 | 后半`）。
-   * 一个把栈打进 stderr 的 server 很容易做到这一点。
-   *
-   * ⚠️ 别把 `cmd.exe` 那句「不是内部或外部命令」的两行当成这个 bug 的例子 ——
-   * 实测过，**那句话本身就是两行**（「……可运行的程序」后面真有一个 `\r\n`），
-   * 拼出来带 `|` 是忠实的。
-   */
   collectStderr(text) {
     const parts = (this.stderrPartial + text).split("\n");
     this.stderrPartial = parts.pop() ?? "";
@@ -782,32 +666,15 @@ var McpClient = class {
       this.stderrTail = this.stderrTail.slice(-STDERR_TAIL_LINES);
     }
   }
-  /**
-   * 最后三行，给错误消息当尾巴。
-   *
-   * 把还没等到换行的那半行也算进来：server 崩在半句话上时，那半句往往正是
-   * 最要紧的一句（而它永远等不到自己的 `\n`）。
-   */
   stderrHint() {
     const partial = this.stderrPartial.trim();
     const lines = partial.length > 0 ? [...this.stderrTail, partial] : this.stderrTail;
     return lines.slice(-3).join(" | ");
   }
-  /**
-   * server 说工具表变了。
-   *
-   * 只做两件事：**失效 schema 缓存**（下次 `getToolSchemas()` 会真去拉一次），
-   * 然后把事件冒泡出去。刻意不在这里自己去 `listTools()` —— 通知可能连着来，
-   * 每条都拉一次是在替 server 打自己。
-   */
   onToolsListChanged() {
     this.cache.invalidate(this.config.name);
     this.onToolsChanged?.();
   }
-  /**
-   * @param closed 触发 onclose 的那个 Client。重连成功后旧连接的迟到通知
-   *               不能把新连接连坐掉，所以要比对身份。
-   */
   onTransportClosed(closed) {
     if (this.closingIntentionally) return;
     if (this.client !== null && this.client !== closed) return;
@@ -817,12 +684,6 @@ var McpClient = class {
     this.lastError = `\u8FDE\u63A5\u5DF2\u65AD\u5F00${this.stderrTail.length > 0 ? `\uFF1Bstderr: ${this.stderrHint()}` : ""}`;
     this.scheduleReconnect();
   }
-  /**
-   * 排一次后台重连（幂等）。
-   *
-   * 看门狗语义：重连全程不占用调用方的时间片，失败就按 backoff 再排一次，
-   * 到 MAX_RECONNECT 为止把 server 标成不可用。
-   */
   scheduleReconnect() {
     if (this.reconnectTimer || this.client) return;
     if (this.needsLogin) return;
@@ -886,13 +747,6 @@ var McpClient = class {
       this.keepaliveTimer = null;
     }
   }
-  /**
-   * 起 idle / max-lifetime 两个自动断连定时器。
-   *
-   * 这里刻意**不**调 `clearTimers()`：它连 keepalive 一起清，而调用顺序是
-   * `startKeepalive(); startLifetime();` —— 等于刚起的 keepalive 立刻被自己清掉，
-   * keepalive 从来没真正跑过。只清自己的两个定时器。
-   */
   startLifetime() {
     if (this.idleTimer) clearTimeout(this.idleTimer);
     if (this.lifetimeTimer) clearTimeout(this.lifetimeTimer);
@@ -938,9 +792,9 @@ var McpClient = class {
     }
   }
 };
-
 // src/oauth/callback.ts
 import { createServer } from "http";
+import { t as t6 } from "@epoch-agent/infra";
 var CALLBACK_TIMEOUT_MS = 5 * 60 * 1e3;
 var CALLBACK_PATH = "/callback";
 async function startCallbackServer(port, timeoutMs = CALLBACK_TIMEOUT_MS) {
@@ -977,7 +831,7 @@ async function startCallbackServer(port, timeoutMs = CALLBACK_TIMEOUT_MS) {
           setTimeout(close, 100).unref?.();
           if (result.error) reject(result.error);
           else if (result.code) resolve(result.code);
-          else reject(new Error("OAuth \u56DE\u8C03\u91CC\u6CA1\u6709\u6388\u6743\u7801"));
+          else reject(new Error(t6("mcp_oauth.err_no_code")));
         };
         if (pending) {
           settle(pending);
@@ -985,7 +839,7 @@ async function startCallbackServer(port, timeoutMs = CALLBACK_TIMEOUT_MS) {
         }
         const timer = setTimeout(() => {
           close();
-          reject(new Error(`\u7B49\u5F85 OAuth \u56DE\u8C03\u8D85\u65F6\uFF08${timeoutMs / 1e3}s\uFF09\uFF0C\u767B\u5F55\u672A\u5B8C\u6210`));
+          reject(new Error(t6("mcp_oauth.err_timeout", { seconds: timeoutMs / 1e3 })));
         }, timeoutMs);
         timer.unref?.();
         onResult = (result) => {
@@ -1003,32 +857,37 @@ async function startCallbackServer(port, timeoutMs = CALLBACK_TIMEOUT_MS) {
       return;
     }
     if (!armed) {
-      respond(res, 400, "\u6388\u6743\u5931\u8D25", "\u672C\u6B21\u767B\u5F55\u5C1A\u672A\u5F00\u59CB\uFF0C\u8FD9\u4E2A\u56DE\u8C03\u4E0D\u5C5E\u4E8E\u4EFB\u4F55\u6D41\u7A0B");
+      respond(res, 400, t6("mcp_oauth.page_failed"), t6("mcp_oauth.page_not_started"));
       return;
     }
     const params = url.searchParams;
     const oauthError = params.get("error");
     if (oauthError) {
       const detail = params.get("error_description");
-      respond(res, 400, "\u6388\u6743\u5931\u8D25", detail ?? oauthError);
+      respond(res, 400, t6("mcp_oauth.page_failed"), detail ?? oauthError);
       emit2({
-        error: new Error(`\u6388\u6743\u670D\u52A1\u5668\u8FD4\u56DE ${oauthError}${detail ? `\uFF1A${detail}` : ""}`)
+        error: new Error(
+          t6("mcp_oauth.err_server_returned", {
+            error: oauthError,
+            detail: detail ? t6("mcp_oauth.err_server_returned_detail", { detail }) : ""
+          })
+        )
       });
       return;
     }
     const state = params.get("state");
     if (expectedState !== void 0 && state !== expectedState) {
-      respond(res, 400, "\u6388\u6743\u5931\u8D25", "state \u4E0D\u5339\u914D\uFF0C\u8FD9\u6B21\u56DE\u8C03\u5DF2\u88AB\u62D2\u7EDD");
-      emit2({ error: new Error("OAuth \u56DE\u8C03\u7684 state \u4E0D\u5339\u914D\uFF08\u53EF\u80FD\u662F CSRF\uFF09\uFF0C\u5DF2\u62D2\u7EDD") });
+      respond(res, 400, t6("mcp_oauth.page_failed"), t6("mcp_oauth.page_state_mismatch"));
+      emit2({ error: new Error(t6("mcp_oauth.err_state_mismatch")) });
       return;
     }
     const code = params.get("code");
     if (!code) {
-      respond(res, 400, "\u6388\u6743\u5931\u8D25", "\u56DE\u8C03\u91CC\u6CA1\u6709 code");
-      emit2({ error: new Error("OAuth \u56DE\u8C03\u91CC\u6CA1\u6709\u6388\u6743\u7801") });
+      respond(res, 400, t6("mcp_oauth.page_failed"), t6("mcp_oauth.page_no_code"));
+      emit2({ error: new Error(t6("mcp_oauth.err_no_code")) });
       return;
     }
-    respond(res, 200, "\u6388\u6743\u6210\u529F", "\u53EF\u4EE5\u5173\u6389\u8FD9\u4E2A\u9875\u9762\u56DE\u5230\u7EC8\u7AEF\u4E86\u3002");
+    respond(res, 200, t6("mcp_oauth.page_ok"), t6("mcp_oauth.page_ok_detail"));
     emit2({ code });
   }
 }
@@ -1038,7 +897,7 @@ function listen(server, port) {
     server.listen(port ?? 0, "127.0.0.1", () => {
       const address = server.address();
       if (!address) {
-        reject(new Error("\u56DE\u8C03\u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25\uFF1A\u62FF\u4E0D\u5230\u7AEF\u53E3"));
+        reject(new Error(t6("mcp_oauth.err_no_port")));
         return;
       }
       server.removeListener("error", reject);
@@ -1047,7 +906,7 @@ function listen(server, port) {
   });
 }
 function respond(res, status, title, detail) {
-  const body = `<!doctype html><html lang="zh"><head><meta charset="utf-8">
+  const body = `<!doctype html><html lang="${t6("mcp_oauth.html_lang")}"><head><meta charset="utf-8">
 <title>${title}</title></head>
 <body style="font-family:system-ui;max-width:32rem;margin:6rem auto;text-align:center">
 <h1>${title}</h1><p>${escapeHtml(detail)}</p><p style="color:#888">epoch-agent</p>
@@ -1060,10 +919,10 @@ function escapeHtml(text) {
     (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c] ?? c
   );
 }
-
 // src/oauth/login.ts
 import { spawn } from "child_process";
 import { auth } from "@modelcontextprotocol/sdk/client/auth.js";
+import { t as t7 } from "@epoch-agent/infra";
 async function loginToMcpServer(opts) {
   const store = opts.store ?? new McpAuthStore();
   const print = opts.print ?? (() => {
@@ -1080,8 +939,8 @@ async function loginToMcpServer(opts) {
     onRedirect: async (url) => {
       redirected = true;
       callback.expect(provider.expectedState);
-      print(`\u5728\u6D4F\u89C8\u5668\u91CC\u5B8C\u6210\u6388\u6743\uFF1A
-  ${url.toString()}`);
+      print(t7("mcp_oauth.open_browser", { url: `
+  ${url.toString()}` }));
       await openBrowser(url.toString());
     }
   });
@@ -1099,7 +958,7 @@ async function loginToMcpServer(opts) {
       scope: opts.scope
     });
     if (second !== "AUTHORIZED") {
-      throw new Error(`\u6388\u6743\u672A\u5B8C\u6210\uFF08SDK \u8FD4\u56DE ${second}\uFF09`);
+      throw new Error(t7("mcp_oauth.incomplete", { result: second }));
     }
     return { server: opts.server, refreshedOnly: false };
   } finally {
@@ -1169,7 +1028,6 @@ async function openInBrowser(url) {
   } catch {
   }
 }
-
 // src/primitives.ts
 var METHOD_NOT_FOUND = -32601;
 var MAX_PAGES = 50;
@@ -1229,11 +1087,9 @@ async function paginate(fetchPage) {
 function isMethodNotFound(err) {
   return err?.code === METHOD_NOT_FOUND;
 }
-
 // src/registry.ts
 import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
-import { mcpConfigPath, mcpSchemaCachePath } from "@epoch-agent/infra";
-
+import { mcpConfigPath, mcpSchemaCachePath, t as t9 } from "@epoch-agent/infra";
 // src/tool-adapter.ts
 function prefixedName(serverName, toolName) {
   return `mcp__${serverName}__${toolName}`;
@@ -1261,7 +1117,6 @@ function toEpochTool(serverName, schema, call) {
       return {
         success: result.success,
         output: result.output,
-        // 原样往上交，不在这里判「模型认不认图」—— 那是 ToolExecutor 的四道闸门
         ...result.artifacts && result.artifacts.length > 0 ? { artifacts: result.artifacts } : {},
         duration: Math.round(performance.now() - startedAt)
       };
@@ -1275,7 +1130,6 @@ function stripTitle(annotations) {
   const given = Object.entries(hints).filter(([, v]) => v !== void 0);
   return given.length > 0 ? Object.fromEntries(given) : void 0;
 }
-
 // src/resource-tools.ts
 var MAX_LISTED = 200;
 function createResourceTools(serverName, getClient) {
@@ -1286,9 +1140,6 @@ function createResourceTools(serverName, getClient) {
       name: prefixedName(serverName, "list_resources"),
       description: `\u5217\u51FA MCP server\u300C${serverName}\u300D\u63D0\u4F9B\u7684\u6240\u6709\u8D44\u6E90\uFF08URI + \u8BF4\u660E\uFF09\u3002\u60F3\u8BFB\u67D0\u4E2A\u8D44\u6E90\u7684\u5185\u5BB9\uFF0C\u518D\u8C03 ${prefixedName(serverName, "read_resource")}\u3002`,
       parameters: { type: "object", properties: {} },
-      // 这两个 hint 是**我们自己**的声明，不是 server 给的：按 MCP 规范
-      // resources/list 与 resources/read 都是只读操作。server 声明的 annotations
-      // 走 tool-adapter.ts，两条路不会混
       annotations: { readOnlyHint: true, openWorldHint: true },
       execute: async () => {
         return run(async () => {
@@ -1348,10 +1199,9 @@ async function run(fn) {
     };
   }
 }
-
 // src/schema.ts
 import { z } from "zod";
-import { parseLenient } from "@epoch-agent/infra";
+import { parseLenient, t as t8 } from "@epoch-agent/infra";
 var seconds = z.number().positive().finite();
 var OAuthSchema = z.object({
   enabled: z.boolean().optional(),
@@ -1360,16 +1210,6 @@ var OAuthSchema = z.object({
 });
 var RawServerSchema = z.object({
   transport: z.enum(["stdio", "sse", "http"]).optional(),
-  /**
-   * `transport` 的别名。**MCP 生态里的通用写法是 `type`**（Claude Desktop /
-   * Cursor 等客户端的 mcp.json 都是它），我们自己的名字是 `transport`。
-   *
-   * 不收它的代价不是「多一条警告」而是**静默选错传输**：`type` 落进未知字段被丢掉，
-   * 下面那行 `raw.url ? 'sse' : 'stdio'` 于是把一个 `{"type":"http","url":…}` 的
-   * Streamable HTTP server 连成 SSE。这正是本文件下面那句注释说已经堵掉的坑
-   * （「写 `transport: 'http'` 的用户会静默走到 SSE 上去」），当时只堵了我们自己
-   * 这个字段名的那一半。2026-08-12 拿真实配置试出来的。
-   */
   type: z.enum(["stdio", "sse", "http"]).optional(),
   command: z.string().min(1).optional(),
   args: z.array(z.string()).optional(),
@@ -1403,7 +1243,10 @@ function parseMcpConfig(raw, label) {
     json = JSON.parse(raw);
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
-    return { servers: [], issues: [{ path: label, message: `JSON \u8BED\u6CD5\u9519\u8BEF\uFF1A${detail}` }] };
+    return {
+      servers: [],
+      issues: [{ path: label, message: t8("mcp_config_parse.json_error", { reason: detail }) }]
+    };
   }
   const issues = [];
   const top = parseLenient(RawConfigSchema, json, {});
@@ -1413,10 +1256,10 @@ function parseMcpConfig(raw, label) {
     if (top.value.mcpServers) {
       issues.push({
         path: label,
-        message: "\u68C0\u6D4B\u5230 `mcpServers` \u5B57\u6BB5\uFF1Bepoch \u8BFB\u7684\u662F `servers`\uFF0C\u8BF7\u6539\u952E\u540D"
+        message: t8("mcp_config_parse.wrong_key")
       });
     } else if (issues.length === 0) {
-      issues.push({ path: label, message: "\u7F3A\u5C11 `servers` \u5B57\u6BB5\uFF0C\u6CA1\u6709\u53EF\u7528\u7684 MCP server" });
+      issues.push({ path: label, message: t8("mcp_config_parse.no_servers") });
     }
     return { servers: [], issues };
   }
@@ -1426,7 +1269,7 @@ function parseMcpConfig(raw, label) {
     const parsed = parseLenient(RawServerSchema.nullable(), value, null);
     if (!parsed.value) {
       issues.push(...prefix(parsed.issues, at));
-      issues.push({ path: at, message: "\u914D\u7F6E\u65E0\u6548\uFF0C\u8BE5 server \u5DF2\u8DF3\u8FC7" });
+      issues.push({ path: at, message: t8("mcp_config_parse.invalid_server") });
       continue;
     }
     issues.push(...unknownKeyIssues(value, at));
@@ -1440,13 +1283,19 @@ function normalize2(name, raw, at) {
   const issues = [];
   const transport = raw.transport ?? raw.type ?? (raw.url ? "sse" : "stdio");
   if (transport === "stdio" && !raw.command) {
-    issues.push({ path: `${at}.command`, message: "stdio \u4F20\u8F93\u7F3A\u5C11 command\uFF0C\u8BE5 server \u5DF2\u8DF3\u8FC7" });
+    issues.push({ path: `${at}.command`, message: t8("mcp_config_parse.stdio_no_command") });
   }
   if (transport !== "stdio") {
     if (!raw.url) {
-      issues.push({ path: `${at}.url`, message: `${transport} \u4F20\u8F93\u7F3A\u5C11 url\uFF0C\u8BE5 server \u5DF2\u8DF3\u8FC7` });
+      issues.push({
+        path: `${at}.url`,
+        message: t8("mcp_config_parse.no_url", { transport })
+      });
     } else if (!isValidUrl(raw.url)) {
-      issues.push({ path: `${at}.url`, message: `\u4E0D\u662F\u5408\u6CD5\u7684 URL\uFF1A${raw.url}\uFF0C\u8BE5 server \u5DF2\u8DF3\u8FC7` });
+      issues.push({
+        path: `${at}.url`,
+        message: t8("mcp_config_parse.bad_url", { url: raw.url })
+      });
     }
   }
   if (issues.length > 0) return { config: null, issues };
@@ -1475,7 +1324,7 @@ function normalize2(name, raw, at) {
 }
 function unknownKeyIssues(value, at) {
   if (typeof value !== "object" || value === null) return [];
-  return Object.keys(value).filter((k) => !KNOWN_KEYS.has(k)).map((k) => ({ path: `${at}.${k}`, message: "\u672A\u77E5\u5B57\u6BB5\uFF0C\u5DF2\u5FFD\u7565\uFF08\u62FC\u5199\u9519\u4E86\uFF1F\uFF09" }));
+  return Object.keys(value).filter((k) => !KNOWN_KEYS.has(k)).map((k) => ({ path: `${at}.${k}`, message: t8("mcp_config_parse.unknown_field") }));
 }
 function isValidUrl(url) {
   try {
@@ -1491,34 +1340,17 @@ function prefix(issues, at) {
     message: i.message
   }));
 }
-
 // src/registry.ts
 var McpRegistry = class {
   clients = /* @__PURE__ */ new Map();
   cache;
   authStore;
-  /**
-   * 某个 server 的工具表变了（收到 `notifications/tools/list_changed`）。
-   *
-   * registry 这层只负责把缓存失效掉并转发这个信号 —— **真正的热更新做不到**：
-   * `AgentLoop` 的工具集是构造参数，一次性传进去的，没有「运行中换一套工具」
-   * 的入口。要做需要先给 loop 引入 `ToolProvider` 接口，那是另一个方案的事，
-   * 本方案明确不碰 loop.ts。当前的效果是：下一次 `getAllTools()` / `refresh()`
-   * 能拿到新工具表，正在跑的那一轮不受影响。
-   */
   onToolsChanged;
   constructor(options = {}) {
     const cacheFile = options.cacheFile !== void 0 ? options.cacheFile : mcpSchemaCachePath(options.homeDir);
     this.cache = new McpSchemaCache(cacheFile);
     this.authStore = options.authStore ?? new McpAuthStore(void 0, options.homeDir);
   }
-  /**
-   * 从配置文件加载所有 MCP servers。
-   *
-   * 返回值带 `issues`：以前是 `catch { return [] }`，mcp.json 写错一个字符
-   * 用户只会发现「MCP 没了」，看不到任何提示。调用方**必须**把 issues
-   * 写进 diagnostics（见 runtime/tools.ts）。
-   */
   loadFromConfig(configPath) {
     const path = configPath ?? mcpConfigPath();
     if (!existsSync2(path)) return { servers: [], issues: [] };
@@ -1527,24 +1359,13 @@ var McpRegistry = class {
       raw = readFileSync3(path, "utf-8");
     } catch (err) {
       const detail = err instanceof Error ? err.message : String(err);
-      return { servers: [], issues: [{ path, message: `\u8BFB\u53D6\u5931\u8D25\uFF1A${detail}` }] };
+      return {
+        servers: [],
+        issues: [{ path, message: t9("mcp_config_parse.read_failed", { reason: detail }) }]
+      };
     }
     return parseMcpConfig(raw, path);
   }
-  /**
-   * 连接所有已配置的 servers。
-   *
-   * @param source 这一批是谁带进来的（方案 44 PR-2）。**由调用方说了算，不从
-   *   `configs` 里读** —— 判据在 `McpClient.source` 上：`McpServerConfig` 是
-   *   用户手写文件解析出来的形状，来源要是它的一个字段，用户就能给自己那台
-   *   贴上宿主的标。缺省 `'user'`，于是老调用点（`epoch mcp` 那几条、用例）
-   *   一个字都不用改
-   *
-   * ⚠️ **可以调多次（两批 server 各一发），但名字必须在批与批之间唯一** ——
-   * `clients` 是一张按名字索引的表，重名的后一发会把前一发整个顶掉，而这里
-   * 拿不到诊断口说不出这件事。去重归调用方，`runtime/src/tools.ts` 的
-   * `registerMcpTools` 就是这么做的（用户那批先到、宿主重名的那台被跳过并报一条）。
-   */
   async connectAll(configs, source = "user") {
     const promises = configs.map(async (cfg) => {
       await this.clients.get(cfg.name)?.disconnect();
@@ -1560,12 +1381,6 @@ var McpRegistry = class {
     });
     return Promise.all(promises);
   }
-  /**
-   * 获取所有 MCP 工具（扁平化）。
-   *
-   * schema 走缓存，第二次调用不再打网络；工具本身每次重建
-   * （execute 闭包要绑到当前的 client 实例上，重连后不能还指向旧连接）。
-   */
   async getAllTools() {
     const allTools = [];
     for (const [name, client] of this.clients) {
@@ -1575,43 +1390,25 @@ var McpRegistry = class {
     }
     return allTools;
   }
-  /**
-   * 丢掉 schema 缓存后重新取一遍工具表。
-   *
-   * 给 `onToolsChanged` 的消费方用：收到通知 → `refresh()` → 拿到新工具表。
-   * 不传 name 就刷所有 server。
-   */
   async refresh(name) {
     this.cache.invalidate(name);
     return this.getAllTools();
   }
-  /**
-   * 列出某个 server 的 prompts。
-   *
-   * **prompts 不包成工具**，与 resources 的处理刻意不同：MCP 规范把 prompts
-   * 定义成 user-controlled（用户主动挑一个模板来用），tools 才是 model-controlled。
-   * gemini 也是这么分的 —— 它把 prompts 注册成斜杠命令（`PromptRegistry`），
-   * 不给模型。所以这里只提供查询 API，暴露方式交给 CLI/TUI。
-   */
   async listPrompts(name) {
     const client = this.requireClient(name);
     return client.raw ? listPrompts(client.raw) : [];
   }
-  /** 取一个 prompt 渲染后的文本 */
   async getPrompt(name, promptName, args = {}) {
     const client = this.requireClient(name);
     if (!client.raw) throw new Error(`MCP server "${name}" \u5F53\u524D\u672A\u8FDE\u63A5`);
     return getPromptText(client.raw, promptName, args);
   }
-  /** 各 server 的登录态。纯读本地凭据文件，不打网络 */
   getAuthStatus() {
     return [...this.clients.values()].map((c) => mcpAuthStatus(c.serverConfig, this.authStore));
   }
-  /** 凭据存储。`epoch mcp login/logout` 要用同一份，否则缓存不一致 */
   get auth() {
     return this.authStore;
   }
-  /** 重连指定 server。工具表可能已变，顺带失效它的 schema 缓存 */
   async reconnect(name) {
     const client = this.requireClient(name);
     this.cache.invalidate(name);
@@ -1619,32 +1416,9 @@ var McpRegistry = class {
     await client.connect();
     return client.status;
   }
-  /**
-   * 显式失效 schema 缓存，不传 name 清全部。
-   *
-   * 给 `epoch mcp reconnect` 和将来的 `notifications/tools/list_changed` 用。
-   */
   invalidateSchemaCache(name) {
     this.cache.invalidate(name);
   }
-  /**
-   * 断开**一台**并把它从表里删掉。返回 false 表示本来就没有这一台。
-   *
-   * ## 为什么在 `disconnectAll()` 之外单开这一个（2026-08-18）
-   *
-   * 在这之前，「让一台 server 在这个进程里消失」**做不到** —— 只能把所有连接一起
-   * 断掉。而 `mcp.json` 的一次编辑真的会删掉一台（runtime 的 `applyMcpConfig`），
-   * 那时全断再全连是错的：宿主注入的和插件带来的那两批也会被连带断开，而它们
-   * 一个字节都不在这份文件里。
-   *
-   * ⚠️ **它连带失效 schema 缓存**：那台下次要是又被配回来，缓存里躺着的是上一份
-   * 工具表。同 `reconnect()` 里那一下，理由逐字相同。
-   *
-   * ⚠️ **工具表不在这一层清**。这里只管连接；把 `mcp:<名字>` 那一组工具从
-   * `ToolRegistry` 里摘掉是装配层的事（`ToolSync.replace`，判据在 runtime 的
-   * `ToolSync` 上：三条路必须排同一条队）。少了那一下的表现是**工具表里留着一批
-   * 指向已断连接的工具**，模型下一轮照着调，报一个它读不懂的错。
-   */
   async disconnect(name) {
     const client = this.clients.get(name);
     if (!client) return false;
@@ -1653,24 +1427,15 @@ var McpRegistry = class {
     this.clients.delete(name);
     return true;
   }
-  /**
-   * 这台 server 在**这个进程里此刻按的是哪份配置**（2026-08-18）。
-   *
-   * 给「盘上那份和进程里这份差在哪」用（runtime 的 `applyMcpConfig` 拿它做 diff）。
-   * ⚠️ 真源必须是 client 手上那一份，**不能是调用方自己记的一份快照**：那份快照
-   * 会和这里分叉，而分叉的表现是「明明改了配置，应用之后说没动」。
-   */
   configOf(name) {
     return this.clients.get(name)?.serverConfig ?? null;
   }
-  /** 断开所有连接 */
   async disconnectAll() {
     for (const client of this.clients.values()) {
       await client.disconnect();
     }
     this.clients.clear();
   }
-  /** 获取状态 */
   getStatus(name) {
     return this.clients.get(name)?.status ?? null;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epoch-agent/plugin-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "description": "epoch-agent MCP 客户端插件",
   "repository": {
@@ -23,8 +23,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
     "zod": "^4.4.3",
-    "@epoch-agent/protocol": "0.1.0",
-    "@epoch-agent/infra": "0.1.0"
+    "@epoch-agent/infra": "0.2.0",
+    "@epoch-agent/protocol": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",