npm - @kodelyth/acpx - Versions diffs - 2026.5.39 → 2026.5.42 - Mend

@kodelyth/acpx 2026.5.39 → 2026.5.42

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (47) hide show

package/AGENTS.md +54 -0
package/CLAUDE.md +54 -0
package/dist/index.js +14 -0
package/dist/process-reaper-DdVqzAA_.js +370 -0
package/dist/register.runtime.js +53 -0
package/dist/runtime-D9qhNKmy.js +741 -0
package/dist/runtime-api.js +4 -0
package/dist/service-CXeUME_-.js +1483 -0
package/dist/setup-api.js +16 -0
package/index.test.ts +119 -0
package/index.ts +19 -0
package/klaw.plugin.json +12 -27
package/package.json +2 -2
package/register.runtime.test.ts +104 -0
package/register.runtime.ts +86 -0
package/runtime-api.ts +49 -0
package/setup-api.ts +18 -0
package/src/acpx-runtime-compat.d.ts +65 -0
package/src/claude-agent-acp-completion.test.ts +187 -0
package/src/codex-auth-bridge.test.ts +688 -0
package/src/codex-auth-bridge.ts +780 -0
package/src/codex-trust-config.ts +297 -0
package/src/config-schema.ts +118 -0
package/src/config.test.ts +285 -0
package/src/config.ts +281 -0
package/src/manifest.test.ts +21 -0
package/src/process-lease.test.ts +89 -0
package/src/process-lease.ts +179 -0
package/src/process-reaper.test.ts +330 -0
package/src/process-reaper.ts +434 -0
package/src/runtime-internals/error-format.mjs +6 -0
package/src/runtime-internals/mcp-command-line.mjs +123 -0
package/src/runtime-internals/mcp-command-line.test.ts +59 -0
package/src/runtime-internals/mcp-proxy.mjs +121 -0
package/src/runtime-internals/mcp-proxy.test.ts +130 -0
package/src/runtime.test.ts +1817 -0
package/src/runtime.ts +1261 -0
package/src/service.test.ts +802 -0
package/src/service.ts +630 -0
package/tsconfig.json +16 -0
package/index.js +0 -7
package/register.runtime.js +0 -7
package/runtime-api.js +0 -7
package/setup-api.js +0 -7
/package/{error-format.mjs → dist/error-format.mjs} +0 -0
/package/{mcp-command-line.mjs → dist/mcp-command-line.mjs} +0 -0
/package/{mcp-proxy.mjs → dist/mcp-proxy.mjs} +0 -0

package/src/codex-trust-config.ts ADDED Viewed

@@ -0,0 +1,297 @@
+import path from "node:path";
+function stripTomlComment(line: string): string {
+  let quote: "'" | '"' | null = null;
+  let escaping = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const ch = line[index];
+    if (escaping) {
+      escaping = false;
+      continue;
+    }
+    if (quote === '"' && ch === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (ch === "#") {
+      return line.slice(0, index);
+    }
+  }
+  return line;
+}
+function parseTomlString(value: string): string | undefined {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    try {
+      return JSON.parse(trimmed) as string;
+    } catch {
+      return undefined;
+    }
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return undefined;
+}
+function parseTomlDottedKey(value: string): string[] {
+  const parts: string[] = [];
+  let current = "";
+  let quote: "'" | '"' | null = null;
+  let escaping = false;
+  for (const ch of value.trim()) {
+    if (escaping) {
+      current += ch;
+      escaping = false;
+      continue;
+    }
+    if (quote === '"' && ch === "\\") {
+      current += ch;
+      escaping = true;
+      continue;
+    }
+    if (quote) {
+      current += ch;
+      if (ch === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === ".") {
+      parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) {
+    parts.push(current.trim());
+  }
+  return parts.map((part) => parseTomlString(part) ?? part);
+}
+function parseProjectHeader(line: string): string | undefined {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]") || trimmed.startsWith("[[")) {
+    return undefined;
+  }
+  const parts = parseTomlDottedKey(trimmed.slice(1, -1));
+  return parts.length === 2 && parts[0] === "projects" ? parts[1] : undefined;
+}
+function parseTrustedInlineProjectEntries(value: string): string[] {
+  const trusted: string[] = [];
+  const entryPattern =
+    /(?<key>"(?:\\.|[^"\\])*"|'[^']*'|[A-Za-z0-9_\-/.~:]+)\s*=\s*\{(?<body>[^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g;
+  for (const match of value.matchAll(entryPattern)) {
+    const key = match.groups?.key;
+    const body = match.groups?.body;
+    if (!key || !body || !/\btrust_level\s*=\s*["']trusted["']/.test(body)) {
+      continue;
+    }
+    const projectPath = parseTomlString(key) ?? key.trim();
+    if (projectPath) {
+      trusted.push(projectPath);
+    }
+  }
+  return trusted;
+}
+export function extractTrustedCodexProjectPaths(configToml: string): string[] {
+  const trusted = new Set<string>();
+  let currentProjectPath: string | undefined;
+  let inProjectsTable = false;
+  for (const rawLine of configToml.split(/\r?\n/)) {
+    const line = stripTomlComment(rawLine).trim();
+    if (!line) {
+      continue;
+    }
+    if (line.startsWith("[")) {
+      currentProjectPath = parseProjectHeader(line);
+      inProjectsTable = line === "[projects]";
+      continue;
+    }
+    if (currentProjectPath && /^trust_level\s*=\s*["']trusted["']\s*$/.test(line)) {
+      trusted.add(currentProjectPath);
+      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();
+    if (inProjectsTable && /^\{.*\}$/.test(value)) {
+      if (/\btrust_level\s*=\s*["']trusted["']/.test(value) && key) {
+        trusted.add(key);
+      }
+      continue;
+    }
+    if (key === "projects" || inProjectsTable) {
+      for (const projectPath of parseTrustedInlineProjectEntries(value)) {
+        trusted.add(projectPath);
+      }
+    }
+  }
+  return Array.from(trusted);
+}
+const INHERITED_TOP_LEVEL_CODEX_CONFIG_KEYS = new Set([
+  "model",
+  "model_provider",
+  "model_reasoning_effort",
+  "sandbox_mode",
+]);
+const INHERITED_MODEL_PROVIDER_CONFIG_KEYS = new Set([
+  "name",
+  "base_url",
+  "wire_api",
+  "env_key",
+  "env_key_instructions",
+  "requires_openai_auth",
+  "request_max_retries",
+  "stream_max_retries",
+  "stream_idle_timeout_ms",
+]);
+function parseTableHeader(line: string): string[] | undefined {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]") || trimmed.startsWith("[[")) {
+    return undefined;
+  }
+  return parseTomlDottedKey(trimmed.slice(1, -1));
+}
+function isInheritedModelProviderTable(parts: string[] | undefined): boolean {
+  return parts?.[0] === "model_providers" && parts.length === 2;
+}
+function parseTopLevelAssignmentKey(line: string): string | undefined {
+  const assignment = /^(?<key>[A-Za-z0-9_-]+)\s*=\s*(?<value>.+)$/.exec(line);
+  return assignment?.groups?.key;
+}
+function extractInheritedCodexRuntimeConfig(configToml: string): string {
+  const inheritedLines: string[] = [];
+  let inAnyTable = false;
+  let inInheritedTable = false;
+  let pendingInheritedTableHeader = "";
+  function flushInheritedTableHeader(): void {
+    if (!pendingInheritedTableHeader) {
+      return;
+    }
+    if (inheritedLines.length > 0 && inheritedLines[inheritedLines.length - 1] !== "") {
+      inheritedLines.push("");
+    }
+    inheritedLines.push(pendingInheritedTableHeader);
+    pendingInheritedTableHeader = "";
+  }
+  for (const rawLine of configToml.split(/\r?\n/)) {
+    const trimmedLine = rawLine.trim();
+    const semanticLine = stripTomlComment(rawLine).trim();
+    if (trimmedLine.startsWith("[")) {
+      const tableParts = parseTableHeader(trimmedLine);
+      inAnyTable = true;
+      inInheritedTable = isInheritedModelProviderTable(tableParts);
+      if (inInheritedTable) {
+        pendingInheritedTableHeader = rawLine.trimEnd();
+      } else {
+        pendingInheritedTableHeader = "";
+      }
+      continue;
+    }
+    if (inInheritedTable) {
+      if (!semanticLine) {
+        continue;
+      }
+      const key = parseTopLevelAssignmentKey(semanticLine);
+      if (!key || !INHERITED_MODEL_PROVIDER_CONFIG_KEYS.has(key)) {
+        continue;
+      }
+      flushInheritedTableHeader();
+      inheritedLines.push(rawLine.trimEnd());
+      continue;
+    }
+    if (inAnyTable) {
+      continue;
+    }
+    const key = parseTopLevelAssignmentKey(semanticLine);
+    if (!key) {
+      continue;
+    }
+    if (!INHERITED_TOP_LEVEL_CODEX_CONFIG_KEYS.has(key)) {
+      continue;
+    }
+    inheritedLines.push(rawLine.trimEnd());
+  }
+  while (inheritedLines.length > 0 && inheritedLines[inheritedLines.length - 1] === "") {
+    inheritedLines.pop();
+  }
+  return inheritedLines.join("\n");
+}
+export function renderIsolatedCodexConfig(params: {
+  sourceConfigToml?: string;
+  projectPaths: string[];
+}): string {
+  const normalized = Array.from(
+    new Set(
+      params.projectPaths
+        .map((projectPath) => projectPath.trim())
+        .filter(Boolean)
+        .map((projectPath) => path.resolve(projectPath)),
+    ),
+  ).toSorted((left, right) => left.localeCompare(right));
+  const inheritedConfig = params.sourceConfigToml
+    ? extractInheritedCodexRuntimeConfig(params.sourceConfigToml)
+    : "";
+  return [
+    "# Generated by Klaw for Codex ACP sessions.",
+    inheritedConfig,
+    ...normalized.flatMap((projectPath) => [
+      "",
+      `[projects.${JSON.stringify(projectPath)}]`,
+      'trust_level = "trusted"',
+    ]),
+    "",
+  ]
+    .filter((line, index, lines) => !(line === "" && lines[index - 1] === ""))
+    .join("\n");
+}
+export function renderIsolatedCodexProjectTrustConfig(projectPaths: string[]): string {
+  return renderIsolatedCodexConfig({ projectPaths });
+}

package/src/config-schema.ts ADDED Viewed

@@ -0,0 +1,118 @@
+import { z } from "zod";
+const ACPX_PERMISSION_MODES = ["approve-all", "approve-reads", "deny-all"] as const;
+export type AcpxPermissionMode = (typeof ACPX_PERMISSION_MODES)[number];
+const ACPX_NON_INTERACTIVE_POLICIES = ["deny", "fail"] as const;
+export type AcpxNonInteractivePermissionPolicy = (typeof ACPX_NON_INTERACTIVE_POLICIES)[number];
+export const DEFAULT_ACPX_TIMEOUT_SECONDS = 120;
+export type McpServerConfig = {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+};
+export type AcpxMcpServer = {
+  name: string;
+  command: string;
+  args: string[];
+  env: Array<{ name: string; value: string }>;
+};
+export type AcpxPluginConfig = {
+  cwd?: string;
+  stateDir?: string;
+  probeAgent?: string;
+  permissionMode?: AcpxPermissionMode;
+  nonInteractivePermissions?: AcpxNonInteractivePermissionPolicy;
+  pluginToolsMcpBridge?: boolean;
+  openClawToolsMcpBridge?: boolean;
+  strictWindowsCmdWrapper?: boolean;
+  timeoutSeconds?: number;
+  queueOwnerTtlSeconds?: number;
+  mcpServers?: Record<string, McpServerConfig>;
+  agents?: Record<string, { command: string; args?: string[] }>;
+};
+export type ResolvedAcpxPluginConfig = {
+  cwd: string;
+  stateDir: string;
+  probeAgent?: string;
+  permissionMode: AcpxPermissionMode;
+  nonInteractivePermissions: AcpxNonInteractivePermissionPolicy;
+  pluginToolsMcpBridge: boolean;
+  openClawToolsMcpBridge: boolean;
+  strictWindowsCmdWrapper: boolean;
+  timeoutSeconds?: number;
+  queueOwnerTtlSeconds: number;
+  legacyCompatibilityConfig: {
+    strictWindowsCmdWrapper?: boolean;
+    queueOwnerTtlSeconds?: number;
+  };
+  mcpServers: Record<string, McpServerConfig>;
+  agents: Record<string, string>;
+};
+const nonEmptyTrimmedString = (message: string) =>
+  z.string({ error: message }).trim().min(1, { error: message });
+const McpServerConfigSchema = z.object({
+  command: nonEmptyTrimmedString("command must be a non-empty string").describe(
+    "Command to run the MCP server",
+  ),
+  args: z
+    .array(z.string({ error: "args must be an array of strings" }), {
+      error: "args must be an array of strings",
+    })
+    .optional()
+    .describe("Arguments to pass to the command"),
+  env: z
+    .record(z.string(), z.string({ error: "env values must be strings" }), {
+      error: "env must be an object of strings",
+    })
+    .optional()
+    .describe("Environment variables for the MCP server"),
+});
+export const AcpxPluginConfigSchema = z.strictObject({
+  cwd: nonEmptyTrimmedString("cwd must be a non-empty string").optional(),
+  stateDir: nonEmptyTrimmedString("stateDir must be a non-empty string").optional(),
+  probeAgent: nonEmptyTrimmedString("probeAgent must be a non-empty string").optional(),
+  permissionMode: z
+    .enum(ACPX_PERMISSION_MODES, {
+      error: `permissionMode must be one of: ${ACPX_PERMISSION_MODES.join(", ")}`,
+    })
+    .optional(),
+  nonInteractivePermissions: z
+    .enum(ACPX_NON_INTERACTIVE_POLICIES, {
+      error: `nonInteractivePermissions must be one of: ${ACPX_NON_INTERACTIVE_POLICIES.join(", ")}`,
+    })
+    .optional(),
+  pluginToolsMcpBridge: z.boolean({ error: "pluginToolsMcpBridge must be a boolean" }).optional(),
+  openClawToolsMcpBridge: z
+    .boolean({ error: "openClawToolsMcpBridge must be a boolean" })
+    .optional(),
+  strictWindowsCmdWrapper: z
+    .boolean({ error: "strictWindowsCmdWrapper must be a boolean" })
+    .optional(),
+  timeoutSeconds: z
+    .number({ error: "timeoutSeconds must be a number >= 0.001" })
+    .min(0.001, { error: "timeoutSeconds must be a number >= 0.001" })
+    .default(DEFAULT_ACPX_TIMEOUT_SECONDS),
+  queueOwnerTtlSeconds: z
+    .number({ error: "queueOwnerTtlSeconds must be a number >= 0" })
+    .min(0, { error: "queueOwnerTtlSeconds must be a number >= 0" })
+    .optional(),
+  mcpServers: z.record(z.string(), McpServerConfigSchema).optional(),
+  agents: z
+    .record(
+      z.string(),
+      z.strictObject({
+        command: nonEmptyTrimmedString("agents.<id>.command must be a non-empty string"),
+        args: z.array(z.string({ error: "args must be an array of strings" })).optional(),
+      }),
+    )
+    .optional(),
+});

package/src/config.test.ts ADDED Viewed

@@ -0,0 +1,285 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { resolveAcpxPluginConfig, resolveAcpxPluginRoot } from "./config.js";
+const requireFromTest = createRequire(import.meta.url);
+const TSX_IMPORT = requireFromTest.resolve("tsx");
+function expectedSourceMcpServerArgs(entrypoint: string): string[] {
+  return ["--import", TSX_IMPORT, path.resolve(entrypoint)];
+}
+describe("embedded acpx plugin config", () => {
+  it("resolves workspace stateDir and cwd by default", () => {
+    const workspaceDir = path.resolve("/tmp/klaw-acpx");
+    const resolved = resolveAcpxPluginConfig({
+      rawConfig: undefined,
+      workspaceDir,
+    });
+    expect(resolved.cwd).toBe(workspaceDir);
+    expect(resolved.stateDir).toBe(path.join(workspaceDir, "state"));
+    expect(resolved.permissionMode).toBe("approve-reads");
+    expect(resolved.nonInteractivePermissions).toBe("fail");
+    expect(resolved.timeoutSeconds).toBe(120);
+    expect(resolved.agents).toStrictEqual({});
+  });
+  it("keeps explicit timeoutSeconds config", () => {
+    const resolved = resolveAcpxPluginConfig({
+      rawConfig: {
+        timeoutSeconds: 300,
+      },
+      workspaceDir: "/tmp/klaw-acpx",
+    });
+    expect(resolved.timeoutSeconds).toBe(300);
+  });
+  it("keeps explicit probeAgent config", () => {
+    const resolved = resolveAcpxPluginConfig({
+      rawConfig: {
+        probeAgent: "claude",
+      },
+      workspaceDir: "/tmp/klaw-acpx",
+    });
+    expect(resolved.probeAgent).toBe("claude");
+  });
+  it("accepts agent command overrides", () => {
+    const resolved = resolveAcpxPluginConfig({
+      rawConfig: {
+        agents: {
+          claude: { command: "claude --acp" },
+          codex: { command: "codex custom-acp" },
+        },
+      },
+      workspaceDir: "/tmp/klaw-acpx",
+    });
+    expect(resolved.agents).toEqual({
+      claude: "claude --acp",
+      codex: "codex custom-acp",
+    });
+  });
+  it("combines agent command with args array", () => {
+    const resolved = resolveAcpxPluginConfig({
+      rawConfig: {
+        agents: {
+          claude: {
+            command: "node",
+            args: ["/path/to/adapter.mjs", "--verbose"],
+          },
+          codex: {
+            command: "codex-acp",
+            args: ["--model", "gpt-5"],
+          },
+        },
+      },
+      workspaceDir: "/tmp/klaw-acpx",
+    });
+    expect(resolved.agents).toEqual({
+      claude: "node /path/to/adapter.mjs --verbose",
+      codex: "codex-acp --model gpt-5",
+    });
+  });
+  it("quotes agent args that need to survive command-line parsing as one token", () => {
+    const resolved = resolveAcpxPluginConfig({
+      rawConfig: {
+        agents: {
+          custom: {
+            command: "node",
+            args: ["/tmp/My Adapter.mjs", "--flag=value with spaces", "owner's-choice"],
+          },
+        },
+      },
+      workspaceDir: "/tmp/klaw-acpx",
+    });
+    expect(resolved.agents).toEqual({
+      custom: "node '/tmp/My Adapter.mjs' '--flag=value with spaces' 'owner'\"'\"'s-choice'",
+    });
+  });
+  it("handles agent command without args (backward compat)", () => {
+    const resolved = resolveAcpxPluginConfig({
+      rawConfig: {
+        agents: {
+          simple: { command: "simple-acp" },
+        },
+      },
+      workspaceDir: "/tmp/klaw-acpx",
+    });
+    expect(resolved.agents).toEqual({
+      simple: "simple-acp",
+    });
+  });
+  it("leaves probeAgent undefined by default so the runtime picks its built-in probe agent", () => {
+    const resolved = resolveAcpxPluginConfig({
+      rawConfig: undefined,
+      workspaceDir: "/tmp/klaw-acpx",
+    });
+    expect(resolved.probeAgent).toBeUndefined();
+  });
+  it("carries an explicit probeAgent through to the resolved plugin config, trimmed and lowercased", () => {
+    const resolved = resolveAcpxPluginConfig({
+      rawConfig: {
+        probeAgent: "  OpenCode  ",
+      },
+      workspaceDir: "/tmp/klaw-acpx",
+    });
+    expect(resolved.probeAgent).toBe("opencode");
+  });
+  it("rejects an empty probeAgent string", () => {
+    expect(() =>
+      resolveAcpxPluginConfig({
+        rawConfig: {
+          probeAgent: "",
+        },
+        workspaceDir: "/tmp/klaw-acpx",
+      }),
+    ).toThrow(/probeAgent must be a non-empty string/);
+  });
+  it("injects the built-in plugin-tools MCP server only when explicitly enabled", () => {
+    const resolved = resolveAcpxPluginConfig({
+      rawConfig: {
+        pluginToolsMcpBridge: true,
+      },
+      workspaceDir: "/tmp/klaw-acpx",
+    });
+    const server = resolved.mcpServers["klaw-plugin-tools"];
+    expect(server).toEqual({
+      command: process.execPath,
+      args: expectedSourceMcpServerArgs("src/mcp/plugin-tools-serve.ts"),
+    });
+  });
+  it("injects the built-in Klaw tools MCP server only when explicitly enabled", () => {
+    const resolved = resolveAcpxPluginConfig({
+      rawConfig: {
+        openClawToolsMcpBridge: true,
+      },
+      workspaceDir: "/tmp/klaw-acpx",
+    });
+    const server = resolved.mcpServers["klaw-tools"];
+    expect(server).toEqual({
+      command: process.execPath,
+      args: expectedSourceMcpServerArgs("src/mcp/klaw-tools-serve.ts"),
+    });
+  });
+  it("resolves the plugin root from shared dist chunk paths", () => {
+    const moduleUrl = new URL("../../../dist/extensions/acpx/service-shared.js", import.meta.url)
+      .href;
+    expect(resolveAcpxPluginRoot(moduleUrl)).toBe(path.resolve("extensions/acpx"));
+  });
+  it("keeps the runtime json schema in sync with the manifest config schema", () => {
+    const pluginRoot = resolveAcpxPluginRoot();
+    const manifest = JSON.parse(
+      fs.readFileSync(path.join(pluginRoot, "klaw.plugin.json"), "utf8"),
+    ) as { configSchema?: unknown };
+    expect(manifest.configSchema).toStrictEqual({
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        cwd: {
+          type: "string",
+          minLength: 1,
+        },
+        stateDir: {
+          type: "string",
+          minLength: 1,
+        },
+        permissionMode: {
+          type: "string",
+          enum: ["approve-all", "approve-reads", "deny-all"],
+        },
+        nonInteractivePermissions: {
+          type: "string",
+          enum: ["deny", "fail"],
+        },
+        pluginToolsMcpBridge: {
+          type: "boolean",
+        },
+        openClawToolsMcpBridge: {
+          type: "boolean",
+        },
+        strictWindowsCmdWrapper: {
+          type: "boolean",
+        },
+        timeoutSeconds: {
+          type: "number",
+          minimum: 0.001,
+          default: 120,
+        },
+        queueOwnerTtlSeconds: {
+          type: "number",
+          minimum: 0,
+        },
+        probeAgent: {
+          type: "string",
+          minLength: 1,
+        },
+        mcpServers: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            properties: {
+              command: {
+                type: "string",
+                minLength: 1,
+                description: "Command to run the MCP server",
+              },
+              args: {
+                type: "array",
+                items: { type: "string" },
+                description: "Arguments to pass to the command",
+              },
+              env: {
+                type: "object",
+                additionalProperties: { type: "string" },
+                description: "Environment variables for the MCP server",
+              },
+            },
+            required: ["command"],
+          },
+        },
+        agents: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            properties: {
+              command: {
+                type: "string",
+                minLength: 1,
+              },
+              args: {
+                type: "array",
+                items: { type: "string" },
+              },
+            },
+            required: ["command"],
+          },
+        },
+      },
+    });
+  });
+});