dsh-gpt-adapter 0.2.2 → 0.2.3

package/README.md

@@ -22,9 +22,19 @@ Reasoning and speed presets are requests to the configured gateway, not guarante
 
 ## Compatibility and installation
 
-The native integration targets DSH `0.2.2-rc.1`, Cordis `4.1.0`, and the pinned adapter source hash. The development dependency uses Pi AI `1.3.0`. Installed third-party package files are never edited. The package has not been published to npm.
+The native integration targets DSH `0.2.2-rc.1`, Cordis `4.1.0`, and the pinned adapter source hash. The development dependency uses Pi AI `1.3.0`. Installed third-party package files are never edited. The published npm package is `dsh-gpt-adapter@0.2.3`.
 
-Requires Node.js `>=24.9.0` and pnpm.
+Requires Node.js `>=24.9.0` and DSH. Source builds also require pnpm.
+
+Install the published package in the web profile:
+
+```sh
+dsh plugin --profile web add dsh-gpt-adapter@0.2.3
+```
+
+Restart the DSH host after installing or upgrading. Configure GPT connections under **Settings → Models**; Codex environment reuse is enabled by default. The plugin extends the existing native settings and conversation controls.
+
+To install from source for development or verification:
 
 ```sh
 git clone https://github.com/lxjmaster/dsh-gpt-adapter.git
@@ -32,17 +42,16 @@ cd dsh-gpt-adapter
 pnpm install --frozen-lockfile
 mkdir -p artifacts
 pnpm pack --pack-destination artifacts
-dsh plugin --profile web add ./artifacts/dsh-gpt-adapter-0.2.2.tgz
+dsh plugin --profile web add ./artifacts/dsh-gpt-adapter-0.2.3.tgz
 ```
 
-`pnpm pack` runs the production build. Restart the DSH host after upgrading the installed package.
+`pnpm pack` runs the production build.
 
 ## Automated releases
 
 The `Release` workflow runs on pushes to `main` and manual dispatches. For a formal `X.Y.Z` version, it runs the test suite, creates `vX.Y.Z`, creates the matching GitHub Release, and publishes the package to npm. Prerelease versions are skipped, and existing tags or npm versions are reused safely.
 
-Add an npm access token as the repository secret `NPM_TOKEN` before the first release.
-Configure GPT connections as usual under **Settings → Models**. The plugin extends the existing native settings and conversation controls.
+Maintainers must provide the npm access token as the repository secret `NPM_TOKEN` for this workflow.
 
 ## Codex environment reuse
 
@@ -58,12 +67,14 @@ Codex compatibility is enabled by default. The root is the plugin's `codexHome`
 | Codex skills                   | Discover `skills/` and `skills/.system/`; bodies load on demand                                                                                   |
 | Shared/project skills          | Retain native discovery and include `.agents/skills` at every directory from cwd to repository root; nearer project skills take precedence        |
 | Skill enablement               | Honor ordered `skills.config` name/path selectors and `skills.bundled.enabled`                                                                    |
-| Enabled plugins                | Read declared skill roots and inline or file-referenced `mcpServers`; disabled plugins stay disabled                                              |
+| Enabled plugins                | Support portable root `plugin.json` / `mcp.json` and legacy declarations; disabled plugins stay disabled                                          |
 
 The compatibility layer reads project instructions through DSH's filesystem, selects candidates using Codex precedence, and replaces native messages only for covered scopes. Additional nested instruction updates remain applicable. It does not import Codex's built-in system prompt. Configured fallback filenames such as `CLAUDE.md` are used only when supplied in Codex configuration. Instructions are recorded as ordinary user context with a bounded byte budget, including an explicit zero budget; they do not override system, developer, or direct user instructions. Existing conversation history is retained when the plugin is removed.
 
 Plugin resources are resolved from the configured local marketplace, or the newest locally cached version in the matching marketplace. Nothing is downloaded automatically. Plugin skills use `<plugin>-<skill>` names to fit DSH's skill-name format and avoid cross-plugin collisions. Original skill paths and relative resources remain intact.
 
+Portable Agent Plugins use fixed `skills/` and `mcp.json` components, regardless of legacy `skills` or `mcpServers` declarations. OpenAI settings come from the root manifest's `extensions.com.openai` object, including an empty object; only when absent does `.codex-plugin/plugin.json` supply the overlay. Plugin identity always comes from the root manifest.
+
 ## MCP compatibility
 
 The plugin automatically starts enabled MCP commands and connects configured HTTP endpoints for each Agent session. It imports `mcp_servers` and the MCP resources declared by enabled plugins. Trusted project overrides apply within that Agent's scope; concurrent sessions do not share imported tool registrations. Untrusted project configuration is skipped.
@@ -77,6 +88,14 @@ Supported configuration includes:
 
 Global server names are retained where DSH permits them. Plugin servers use a plugin prefix. Unchanged connections are preserved. Changed or removed connections are disposed before replacement. Invalid configuration retains the last working snapshot, including individually invalid server entries. With automatic refresh enabled, failed startup retries with exponential backoff for up to ten attempts; a manual refresh resets that budget. The default two-second refresh detects configuration and plugin-resource changes; native skill watchers detect skill file changes.
 
+Plugin-scoped `plugins.<plugin>.mcp_servers.<server>` policies apply `enabled`, `enabled_tools`, `disabled_tools`, and per-tool disabling without overriding the plugin's executable, transport, or credentials. When plugin files are invalid, retained connections still receive current disabling and filtering restrictions; old restrictions are not relaxed until a valid declaration is available again.
+
+Stdio servers default to their Agent's project working directory and reconnect when that directory changes. An explicit `cwd` takes precedence. Without an explicit `cwd`, relative executable paths still resolve from the config or plugin root, independently of the process working directory. Plugin paths support `${PLUGIN_ROOT}`, `${CODEX_PLUGIN_ROOT}`, and `${CLAUDE_PLUGIN_ROOT}`.
+
+Imported MCP tools carry the current DSH session and turn in `tools/call` metadata under `_meta["x-codex-turn-metadata"]`. `session_id` is the Agent session ID; `turn_id` is `<session ID>:<turn/start event sequence>`. Calls in one turn share the same identity, new turns read a fresh boundary, and asynchronous sessions remain isolated. Diagnostic calls outside an active turn do not invent identities. These fields are transport metadata, never model-supplied tool arguments.
+
+The path is DSH Agent → imported tool execution context → MCP `tools/call` metadata → `node_repl` → browser service. This bridge addresses `Missing required Codex turn metadata: session_id, turn_id`; the browser extension, authentication, and App-specific services must still be available on the host. Unloading the plugin removes the bridge, and ordinary DSH MCP calls do not receive these fields.
+
 Credentials are not copied into DSH settings, plugin caches, or this repository. Status responses contain only resource names, states, and sanitized reason codes. Missing environment variables must exist in the DSH host environment to be inherited.
 
 This is environment compatibility, not a replacement Codex runtime. Codex OAuth/keychain sessions, Codex App IPC services, hooks, app components, permission policies, and proprietary commands are not automatically reproduced. Standard MCPs using configured headers/environment can be reused; servers requiring unavailable runtime authentication or services report a connection failure. Plugin hooks/apps/commands are reported as unsupported rather than executed. DSH retains its own approval and sandbox behavior.

package/README.zh-CN.md

@@ -22,9 +22,19 @@
 
 ## 兼容性与安装
 
-原生集成面向 DSH `0.2.2-rc.1`、Cordis `4.1.0`，并校验适配器源码指纹。开发依赖固定 Pi AI `1.3.0`。插件不会修改已安装的第三方包文件，目前未发布到 npm。
+原生集成面向 DSH `0.2.2-rc.1`、Cordis `4.1.0`，并校验适配器源码指纹。开发依赖固定 Pi AI `1.3.0`。插件不会修改已安装的第三方包文件。当前 npm 发布版本为 `dsh-gpt-adapter@0.2.3`。
 
-需要 Node.js `>=24.9.0` 和 pnpm。
+需要 Node.js `>=24.9.0` 和 DSH。源码构建另外需要 pnpm。
+
+在 `web` 配置档（profile）中安装已发布的 npm 包：
+
+```sh
+dsh plugin --profile web add dsh-gpt-adapter@0.2.3
+```
+
+安装或升级后重启 DSH 宿主。在「设置 → 模型」中配置 GPT 连接；Codex 环境复用默认开启。插件扩展现有原生设置与对话控件。
+
+如需从源码安装进行开发或验证：
 
 ```sh
 git clone https://github.com/lxjmaster/dsh-gpt-adapter.git
@@ -32,17 +42,16 @@ cd dsh-gpt-adapter
 pnpm install --frozen-lockfile
 mkdir -p artifacts
 pnpm pack --pack-destination artifacts
-dsh plugin --profile web add ./artifacts/dsh-gpt-adapter-0.2.2.tgz
+dsh plugin --profile web add ./artifacts/dsh-gpt-adapter-0.2.3.tgz
 ```
 
-`pnpm pack` 会自动执行生产构建。升级安装包后重启 DSH 宿主。
+`pnpm pack` 会自动执行生产构建。
 
 ## 自动发布
 
 `Release` 工作流会在推送到 `main` 或手动运行时执行。版本号为正式的 `X.Y.Z` 时，工作流会运行测试、创建 `vX.Y.Z` 标签、创建对应的 GitHub Release，并将包发布到 npm。预发布版本会跳过；已有标签或 npm 版本会安全复用。
 
-首次发布前，请在仓库 Secrets 中添加 npm 访问令牌 `NPM_TOKEN`。
-在「设置 → 模型」中照常配置 GPT 连接；插件扩展现有原生设置与对话控件。
+维护者需要在仓库 Secrets 中提供 npm 访问令牌 `NPM_TOKEN`，工作流才能发布。
 
 ## 复用 Codex 环境
 
@@ -58,12 +67,14 @@ dsh plugin --profile web add ./artifacts/dsh-gpt-adapter-0.2.2.tgz
 | Codex 技能         | 发现 `skills/` 和 `skills/.system/`，正文按需加载                                                   |
 | 共享与项目技能     | 保留原生发现机制，并补齐当前目录到仓库根每一级 `.agents/skills`；更近的项目技能优先                 |
 | 技能开关           | 遵循有序的 `skills.config` 名称/路径选择器，以及 `skills.bundled.enabled`                           |
-| 已启用插件         | 读取声明的技能目录和内联或文件引用形式的 `mcpServers`；禁用插件不加载                               |
+| 已启用插件         | 支持新版根目录 `plugin.json`、`mcp.json` 和旧版声明；禁用插件不加载                                 |
 
 兼容层通过 DSH 文件系统读取项目指令，按 Codex 优先级选择候选文件，只替换已覆盖作用域内的原生指令消息；额外发现的子目录指令更新仍然保留。它不会导入 Codex 内置系统提示词。`CLAUDE.md` 等后备文件仅在 Codex 配置明确声明时使用。指令以有字节预算的普通用户上下文写入会话，明确配置的零预算也会生效；指令不覆盖系统、开发者或用户直接指令。移除插件不会删除已有会话历史。
 
 插件资源优先来自已配置的本地市场目录，否则使用匹配市场中最新的本地缓存版本，不会自动下载。插件技能使用 `<插件名>-<技能名>`，以符合 DSH 命名格式并避免跨插件冲突。技能原始路径和相对资源引用保持不变。
 
+新版 Agent Plugins 使用固定的 `skills/` 与 `mcp.json`，不受旧版 `skills`、`mcpServers` 声明改写。OpenAI 扩展优先使用根清单的 `extensions.com.openai` 对象（包括空对象），缺省时才使用 `.codex-plugin/plugin.json`；插件名称仍取自根清单。
+
 ## MCP 兼容
 
 插件会为每个会话代理（Agent）自动启动已启用的 MCP 命令并连接已配置的 HTTP 端点。导入来源包括 `mcp_servers` 和已启用插件声明的 MCP 资源。受信任项目的覆盖配置只在该会话代理的作用域内生效，并行会话不会共用导入工具的注册；未受信任项目的配置会跳过。
@@ -77,6 +88,14 @@ dsh plugin --profile web add ./artifacts/dsh-gpt-adapter-0.2.2.tgz
 
 全局服务器名称在 DSH 允许时原样保留，插件服务器增加插件名前缀。未变化的连接继续复用；变更或删除的连接先卸载再替换。配置损坏时保留上一份有效快照，单个服务器配置无效时也会保留其可用连接。开启自动刷新时，启动失败会按指数退避间隔重试，最多尝试十次；手动刷新会重置次数。默认每两秒检查配置与插件资源变化，技能文件变化由原生监视器处理。
 
+插件级 `plugins.<插件>.mcp_servers.<服务器>` 的 `enabled`、`enabled_tools`、`disabled_tools` 和单工具禁用设置会覆盖声明中的策略，但不能改写插件的命令、传输或凭证。插件文件损坏时，保留的旧连接仍应用最新禁用和过滤限制；有效声明恢复前，不会放宽旧快照已有的限制。
+
+stdio 服务器默认从所属 Agent 的项目工作目录启动，切换项目时重建连接；显式 `cwd` 配置优先。未显式配置 `cwd` 时，相对可执行文件路径仍按配置或插件根目录解析，避免与运行目录混淆。插件根目录替换同时支持 `${PLUGIN_ROOT}`、`${CODEX_PLUGIN_ROOT}` 和 `${CLAUDE_PLUGIN_ROOT}`。
+
+导入的 MCP 工具会在 `tools/call` 的 `_meta["x-codex-turn-metadata"]` 中携带当前 DSH 会话和轮次信息。`session_id` 使用 Agent 的会话 ID，`turn_id` 使用 `<会话 ID>:<turn/start 事件序号>`；同一轮的调用保持一致，新轮次重新读取，异步并发会话相互隔离。没有活动轮次的诊断调用不生成虚假标识。这些字段不进入工具参数，也不要求模型填写。
+
+调用链为：DSH Agent → 导入工具的异步调用上下文 → MCP `tools/call` 元数据 → `node_repl` → 浏览器服务。此桥接修复浏览器服务因缺少 `session_id`、`turn_id` 抛出的 `Missing required Codex turn metadata`；浏览器扩展、认证和 App 专属服务仍需在宿主可用。插件卸载时撤销桥接，普通 DSH MCP 调用不注入这些字段。
+
 凭证不会复制到 DSH 设置、插件缓存或本仓库。状态接口只返回资源名、状态和经过脱敏的原因代码。需要继承的环境变量必须存在于 DSH 宿主环境中。
 
 本插件提供环境兼容，不会重新实现 Codex 运行时。Codex 的 OAuth/钥匙串会话、App 专属进程通信服务、Hooks、应用组件、权限策略和专用命令不会自动重现。使用配置中的请求头或环境变量认证的标准 MCP 可以复用；依赖缺失认证或运行时服务的服务器会报告连接失败。插件的 Hooks、应用和命令明确标为不支持，不会自动执行。审批和沙箱仍由 DSH 自身管理。

package/dist/src/codex-config.d.ts

@@ -8,6 +8,7 @@ export type CompatibilityItem = {
 export type CodexMcpConfig = {
     serverName: string;
     source: string;
+    originalName?: string;
     transport: 'stdio' | 'streamable-http';
     command?: string;
     args?: string[];
@@ -47,7 +48,7 @@ export declare function projectText(path: string, fs?: ProjectFileSystem, signal
 /** Repository root to cwd; without a repository only cwd participates. */
 export declare function projectDirectories(cwd: string, fs?: ProjectFileSystem, signal?: AbortSignal): Promise<string[]>;
 export declare function readCodexConfig(home: string, cwd?: string, fs?: ProjectFileSystem, signal?: AbortSignal): Promise<JsonObject>;
-export declare function normalizeCodexMcp(name: string, value: unknown, source: string, base: string, environment?: NodeJS.ProcessEnv): CodexMcpConfig | undefined;
+export declare function normalizeCodexMcp(name: string, value: unknown, source: string, base: string, environment?: NodeJS.ProcessEnv, defaultCwd?: string): CodexMcpConfig | undefined;
 export declare function discoverCodexSnapshot(home: string, options: {
     importPluginResources: boolean;
     mcpAllowlist: string[];

package/dist/src/codex-mcp-metadata.d.ts

@@ -0,0 +1,12 @@
+export type CodexTurnMetadata = {
+    session_id: string;
+    turn_id: string;
+};
+/**
+ * DSH 0.2.2-rc.1 has no per-call MCP metadata hook. Scope the SDK seam to
+ * imported tool executions so its native lifecycle and result handling remain intact.
+ */
+export declare function installCodexMcpMetadata(): {
+    run<T>(metadata: CodexTurnMetadata | undefined, operation: () => T): T;
+    dispose(): void;
+};

package/lib/index.js

@@ -1082,7 +1082,7 @@ function serverName(name2) {
   const hash = createHash3("sha256").update(name2).digest("hex").slice(0, 8);
   return `${name2.replace(/[^A-Za-z0-9_-]/g, "-").slice(0, 23)}-${hash}`;
 }
-function normalizeCodexMcp(name2, value, source, base, environment = process.env) {
+function normalizeCodexMcp(name2, value, source, base, environment = process.env, defaultCwd = base) {
   const raw = object(value);
   if (raw.enabled === false) return void 0;
   const headers = record2(raw.http_headers ?? raw.headers);
@@ -1131,8 +1131,8 @@ function normalizeCodexMcp(name2, value, source, base, environment = process.env
     if (environment[variable] !== void 0 && env[variable] === void 0)
       env[variable] = environment[variable];
   }
-  const cwd = typeof raw.cwd === "string" ? resolve(base, raw.cwd) : base;
-  const command = raw.command.includes("/") && !isAbsolute(raw.command) ? resolve(cwd, raw.command) : raw.command;
+  const cwd = typeof raw.cwd === "string" ? resolve(base, raw.cwd) : defaultCwd;
+  const command = raw.command.includes("/") && !isAbsolute(raw.command) ? resolve(typeof raw.cwd === "string" ? cwd : base, raw.command) : raw.command;
   return {
     ...common,
     transport: "stdio",
@@ -1151,9 +1151,29 @@ async function directories(path) {
   }
 }
 async function manifestAt(root) {
+  const text = await optionalText(join2(root, "plugin.json"));
+  if (text !== void 0) {
+    const manifest = object(JSON.parse(text));
+    if (manifest.$schema === "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json") {
+      const inline = manifest.extensions?.["com.openai"];
+      const overlay = inline !== null && typeof inline === "object" && !Array.isArray(inline) ? inline : object(
+        JSON.parse(
+          await optionalText(
+            join2(root, ".codex-plugin", "plugin.json")
+          ) ?? "{}"
+        )
+      );
+      return {
+        root,
+        manifest: { ...manifest, ...overlay, name: manifest.name },
+        portable: true
+      };
+    }
+  }
   for (const name2 of [".codex-plugin", ".claude-plugin"]) {
-    const text = await optionalText(join2(root, name2, "plugin.json"));
-    if (text !== void 0) return { root, manifest: object(JSON.parse(text)) };
+    const text2 = await optionalText(join2(root, name2, "plugin.json"));
+    if (text2 !== void 0)
+      return { root, manifest: object(JSON.parse(text2)), portable: false };
   }
   return void 0;
 }
@@ -1182,7 +1202,7 @@ async function resolvePlugin(home, id, config) {
 }
 function expandPlugin(value, root, home) {
   if (typeof value === "string")
-    return value.replaceAll("${CLAUDE_PLUGIN_ROOT}", root).replaceAll("${CODEX_PLUGIN_ROOT}", root).replaceAll("${CODEX_HOME}", home);
+    return value.replaceAll("${PLUGIN_ROOT}", root).replaceAll("${CLAUDE_PLUGIN_ROOT}", root).replaceAll("${CODEX_PLUGIN_ROOT}", root).replaceAll("${CODEX_HOME}", home);
   if (Array.isArray(value)) return value.map((v) => expandPlugin(v, root, home));
   if (value && typeof value === "object")
     return Object.fromEntries(
@@ -1190,6 +1210,22 @@ function expandPlugin(value, root, home) {
     );
   return value;
 }
+function restrictMcpFallback(entry, policy) {
+  if (policy.enabled === false) return void 0;
+  const requested = Array.isArray(policy.enabled_tools) ? strings(policy.enabled_tools) : void 0;
+  const enabledTools = requested && entry.enabledTools ? entry.enabledTools.filter((name2) => requested.includes(name2)) : requested ?? entry.enabledTools;
+  return {
+    ...entry,
+    ...enabledTools ? { enabledTools } : {},
+    disabledTools: [
+      .../* @__PURE__ */ new Set([
+        ...entry.disabledTools,
+        ...strings(policy.disabled_tools),
+        ...Object.entries(object(policy.tools)).filter(([, tool]) => object(tool).enabled === false).map(([name2]) => name2)
+      ])
+    ]
+  };
+}
 async function discoverCodexSnapshot(home, options, context = {}) {
   const config = await readCodexConfig(
     home,
@@ -1207,24 +1243,38 @@ async function discoverCodexSnapshot(home, options, context = {}) {
     items: []
   };
   const names = /* @__PURE__ */ new Set();
-  const addServers = (servers, source, base, plugin = "") => {
-    for (const [name2, raw] of Object.entries(servers)) {
+  const addServers = (servers, source, base, plugin = "", policies = {}) => {
+    for (const [name2, declaration] of Object.entries(servers)) {
+      const policy = Object.fromEntries(
+        Object.entries(object(policies[name2])).filter(
+          ([key]) => ["enabled", "enabled_tools", "disabled_tools", "tools"].includes(key)
+        )
+      );
+      const raw = mergeConfig(object(declaration), policy);
       const publicName = plugin ? `${plugin}-${name2}` : name2;
       if (object(raw).enabled === false || options.mcpAllowlist.length && !options.mcpAllowlist.includes(name2)) {
         result.items.push({ name: publicName, kind: "mcp", state: "disabled" });
         continue;
       }
       try {
-        const value = normalizeCodexMcp(publicName, raw, source, base);
+        const value = normalizeCodexMcp(
+          publicName,
+          raw,
+          source,
+          base,
+          process.env,
+          context.cwd ?? base
+        );
         if (!value) continue;
         if (names.has(value.serverName)) throw new Error("namespace-conflict");
         names.add(value.serverName);
-        result.mcp.push(value);
+        result.mcp.push({ ...value, originalName: name2 });
       } catch (error) {
         const previous = context.previous?.mcp.find(
           (entry) => entry.serverName === serverName(publicName)
         );
-        if (previous) result.mcp.push(previous);
+        const retained = previous && restrictMcpFallback(previous, raw);
+        if (retained) result.mcp.push(retained);
         const reason = [
           "missing-environment",
           "unsupported-transport",
@@ -1258,9 +1308,9 @@ async function discoverCodexSnapshot(home, options, context = {}) {
           });
           continue;
         }
-        const { root, manifest } = plugin;
+        const { root, manifest, portable } = plugin;
         const name2 = String(manifest.name ?? id.split("@")[0]);
-        const declared = manifest.skills ?? "./skills";
+        const declared = portable ? "./skills" : manifest.skills ?? "./skills";
         const skillRoots = [];
         for (const entry of Array.isArray(declared) ? declared : [declared]) {
           if (typeof entry === "string")
@@ -1271,7 +1321,10 @@ async function discoverCodexSnapshot(home, options, context = {}) {
             });
         }
         let servers = manifest.mcpServers;
-        if (typeof servers === "string") {
+        if (portable) {
+          const text = await optionalText(join2(root, "mcp.json"));
+          servers = text === void 0 ? void 0 : JSON.parse(text);
+        } else if (typeof servers === "string") {
           const text = await optionalText(resolve(root, servers));
           if (text === void 0) throw new Error("missing-plugin-mcp-file");
           servers = JSON.parse(text);
@@ -1285,7 +1338,13 @@ async function discoverCodexSnapshot(home, options, context = {}) {
           home
         );
         result.skillRoots.push(...skillRoots);
-        addServers(object(expanded), `plugin:${id}`, root, name2);
+        addServers(
+          object(expanded),
+          `plugin:${id}`,
+          root,
+          name2,
+          object(object(setting).mcp_servers)
+        );
         result.items.push({ name: id, kind: "plugin", state: "loaded" });
         for (const field of ["hooks", "apps", "commands"]) {
           if (manifest[field])
@@ -1297,11 +1356,16 @@ async function discoverCodexSnapshot(home, options, context = {}) {
             });
         }
       } catch {
-        result.mcp.push(
-          ...context.previous?.mcp.filter(
-            (entry) => entry.source === `plugin:${id}`
-          ) ?? []
-        );
+        const policies = object(object(setting).mcp_servers);
+        for (const entry of context.previous?.mcp ?? []) {
+          if (entry.source !== `plugin:${id}`) continue;
+          if (!entry.originalName && Object.keys(policies).length) continue;
+          const retained = restrictMcpFallback(
+            entry,
+            object(policies[entry.originalName ?? ""])
+          );
+          if (retained) result.mcp.push(retained);
+        }
         result.skillRoots.push(
           ...context.previous?.skillRoots.filter(
             (entry) => entry.pluginId === id
@@ -1548,6 +1612,49 @@ function installCodexInstructions(ctx, home) {
   );
 }
 
+// src/codex-mcp-metadata.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Client } from "@modelcontextprotocol/client";
+var scope = new AsyncLocalStorage();
+var users = 0;
+var restore;
+function installCodexMcpMetadata() {
+  if (users++ === 0) {
+    const original = Client.prototype.callTool;
+    const callTool = function(params, options) {
+      const call = scope.getStore();
+      const metadata = call?.active() ? call.metadata : void 0;
+      return original.call(
+        this,
+        metadata ? {
+          ...params,
+          _meta: { ...params._meta, "x-codex-turn-metadata": metadata }
+        } : params,
+        options
+      );
+    };
+    Client.prototype.callTool = callTool;
+    restore = () => {
+      if (Client.prototype.callTool === callTool)
+        Client.prototype.callTool = original;
+    };
+  }
+  let active = true;
+  return {
+    run(metadata, operation) {
+      return scope.run({ active: () => active, metadata }, operation);
+    },
+    dispose() {
+      if (!active) return;
+      active = false;
+      if (--users === 0) {
+        restore?.();
+        restore = void 0;
+      }
+    }
+  };
+}
+
 // src/codex.ts
 var fingerprint = (v) => createHash5("sha256").update(JSON.stringify(v)).digest("hex");
 function publicToolName(server, name2) {
@@ -1629,6 +1736,7 @@ function installCodexCompatibility(ctx, config) {
       dispose: async () => {
       }
     };
+  const metadata = config.importMcpServers ? installCodexMcpMetadata() : void 0;
   const scopedSnapshot = async (cwd, signal, fallback) => {
     const key = resolve3(cwd);
     const previous = scopedSnapshots.get(key) ?? fallback ?? latest;
@@ -1841,7 +1949,22 @@ function installCodexCompatibility(ctx, config) {
                 if (enabledTools && !enabledTools.includes(definition.name) || disabledTools.includes(definition.name))
                   return () => {
                   };
-                return target.register(definition);
+                return target.register({
+                  ...definition,
+                  execute(args, execution) {
+                    const agent = execution.agent ?? owner.agent;
+                    const boundary = agent.session ? child.agents.turnBoundaryOf?.(agent.session) : void 0;
+                    const turn = boundary?.openTurnStartSeq;
+                    const turnMetadata = typeof agent.id === "string" && agent.id && turn != null ? {
+                      session_id: agent.id,
+                      turn_id: `${agent.id}:${turn}`
+                    } : void 0;
+                    return metadata.run(
+                      turnMetadata,
+                      () => definition.execute(args, execution)
+                    );
+                  }
+                });
               };
             const value = Reflect.get(target, key);
             return typeof value === "function" ? value.bind(target) : value;
@@ -1984,9 +2107,15 @@ function installCodexCompatibility(ctx, config) {
     agents.delete(agent);
     await owner.tail.catch(() => {
     });
-    await Promise.all(
-      [...owner.clients.values()].map((client) => client.fiber.dispose())
+    const results = await Promise.allSettled(
+      [...owner.clients.values()].map(async (client) => client.fiber.dispose())
     );
+    const errors = results.flatMap(
+      (result) => result.status === "rejected" ? [result.reason] : []
+    );
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1)
+      throw new AggregateError(errors, "Codex MCP client cleanup failed");
   };
   const reconcile = async () => {
     if (closed) return;
@@ -2082,11 +2211,25 @@ function installCodexCompatibility(ctx, config) {
   const dispose = () => stopping ??= (async () => {
     closed = true;
     if (timer) clearInterval(timer);
-    await Promise.all(injections.map((fiber) => fiber.dispose()));
-    await tail;
-    await Promise.all([...agents.keys()].map(disposeAgent));
-    skillDispose?.();
-    await Promise.all(skills.map((s) => s.dispose()));
+    const errors = [];
+    const settle = async (actions) => {
+      const results = await Promise.allSettled(
+        actions.map(async (action) => action())
+      );
+      for (const result of results)
+        if (result.status === "rejected") errors.push(result.reason);
+    };
+    await settle(injections.map((fiber) => () => fiber.dispose()));
+    await settle([() => tail]);
+    await settle([...agents.keys()].map((agent) => () => disposeAgent(agent)));
+    await settle([
+      () => metadata?.dispose(),
+      () => skillDispose?.(),
+      ...skills.map((provider) => () => provider.dispose())
+    ]);
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1)
+      throw new AggregateError(errors, "Codex compatibility cleanup failed");
   })();
   ctx.effect(() => dispose, "codex-compatibility");
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-gpt-adapter",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -122,7 +122,8 @@
     "react-dom": "18.3.1",
     "typescript": "^5.8.2",
     "vitest": "^3.0.8",
-    "yaml": "^2.8.1"
+    "yaml": "^2.8.1",
+    "@modelcontextprotocol/client": "2.2.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "4.1.0",
@@ -141,7 +142,8 @@
     "@deepseek-ai/dsh-typert-protocol": "0.2.2-rc.1",
     "@deepseek-ai/dsh-util-values": "0.2.2-rc.1",
     "@deepseek-ai/schemastery": "3.19.0",
-    "@earendil-works/pi-ai": "1.3.0"
+    "@earendil-works/pi-ai": "1.3.0",
+    "@modelcontextprotocol/client": "2.2.0"
   },
   "dependencies": {
     "smol-toml": "1.9.1"