@openclaw/acpx 2026.7.1 → 2026.7.2-beta.2

package/dist/{service-CzJr7Koj.js → service-DJchyiuU.js}

@@ -1,18 +1,21 @@
-import { n as createLazyAcpRuntimeProxy } from "./register.runtime-Yz704dK5.js";
+import { n as createLazyAcpRuntimeProxy } from "./register.runtime-CysfMsSr.js";
+import "./config-schema-lrk5nlcV.js";
 import { a as createAcpxProcessLeaseStore, d as ACPX_GATEWAY_INSTANCE_KEY, f as ACPX_GATEWAY_INSTANCE_NAMESPACE, h as normalizeAcpxGatewayInstanceRecord, l as openAcpxProcessLeaseStateStore, n as OPENCLAW_ACPX_LEASE_ID_ENV, r as OPENCLAW_GATEWAY_INSTANCE_ID_ARG, t as OPENCLAW_ACPX_LEASE_ID_ARG } from "./process-lease-DiKkFj6F.js";
 import { registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "./runtime-api.js";
-import { a as resolveAcpxPluginRoot, c as splitCommandParts, i as resolveAcpxPluginConfig, o as toAcpMcpServers, r as reapStaleOpenClawOwnedAcpxOrphans, s as quoteCommandPart, t as cleanupOpenClawOwnedAcpxProcessTree } from "./process-reaper-cncoDfwV.js";
+import { a as resolveAcpxPluginRoot, c as splitCommandParts, d as LEGACY_CODEX_ACP_PACKAGE, f as OPENCLAW_CODEX_CONFIG_ARG, i as resolveAcpxPluginConfig, l as CODEX_ACP_BIN, o as toAcpMcpServers, r as reapStaleOpenClawOwnedAcpxOrphans, s as quoteCommandPart, t as cleanupOpenClawOwnedAcpxProcessTree, u as CODEX_ACP_PACKAGE } from "./process-reaper-CoGRyMJ_.js";
 import { createRequire } from "node:module";
+import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import fs from "node:fs/promises";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import fs from "node:fs";
+import fs$1 from "node:fs/promises";
 import path from "node:path";
+import os from "node:os";
 import { randomUUID } from "node:crypto";
-import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";
 import { inspect } from "node:util";
-import fs$1 from "node:fs";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import os from "node:os";
 import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
+import { parse, stringify } from "smol-toml";
 //#region extensions/acpx/src/codex-trust-config.ts
 /**
 * Builds isolated Codex config for ACPX sessions. It preserves safe inherited
@@ -123,9 +126,11 @@ function extractTrustedCodexProjectPaths(configToml) {
 			continue;
 		}
 		const assignment = /^(?<key>"(?:\\.|[^"\\])*"|'[^']*'|[A-Za-z0-9_\-/.~:]+)\s*=\s*(?<value>.+)$/.exec(line);
-		if (!assignment?.groups) continue;
-		const key = parseTomlString(assignment.groups.key) ?? assignment.groups.key;
-		const value = assignment.groups.value.trim();
+		const rawKey = assignment?.groups?.key;
+		const rawValue = assignment?.groups?.value;
+		if (!rawKey || rawValue === void 0) continue;
+		const key = parseTomlString(rawKey) ?? rawKey;
+		const value = rawValue.trim();
 		if (inProjectsTable && /^\{.*\}$/.test(value)) {
 			if (/\btrust_level\s*=\s*["']trusted["']/.test(value) && key) trusted.add(key);
 			continue;
@@ -221,15 +226,13 @@ function renderIsolatedCodexConfig(params) {
 * Prepares isolated Codex and Claude ACP wrapper commands for ACPX. The bridge
 * copies safe auth/config state into plugin-owned homes and redacts diagnostics.
 */
-const CODEX_ACP_PACKAGE = "@zed-industries/codex-acp";
-const CODEX_ACP_BIN = "codex-acp";
 const CLAUDE_ACP_PACKAGE = "@agentclientprotocol/claude-agent-acp";
 const CLAUDE_ACP_BIN = "claude-agent-acp";
 const RUN_CONFIGURED_COMMAND_SENTINEL = "--openclaw-run-configured";
 const requireFromHere = createRequire(import.meta.url);
 function readSelfManifest() {
 	const manifestPath = path.join(resolveAcpxPluginRoot(import.meta.url), "package.json");
-	return JSON.parse(fs$1.readFileSync(manifestPath, "utf8"));
+	return JSON.parse(fs.readFileSync(manifestPath, "utf8"));
 }
 function readManifestDependencyVersion(packageName) {
 	const version = readSelfManifest().dependencies?.[packageName];
@@ -254,7 +257,7 @@ async function resolveInstalledAcpPackageBinPath(packageName, binName) {
 		if (manifest.name !== packageName) return;
 		const binPath = resolvePackageBinPath(packageJsonPath, manifest, binName);
 		if (!binPath) return;
-		await fs.access(binPath);
+		await fs$1.access(binPath);
 		return binPath;
 	} catch {
 		return;
@@ -378,9 +381,10 @@ function renderDiagnosticRedactionRuleSpecs() {
 }
 function buildAdapterWrapperScript(params) {
 	return `#!/usr/bin/env node
-import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
 import { fileURLToPath } from "node:url";
 
 ${params.envSetup}
@@ -390,6 +394,7 @@ const stderrLogMaxChars = 256 * 1024;
 const openClawWrapperArgs = new Set([
   ${quoteCommandPart(OPENCLAW_ACPX_LEASE_ID_ARG)},
   ${quoteCommandPart(OPENCLAW_GATEWAY_INSTANCE_ID_ARG)},
+  ${(params.openClawWrapperArgs ?? []).map(quoteCommandPart).join(",\n  ")}
 ]);
 
 function readOpenClawWrapperArg(args, name) {
@@ -401,6 +406,21 @@ function readOpenClawWrapperArg(args, name) {
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
 
+function readOpenClawWrapperArgs(args, name) {
+  const values = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] !== name) {
+      continue;
+    }
+    const value = args[index + 1];
+    if (typeof value === "string" && value.trim()) {
+      values.push(value.trim());
+    }
+    index += 1;
+  }
+  return values;
+}
+
 function safeDiagnosticFilePart(value) {
   const sanitized = String(value || "").replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120);
   return sanitized || "pid-" + process.pid;
@@ -431,7 +451,25 @@ function redactDiagnosticText(text) {
   return redacted;
 }
 
+function tailUtf16Safe(text, maxChars) {
+  let start = Math.max(0, text.length - maxChars);
+  const startsInsideSurrogatePair =
+    start > 0 &&
+    start < text.length &&
+    text.charCodeAt(start) >= 0xdc00 &&
+    text.charCodeAt(start) <= 0xdfff &&
+    text.charCodeAt(start - 1) >= 0xd800 &&
+    text.charCodeAt(start - 1) <= 0xdbff;
+  if (startsInsideSurrogatePair) {
+    start += 1;
+  }
+  return text.slice(start);
+}
+
 let pendingStderrLogText = "";
+// Pipe chunks can split a UTF-8 sequence. Preserve decoder state so diagnostic
+// capture does not manufacture replacement characters between chunks.
+const stderrDecoder = new StringDecoder("utf8");
 const stderrPrivateKeyEndPattern = /-----END [A-Z ]*PRIVATE KEY-----/;
 
 function hasUnclosedPrivateKeyBlock(text) {
@@ -456,7 +494,7 @@ function writeRedactedStderrLog(text) {
     appendFileSync(stderrLogPath, redactDiagnosticText(text), "utf8");
     const current = readFileSync(stderrLogPath, "utf8");
     if (current.length > stderrLogMaxChars) {
-      writeFileSync(stderrLogPath, current.slice(-stderrLogMaxChars), "utf8");
+      writeFileSync(stderrLogPath, tailUtf16Safe(current, stderrLogMaxChars), "utf8");
     }
   } catch {
     // Stderr capture is diagnostic-only; never break the ACP adapter.
@@ -475,7 +513,7 @@ function flushFinalizedStderrLogText() {
   const lastLineBreak = pendingStderrLogText.lastIndexOf("\\n");
   if (lastLineBreak === -1) {
     if (pendingStderrLogText.length > stderrLogMaxChars) {
-      pendingStderrLogText = pendingStderrLogText.slice(-stderrLogMaxChars);
+      pendingStderrLogText = tailUtf16Safe(pendingStderrLogText, stderrLogMaxChars);
     }
     return;
   }
@@ -488,7 +526,7 @@ function flushFinalizedStderrLogText() {
   }
   if (flushEnd <= 0) {
     if (pendingStderrLogText.length > stderrLogMaxChars) {
-      pendingStderrLogText = pendingStderrLogText.slice(-stderrLogMaxChars);
+      pendingStderrLogText = tailUtf16Safe(pendingStderrLogText, stderrLogMaxChars);
     }
     return;
   }
@@ -498,7 +536,7 @@ function flushFinalizedStderrLogText() {
 }
 
 function appendStderrLog(chunk) {
-  const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+  const text = stderrDecoder.write(chunk);
   if (!text) {
     return;
   }
@@ -507,6 +545,7 @@ function appendStderrLog(chunk) {
 }
 
 function finishStderrLog() {
+  pendingStderrLogText += stderrDecoder.end();
   const text = redactIncompletePrivateKeyTail(pendingStderrLogText);
   pendingStderrLogText = "";
   writeRedactedStderrLog(text);
@@ -526,14 +565,14 @@ function stripOpenClawWrapperArgs(args) {
 }
 
 const rawConfiguredArgs = process.argv.slice(2);
+${params.envConfigSetup ?? ""}
 const stderrLogPath = resolveStderrLogPath(rawConfiguredArgs);
-
-try {
-  if (stderrLogPath) {
-    writeFileSync(stderrLogPath, "", "utf8");
+if (stderrLogPath) {
+  try {
+    rmSync(stderrLogPath, { force: true });
+  } catch {
+    // Diagnostic cleanup must never prevent the adapter from starting.
   }
-} catch {
-  // Stderr capture is diagnostic-only; never break the ACP adapter.
 }
 
 const configuredArgs = stripOpenClawWrapperArgs(rawConfiguredArgs);
@@ -682,6 +721,7 @@ function buildCodexAcpWrapperScript(installedBinPath) {
 		binName: CODEX_ACP_BIN,
 		installedBinPath,
 		stderrLogFileNamePrefix: "codex-acp-wrapper.stderr",
+		openClawWrapperArgs: [OPENCLAW_CODEX_CONFIG_ARG],
 		envSetup: `const codexHome = fileURLToPath(new URL("./codex-home/", import.meta.url));
 const codexAuthPath = fileURLToPath(new URL("./codex-home/auth.json", import.meta.url));
 const codexApiKey = (process.env.CODEX_API_KEY || process.env.OPENAI_API_KEY || "").trim();
@@ -715,7 +755,59 @@ if (shouldWriteCodexApiKeyAuth) {
 const env = {
   ...process.env,
   CODEX_HOME: codexHome,
-};`
+};`,
+		envConfigSetup: `function isCodexConfigObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function mergeCodexConfig(base, override) {
+  const merged = Object.assign(Object.create(null), base);
+  for (const [key, value] of Object.entries(override)) {
+    const existing = merged[key];
+    merged[key] =
+      isCodexConfigObject(existing) && isCodexConfigObject(value)
+        ? mergeCodexConfig(existing, value)
+        : value;
+  }
+  return merged;
+}
+
+const openClawCodexConfigs = readOpenClawWrapperArgs(
+  rawConfiguredArgs,
+  ${quoteCommandPart(OPENCLAW_CODEX_CONFIG_ARG)},
+);
+if (openClawCodexConfigs.length > 0) {
+  let existingCodexConfig = {};
+  if (typeof env.CODEX_CONFIG === "string" && env.CODEX_CONFIG.trim()) {
+    try {
+      const parsedCodexConfig = JSON.parse(env.CODEX_CONFIG);
+      if (!parsedCodexConfig || typeof parsedCodexConfig !== "object" || Array.isArray(parsedCodexConfig)) {
+        throw new Error("CODEX_CONFIG must be a JSON object");
+      }
+      existingCodexConfig = parsedCodexConfig;
+    } catch {
+      console.error("[openclaw] CODEX_CONFIG must be a valid JSON object");
+      process.exit(1);
+    }
+  }
+  for (const openClawCodexConfig of openClawCodexConfigs) {
+    try {
+      const parsedOpenClawCodexConfig = JSON.parse(openClawCodexConfig);
+      if (
+        !parsedOpenClawCodexConfig ||
+        typeof parsedOpenClawCodexConfig !== "object" ||
+        Array.isArray(parsedOpenClawCodexConfig)
+      ) {
+        throw new Error("invalid OpenClaw Codex config");
+      }
+      existingCodexConfig = mergeCodexConfig(existingCodexConfig, parsedOpenClawCodexConfig);
+    } catch {
+      console.error("[openclaw] invalid generated Codex ACP startup config");
+      process.exit(1);
+    }
+  }
+  env.CODEX_CONFIG = JSON.stringify(existingCodexConfig);
+}`
 	});
 }
 function buildClaudeAcpWrapperScript(installedBinPath) {
@@ -731,7 +823,7 @@ function buildClaudeAcpWrapperScript(installedBinPath) {
 }
 async function readSourceCodexConfig(codexHome) {
 	try {
-		return await fs.readFile(path.join(codexHome, "config.toml"), "utf8");
+		return await fs$1.readFile(path.join(codexHome, "config.toml"), "utf8");
 	} catch (error) {
 		if (error.code === "ENOENT") return;
 		throw error;
@@ -741,8 +833,8 @@ async function prepareIsolatedCodexHome(params) {
 	const sourceConfig = await readSourceCodexConfig(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"));
 	const trustedProjectPaths = [...sourceConfig ? extractTrustedCodexProjectPaths(sourceConfig) : [], params.workspaceDir];
 	const codexHome = path.join(params.baseDir, "codex-home");
-	await fs.mkdir(codexHome, { recursive: true });
-	await fs.writeFile(path.join(codexHome, "config.toml"), renderIsolatedCodexConfig({
+	await fs$1.mkdir(codexHome, { recursive: true });
+	await fs$1.writeFile(path.join(codexHome, "config.toml"), renderIsolatedCodexConfig({
 		sourceConfigToml: sourceConfig,
 		projectPaths: trustedProjectPaths
 	}), "utf8");
@@ -750,20 +842,20 @@ async function prepareIsolatedCodexHome(params) {
 }
 async function makeGeneratedWrapperExecutableIfPossible(wrapperPath) {
 	try {
-		await fs.chmod(wrapperPath, 493);
+		await fs$1.chmod(wrapperPath, 493);
 	} catch {}
 }
 async function writeCodexAcpWrapper(baseDir, installedBinPath) {
-	await fs.mkdir(baseDir, { recursive: true });
+	await fs$1.mkdir(baseDir, { recursive: true });
 	const wrapperPath = path.join(baseDir, "codex-acp-wrapper.mjs");
-	await fs.writeFile(wrapperPath, buildCodexAcpWrapperScript(installedBinPath), { encoding: "utf8" });
+	await fs$1.writeFile(wrapperPath, buildCodexAcpWrapperScript(installedBinPath), { encoding: "utf8" });
 	await makeGeneratedWrapperExecutableIfPossible(wrapperPath);
 	return wrapperPath;
 }
 async function writeClaudeAcpWrapper(baseDir, installedBinPath) {
-	await fs.mkdir(baseDir, { recursive: true });
+	await fs$1.mkdir(baseDir, { recursive: true });
 	const wrapperPath = path.join(baseDir, "claude-agent-acp-wrapper.mjs");
-	await fs.writeFile(wrapperPath, buildClaudeAcpWrapperScript(installedBinPath), { encoding: "utf8" });
+	await fs$1.writeFile(wrapperPath, buildClaudeAcpWrapperScript(installedBinPath), { encoding: "utf8" });
 	await makeGeneratedWrapperExecutableIfPossible(wrapperPath);
 	return wrapperPath;
 }
@@ -802,15 +894,94 @@ function extractConfiguredAdapterArgs(params) {
 	if (isAcpBinName(parts[0] ?? "", params.binName)) return parts.slice(1);
 	if (basename(parts[0] ?? "") === "node" && isAcpBinName(parts[1] ?? "", params.binName)) return parts.slice(2);
 }
-function buildCodexAcpWrapperCommand(wrapperPath, configuredCommand) {
-	const configuredAdapterArgs = extractConfiguredAdapterArgs({
+function isConfigRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mergeConfigRecords(base, override) {
+	const merged = { ...base };
+	for (const [key, value] of Object.entries(override)) {
+		const existing = merged[key];
+		const nextValue = isConfigRecord(existing) && isConfigRecord(value) ? mergeConfigRecords(existing, value) : value;
+		Object.defineProperty(merged, key, {
+			value: nextValue,
+			configurable: true,
+			enumerable: true,
+			writable: true
+		});
+	}
+	return merged;
+}
+function parseLegacyCodexConfigAssignment(assignment) {
+	const separator = assignment.indexOf("=");
+	if (separator <= 0) throw new Error(`Invalid legacy Codex ACP config override: ${assignment}`);
+	const rawKey = assignment.slice(0, separator).trim();
+	const key = rawKey === "use_legacy_landlock" ? "features.use_legacy_landlock" : rawKey;
+	const rawValue = assignment.slice(separator + 1).trim();
+	try {
+		return parse(`${key} = ${rawValue}`);
+	} catch {
+		const literal = rawValue.replace(/^["']+|["']+$/g, "");
+		return parse(`${key} = ${JSON.stringify(literal)}`);
+	}
+}
+function migrateLegacyCodexArgs(args) {
+	let config = {};
+	const forwardedArgs = [];
+	let hadOverrides = false;
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index] ?? "";
+		let assignment;
+		if (arg === "-c" || arg === "--config") assignment = args[index += 1];
+		else if (arg.startsWith("--config=")) assignment = arg.slice(9);
+		else if (arg.startsWith("-c=")) assignment = arg.slice(3);
+		else if (arg.startsWith("-c") && arg.length > 2) assignment = arg.slice(2);
+		else {
+			forwardedArgs.push(arg);
+			continue;
+		}
+		if (!assignment) throw new Error(`Missing value for legacy Codex ACP option ${arg}`);
+		hadOverrides = true;
+		config = mergeConfigRecords(config, parseLegacyCodexConfigAssignment(assignment));
+	}
+	return {
+		config,
+		forwardedArgs,
+		hadOverrides
+	};
+}
+function resolveCodexAdapterLaunch(configuredCommand) {
+	const legacyAdapterArgs = extractConfiguredAdapterArgs({
+		configuredCommand,
+		packageName: LEGACY_CODEX_ACP_PACKAGE,
+		binName: CODEX_ACP_BIN
+	});
+	if (legacyAdapterArgs) {
+		const migration = migrateLegacyCodexArgs(legacyAdapterArgs);
+		return {
+			args: [...migration.hadOverrides ? [OPENCLAW_CODEX_CONFIG_ARG, JSON.stringify(migration.config)] : [], ...migration.forwardedArgs],
+			...migration.hadOverrides ? { migratedConfig: migration.config } : {}
+		};
+	}
+	const maintainedAdapterArgs = extractConfiguredAdapterArgs({
 		configuredCommand,
 		packageName: CODEX_ACP_PACKAGE,
 		binName: CODEX_ACP_BIN
 	});
-	if (configuredAdapterArgs) return buildWrapperCommand(wrapperPath, configuredAdapterArgs);
+	if (!maintainedAdapterArgs) return;
+	return { args: maintainedAdapterArgs };
+}
+function buildCodexAcpWrapperCommand(wrapperPath, configuredCommand) {
+	const launch = resolveCodexAdapterLaunch(configuredCommand);
+	if (launch) return buildWrapperCommand(wrapperPath, launch.args);
 	return buildWrapperCommand(wrapperPath, [RUN_CONFIGURED_COMMAND_SENTINEL, ...splitCommandParts(configuredCommand?.trim() ?? "")]);
 }
+async function persistMigratedCodexMcpConfig(params) {
+	const mcpServers = params.migratedConfig?.mcp_servers;
+	if (!isConfigRecord(mcpServers)) return;
+	const configPath = path.join(params.codexHome, "config.toml");
+	const merged = mergeConfigRecords(parse(await fs$1.readFile(configPath, "utf8")), { mcp_servers: mcpServers });
+	await fs$1.writeFile(configPath, stringify(merged), "utf8");
+}
 function buildClaudeAcpWrapperCommand(wrapperPath, configuredCommand) {
 	const configuredAdapterArgs = extractConfiguredAdapterArgs({
 		configuredCommand,
@@ -824,16 +995,20 @@ function buildClaudeAcpWrapperCommand(wrapperPath, configuredCommand) {
 async function prepareAcpxCodexAuthConfig(params) {
 	params.logger;
 	const codexBaseDir = path.join(params.stateDir, "acpx");
-	await prepareIsolatedCodexHome({
-		baseDir: codexBaseDir,
-		workspaceDir: params.pluginConfig.cwd
+	const configuredCodexCommand = params.pluginConfig.agents.codex;
+	const configuredClaudeCommand = params.pluginConfig.agents.claude;
+	const codexLaunch = resolveCodexAdapterLaunch(configuredCodexCommand);
+	await persistMigratedCodexMcpConfig({
+		codexHome: await prepareIsolatedCodexHome({
+			baseDir: codexBaseDir,
+			workspaceDir: params.pluginConfig.cwd
+		}),
+		migratedConfig: codexLaunch?.migratedConfig
 	});
 	const installedCodexBinPath = await (params.resolveInstalledCodexAcpBinPath ?? resolveInstalledCodexAcpBinPath)();
 	const installedClaudeBinPath = await (params.resolveInstalledClaudeAcpBinPath ?? resolveInstalledClaudeAcpBinPath)();
 	const wrapperPath = await writeCodexAcpWrapper(codexBaseDir, installedCodexBinPath);
 	const claudeWrapperPath = await writeClaudeAcpWrapper(codexBaseDir, installedClaudeBinPath);
-	const configuredCodexCommand = params.pluginConfig.agents.codex;
-	const configuredClaudeCommand = params.pluginConfig.agents.claude;
 	return {
 		...params.pluginConfig,
 		agents: {
@@ -852,7 +1027,7 @@ async function prepareAcpxCodexAuthConfig(params) {
 const ENABLE_STARTUP_PROBE_ENV = "OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE";
 const SKIP_RUNTIME_PROBE_ENV = "OPENCLAW_SKIP_ACPX_RUNTIME_PROBE";
 const ACPX_BACKEND_ID = "acpx";
-const loadRuntimeModule = createLazyRuntimeModule(() => import("./runtime-WjNm2DKO.js"));
+const loadRuntimeModule = createLazyRuntimeModule(() => import("./runtime-BEOGc4Ik.js"));
 /** Convert ACPX timeout seconds into timer-safe milliseconds. */
 function resolveAcpxTimerTimeoutMs(timeoutSeconds) {
 	if (timeoutSeconds === void 0) return;
@@ -873,6 +1048,7 @@ function createLazyDefaultRuntime(params) {
 				agentRegistry: module.createAgentRegistry({ overrides: params.pluginConfig.agents }),
 				probeAgent: params.pluginConfig.probeAgent,
 				mcpServers: toAcpMcpServers(params.pluginConfig.mcpServers),
+				pluginToolsMcpBridgeEnabled: params.pluginConfig.pluginToolsMcpBridge,
 				openclawToolsMcpBridgeEnabled: params.pluginConfig.openClawToolsMcpBridge,
 				permissionMode: params.pluginConfig.permissionMode,
 				nonInteractivePermissions: params.pluginConfig.nonInteractivePermissions,
@@ -924,13 +1100,9 @@ function formatDoctorFailureMessage(report) {
 	const detailText = report.details?.map(formatDoctorDetail).filter(Boolean).join("; ").trim();
 	return detailText ? `${report.message} (${detailText})` : report.message;
 }
-function normalizeProbeAgent(value) {
-	const normalized = value?.trim().toLowerCase();
-	return normalized ? normalized : void 0;
-}
 function resolveAllowedAgentsProbeAgent(ctx) {
 	for (const agent of ctx.config.acp?.allowedAgents ?? []) {
-		const normalized = normalizeProbeAgent(agent);
+		const normalized = normalizeLowercaseStringOrEmpty(agent);
 		if (normalized) return normalized;
 	}
 }
@@ -1043,8 +1215,8 @@ function createAcpxRuntimeService(params = {}) {
 			}));
 			const wrapperRoot = path.join(ctx.stateDir, "acpx");
 			await measureAcpxStartup(ctx, "filesystem.prepare", async () => {
-				await fs.mkdir(pluginConfig.stateDir, { recursive: true });
-				await fs.mkdir(wrapperRoot, { recursive: true });
+				await fs$1.mkdir(pluginConfig.stateDir, { recursive: true });
+				await fs$1.mkdir(wrapperRoot, { recursive: true });
 			});
 			const gatewayInstanceId = await measureAcpxStartup(ctx, "gateway-instance-id", () => resolveGatewayInstanceId(openKeyedStore));
 			const processLeaseStore = createAcpxProcessLeaseStore({ store: openAcpxProcessLeaseStateStore(openKeyedStore) });

package/dist/setup-api.js

@@ -1,5 +1,5 @@
-import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/acpx/setup-api.ts
 /**
 * ACPX setup plugin entry. It auto-enables setup when ACP config already points