@duckmind/dm-windows-x64 0.63.4 → 0.63.9

package/extensions/dm-mcp-adapter/mcp-trace.js

@@ -0,0 +1,215 @@
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { Buffer } from "node:buffer";
+import { dirname, isAbsolute, resolve } from "node:path";
+export const MCP_TRACE_SCHEMA_VERSION = 1;
+export const DEFAULT_MCP_TRACE_MAX_BYTES = 256 * 1024;
+export const DEFAULT_MCP_TRACE_MAX_EVENTS = 1e4;
+function boundedPositiveInteger(value, fallback) {
+  if (!Number.isFinite(value) || value === undefined || value <= 0)
+    return fallback;
+  return Math.floor(value);
+}
+export function redactTraceText(value, maxLength = 160) {
+  if (/\b(?:token|secret|password|passwd|api[_-]?key|authorization|cookie)\b/i.test(value)) {
+    return "[REDACTED]";
+  }
+  let redacted = value.replace(/\b[a-z][a-z\d+.-]*:\/\/[^\s"'<>]+/gi, "[REDACTED_URL]").replace(/\b(?:bearer|basic)\s+[A-Za-z0-9._~+/=-]+/gi, "[REDACTED_AUTH]").replace(/\b(?:token|secret|password|passwd|api[_-]?key|authorization|cookie)\s*[:=]\s*[^\s,;]+/gi, "$1=[REDACTED]");
+  if (redacted.length > maxLength)
+    redacted = `${redacted.slice(0, maxLength - 1)}…`;
+  return redacted;
+}
+function messageKind(message) {
+  if ("method" in message)
+    return "id" in message ? "request" : "notification";
+  return "response";
+}
+function traceId(value) {
+  if (value === null)
+    return null;
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string")
+    return "[REDACTED_ID]";
+  return;
+}
+function messageBytes(message) {
+  try {
+    return Buffer.byteLength(JSON.stringify(message), "utf8");
+  } catch {
+    return;
+  }
+}
+export function createMcpTraceEvent(direction, server, transport, message, status, options) {
+  const kind = messageKind(message);
+  const bytes = messageBytes(message);
+  const event = {
+    version: MCP_TRACE_SCHEMA_VERSION,
+    timestamp: new Date().toISOString(),
+    direction,
+    server: redactTraceText(server, 120),
+    transport,
+    kind,
+    status,
+    ...bytes !== undefined ? { bytes } : {}
+  };
+  if ("method" in message)
+    event.method = redactTraceText(message.method, 120);
+  if ("id" in message)
+    event.id = traceId(message.id) ?? null;
+  const relatedRequestId = traceId(options?.relatedRequestId);
+  if (relatedRequestId !== undefined && relatedRequestId !== null)
+    event.relatedRequestId = relatedRequestId;
+  if ("error" in message && message.error && typeof message.error.code === "number") {
+    event.errorCode = message.error.code;
+  }
+  if (options?.durationMs !== undefined && Number.isFinite(options.durationMs)) {
+    event.durationMs = Math.max(0, Math.round(options.durationMs * 100) / 100);
+  }
+  return event;
+}
+
+export class McpTraceWriter {
+  options;
+  maxBytes;
+  maxEvents;
+  append;
+  resetFile;
+  makeDirectory;
+  bytesWritten = 0;
+  eventsWritten = 0;
+  queue = Promise.resolve();
+  disabled = false;
+  initializationFailed = false;
+  fileReady;
+  constructor(options) {
+    this.options = options;
+    this.maxBytes = boundedPositiveInteger(options.maxBytes, DEFAULT_MCP_TRACE_MAX_BYTES);
+    this.maxEvents = boundedPositiveInteger(options.maxEvents, DEFAULT_MCP_TRACE_MAX_EVENTS);
+    this.append = options.appendFile ?? (async (path, data, appendOptions) => {
+      await appendFile(path, data, appendOptions);
+    });
+    this.resetFile = options.writeFile ?? (async (path, data, writeOptions) => {
+      await writeFile(path, data, writeOptions);
+    });
+    this.makeDirectory = options.mkdir ?? (async (path) => {
+      await mkdir(path, { recursive: true });
+      return;
+    });
+    this.fileReady = this.makeDirectory(dirname(this.options.filePath), { recursive: true }).then(() => this.resetFile(this.options.filePath, "", { encoding: "utf8" })).catch(() => {
+      this.initializationFailed = true;
+      this.disabled = true;
+    });
+  }
+  get filePath() {
+    return this.options.filePath;
+  }
+  get isDisabled() {
+    return this.disabled;
+  }
+  get stats() {
+    return { bytes: this.bytesWritten, events: this.eventsWritten };
+  }
+  write(event) {
+    if (this.disabled || this.eventsWritten >= this.maxEvents)
+      return;
+    let line;
+    try {
+      line = `${JSON.stringify(event)}
+`;
+    } catch {
+      this.disabled = true;
+      return;
+    }
+    const bytes = Buffer.byteLength(line, "utf8");
+    if (bytes > this.maxBytes - this.bytesWritten) {
+      this.disabled = true;
+      return;
+    }
+    this.bytesWritten += bytes;
+    this.eventsWritten += 1;
+    this.queue = this.queue.then(async () => {
+      await this.fileReady;
+      if (this.initializationFailed)
+        return;
+      await this.append(this.options.filePath, line, { encoding: "utf8" });
+    }).catch(() => {
+      this.disabled = true;
+    });
+  }
+  async flush() {
+    await this.fileReady;
+    await this.queue;
+  }
+}
+export function createMcpTraceWriter(sessionCwd, settings = {}, randomSuffix = Math.random().toString(36).slice(2, 10)) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const configuredPath = settings.file;
+  const filePath = configuredPath ? isAbsolute(configuredPath) ? configuredPath : resolve(sessionCwd ?? process.cwd(), configuredPath) : resolve(sessionCwd ?? process.cwd(), ".dm", "mcp-traces", `mcp-${timestamp}-${randomSuffix}.jsonl`);
+  return new McpTraceWriter({
+    filePath,
+    ...settings.maxBytes !== undefined ? { maxBytes: settings.maxBytes } : {},
+    ...settings.maxEvents !== undefined ? { maxEvents: settings.maxEvents } : {}
+  });
+}
+export function isMcpTraceEnabled(definition, settings) {
+  return definition.trace ?? settings?.enabled === true;
+}
+export function wrapTransportWithMcpTrace(transport, server, transportKind, observer) {
+  let messageHandler = transport.onmessage;
+  let tracedMessageHandler;
+  const originalSend = transport.send;
+  const record = (event) => {
+    try {
+      observer.record(event);
+    } catch {}
+  };
+  try {
+    Object.defineProperty(transport, "onmessage", {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return tracedMessageHandler;
+      },
+      set(handler) {
+        messageHandler = handler;
+        tracedMessageHandler = handler ? (message, extra) => {
+          record(createMcpTraceEvent("inbound", server, transportKind, message, "received"));
+          handler(message, extra);
+        } : undefined;
+      }
+    });
+    transport.onmessage = messageHandler;
+  } catch {}
+  transport.send = async (message, options) => {
+    const started = performance.now();
+    const messages = Array.isArray(message) ? message : [message];
+    try {
+      await originalSend.call(transport, message, options);
+      for (const item of messages) {
+        record(createMcpTraceEvent("outbound", server, transportKind, item, "sent", {
+          durationMs: performance.now() - started
+        }));
+      }
+    } catch (error) {
+      for (const item of messages) {
+        record(createMcpTraceEvent("outbound", server, transportKind, item, "error", {
+          durationMs: performance.now() - started
+        }));
+      }
+      throw error;
+    }
+  };
+  return transport;
+}
+export function traceTransportKind(definition, transport) {
+  if (definition.command)
+    return "stdio";
+  if (definition.socket)
+    return "unix-socket";
+  const constructorName = transport.constructor?.name.toLowerCase() ?? "";
+  if (constructorName.includes("sse"))
+    return "sse";
+  if (constructorName.includes("streamable"))
+    return "streamable-http";
+  return definition.url ? "streamable-http" : "unknown";
+}

package/extensions/dm-mcp-adapter/metadata-cache.js

@@ -0,0 +1,292 @@
+import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { getAgentPath } from "./agent-dir.js";
+import { createHash } from "node:crypto";
+import { getToolUiResourceUri } from "./ui-app-bridge-helpers.js";
+import { createToolSelectorCandidateIndex, formatPromptCommandName, formatToolName, getToolNameCandidates, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
+import { resourceNameToToolName } from "./resource-tools.js";
+import {
+  extractToolUiStreamMode,
+  interpolateEnvRecord,
+  interpolateEnvVars,
+  resolveBearerToken,
+  resolveConfigPath,
+  resolveServerUrl
+} from "./utils.js";
+import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.js";
+const CACHE_VERSION = 1;
+const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+export function getMetadataCachePath() {
+  return getAgentPath("mcp-cache.json");
+}
+export function loadMetadataCache() {
+  const cachePath = getMetadataCachePath();
+  if (!existsSync(cachePath))
+    return null;
+  try {
+    const raw = JSON.parse(readFileSync(cachePath, "utf-8"));
+    if (!raw || typeof raw !== "object")
+      return null;
+    if (raw.version !== CACHE_VERSION)
+      return null;
+    if (!raw.servers || typeof raw.servers !== "object")
+      return null;
+    return raw;
+  } catch {
+    return null;
+  }
+}
+export function saveMetadataCache(cache) {
+  const cachePath = getMetadataCachePath();
+  const dir = dirname(cachePath);
+  mkdirSync(dir, { recursive: true });
+  let merged = { version: CACHE_VERSION, servers: {} };
+  try {
+    if (existsSync(cachePath)) {
+      const existing = JSON.parse(readFileSync(cachePath, "utf-8"));
+      if (existing && existing.version === CACHE_VERSION && existing.servers) {
+        merged.servers = { ...existing.servers };
+      }
+    }
+  } catch {}
+  merged.version = CACHE_VERSION;
+  merged.servers = { ...merged.servers, ...cache.servers };
+  const tmpPath = `${cachePath}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, JSON.stringify(merged), "utf-8");
+  renameSync(tmpPath, cachePath);
+}
+export function computeServerHash(definition, environment = process.env) {
+  const identity = {
+    command: definition.command,
+    args: definition.args,
+    socket: resolveConfigPath(definition.socket, environment),
+    env: interpolateEnvRecord(definition.env, environment),
+    cwd: resolveConfigPath(definition.cwd, environment),
+    url: resolveServerUrl(definition, environment),
+    headers: interpolateEnvRecord(definition.headers, environment),
+    requestHeadersCommand: definition.requestHeadersCommand ? {
+      command: interpolateEnvVars(definition.requestHeadersCommand.command, environment),
+      args: definition.requestHeadersCommand.args?.map((argument) => interpolateEnvVars(argument, environment)),
+      env: interpolateEnvRecord(definition.requestHeadersCommand.env, environment),
+      timeoutMs: definition.requestHeadersCommand.timeoutMs
+    } : undefined,
+    auth: definition.auth,
+    protocolVersion: definition.protocolVersion,
+    bearerToken: resolveBearerToken(definition, environment),
+    bearerTokenEnv: definition.bearerTokenEnv,
+    exposeResources: definition.exposeResources,
+    includeTools: definition.includeTools,
+    excludeTools: definition.excludeTools
+  };
+  const normalized = stableStringify(identity);
+  return createHash("sha256").update(normalized).digest("hex");
+}
+export function isServerCacheValid(entry, definition, maxAgeMs = CACHE_MAX_AGE_MS, environment = process.env) {
+  let configHash;
+  try {
+    configHash = computeServerHash(definition, environment);
+  } catch {
+    return false;
+  }
+  if (!entry || entry.configHash !== configHash)
+    return false;
+  if (!entry.cachedAt || typeof entry.cachedAt !== "number")
+    return false;
+  const declaredTtlMs = entry.ttlMs;
+  if (typeof declaredTtlMs === "number" && Number.isSafeInteger(declaredTtlMs) && declaredTtlMs >= 0) {
+    if (declaredTtlMs === 0)
+      return false;
+    const ageMs = Date.now() - entry.cachedAt;
+    const effectiveMaxAge = maxAgeMs > 0 ? Math.min(maxAgeMs, declaredTtlMs) : declaredTtlMs;
+    return ageMs < effectiveMaxAge;
+  }
+  if (maxAgeMs > 0 && Date.now() - entry.cachedAt > maxAgeMs)
+    return false;
+  return true;
+}
+export function parseDirectToolSelectors(selectors) {
+  const servers = new Set;
+  const tools = new Map;
+  for (let selector of selectors) {
+    selector = selector.replace(/\/+$/, "");
+    if (selector.includes("/")) {
+      const [server, tool] = selector.split("/", 2);
+      if (server && tool) {
+        const serverTools = tools.get(server) ?? new Set;
+        serverTools.add(tool);
+        tools.set(server, serverTools);
+      } else if (server) {
+        servers.add(server);
+      }
+    } else if (selector) {
+      servers.add(selector);
+    }
+  }
+  return { servers, tools };
+}
+export function getMissingConfiguredDirectToolServers(config, cache, envOverride) {
+  const missing = [];
+  const globalDirect = config.settings?.directTools;
+  const envSelection = envOverride ? parseDirectToolSelectors(envOverride) : null;
+  for (const [serverName, definition] of Object.entries(config.mcpServers)) {
+    if (isServerDisabled(definition))
+      continue;
+    const hasDirectTools = envSelection ? envSelection.servers.has(serverName) || envSelection.tools.has(serverName) : definition.directTools !== undefined ? !!definition.directTools : !!globalDirect;
+    if (!hasDirectTools)
+      continue;
+    const serverCache = cache?.servers?.[serverName];
+    if (!serverCache || !isServerCacheValid(serverCache, definition)) {
+      missing.push(serverName);
+    }
+  }
+  return missing;
+}
+export function reconstructToolMetadata(serverName, entry, prefix, definition, configuredServers, cache, sharedSelectorCandidateIndex) {
+  const metadata = [];
+  const seenNames = new Set;
+  const effectivePrefix = resolveToolPrefix(definition, prefix);
+  const hasToolFilters = Array.isArray(definition.includeTools) && definition.includeTools.length > 0 || Array.isArray(definition.excludeTools) && definition.excludeTools.length > 0;
+  const selectorCandidateIndex = hasToolFilters ? sharedSelectorCandidateIndex ?? (configuredServers && cache ? createCachedToolSelectorCandidateIndex(configuredServers, cache, prefix) : undefined) : undefined;
+  for (const tool of entry.tools ?? []) {
+    if (!tool?.name)
+      continue;
+    if (!isUiToolVisibleToModel(tool.uiVisibility)) {
+      continue;
+    }
+    if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)) {
+      continue;
+    }
+    const name = formatToolName(tool.name, serverName, effectivePrefix);
+    if (seenNames.has(name)) {
+      continue;
+    }
+    seenNames.add(name);
+    metadata.push({
+      name,
+      originalName: tool.name,
+      description: tool.description ?? "",
+      ...tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {},
+      ...tool.uiResourceUri !== undefined ? { uiResourceUri: tool.uiResourceUri } : {},
+      ...tool.uiVisibility !== undefined ? { uiVisibility: tool.uiVisibility } : {},
+      ...tool.uiStreamMode !== undefined ? { uiStreamMode: tool.uiStreamMode } : {}
+    });
+  }
+  if (definition.exposeResources !== false) {
+    for (const resource of entry.resources ?? []) {
+      if (!resource?.name || !resource?.uri)
+        continue;
+      const baseName = `read_${resourceNameToToolName(resource.name)}`;
+      if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)) {
+        continue;
+      }
+      const name = formatToolName(baseName, serverName, effectivePrefix);
+      if (seenNames.has(name)) {
+        continue;
+      }
+      seenNames.add(name);
+      metadata.push({
+        name,
+        originalName: baseName,
+        description: resource.description ?? `Read resource: ${resource.uri}`,
+        resourceUri: resource.uri
+      });
+    }
+  }
+  return metadata;
+}
+export function createCachedToolSelectorCandidateIndex(configuredServers, cache, prefix) {
+  const candidates = new Set;
+  for (const [serverName, definition] of Object.entries(configuredServers)) {
+    const entry = cache.servers[serverName];
+    if (!entry || !isServerCacheValid(entry, definition) || isServerDisabled(definition))
+      continue;
+    const effectivePrefix = resolveToolPrefix(definition, prefix);
+    for (const tool of entry.tools ?? []) {
+      if (!isUiToolVisibleToModel(tool.uiVisibility))
+        continue;
+      for (const candidate of getToolNameCandidates(tool.name, serverName, effectivePrefix, false))
+        candidates.add(candidate);
+    }
+    if (definition.exposeResources !== false) {
+      for (const resource of entry.resources ?? []) {
+        const baseName = `read_${resourceNameToToolName(resource.name)}`;
+        for (const candidate of getToolNameCandidates(baseName, serverName, effectivePrefix, false))
+          candidates.add(candidate);
+      }
+    }
+  }
+  return createToolSelectorCandidateIndex(candidates);
+}
+export function serializeTools(tools) {
+  return tools.filter((t) => t?.name).map((t) => {
+    const uiResourceUri = tryGetToolUiResourceUri(t);
+    const uiVisibility = extractUiToolVisibility(t._meta);
+    const uiStreamMode = extractToolUiStreamMode(t._meta);
+    return {
+      name: t.name,
+      ...t.description !== undefined ? { description: t.description } : {},
+      ...t.inputSchema !== undefined ? { inputSchema: t.inputSchema } : {},
+      ...uiResourceUri !== undefined ? { uiResourceUri } : {},
+      ...uiVisibility !== undefined ? { uiVisibility } : {},
+      ...uiStreamMode !== undefined ? { uiStreamMode } : {}
+    };
+  });
+}
+export function serializeResources(resources) {
+  return resources.filter((r) => r?.name && r?.uri).map((r) => ({
+    uri: r.uri,
+    name: r.name,
+    ...r.description !== undefined ? { description: r.description } : {}
+  }));
+}
+export function serializePrompts(prompts) {
+  return (prompts ?? []).filter((prompt) => prompt?.name).map((prompt) => ({
+    name: prompt.name,
+    ...prompt.title !== undefined ? { title: prompt.title } : {},
+    ...prompt.description !== undefined ? { description: prompt.description } : {},
+    ...Array.isArray(prompt.arguments) ? {
+      arguments: prompt.arguments.filter((argument) => argument?.name).map((argument) => ({
+        name: argument.name,
+        ...argument.description !== undefined ? { description: argument.description } : {},
+        ...argument.required !== undefined ? { required: argument.required } : {}
+      }))
+    } : {}
+  }));
+}
+export function reconstructPromptMetadata(serverName, prompts, prefix, definition) {
+  const effectivePrefix = resolveToolPrefix(definition, prefix);
+  return (prompts ?? []).filter((prompt) => prompt?.name).map((prompt) => {
+    const args = Array.isArray(prompt.arguments) ? prompt.arguments.filter((argument) => argument?.name).map((argument) => ({
+      name: argument.name,
+      ...argument.description !== undefined ? { description: argument.description } : {},
+      ...argument.required !== undefined ? { required: argument.required } : {}
+    })) : [];
+    return {
+      serverName,
+      originalName: prompt.name,
+      commandName: formatPromptCommandName(prompt.name, serverName, effectivePrefix),
+      ...prompt.title !== undefined ? { title: prompt.title } : {},
+      description: prompt.description ?? "",
+      arguments: args
+    };
+  });
+}
+function stableStringify(value) {
+  if (value === null || value === undefined || typeof value !== "object") {
+    const serialized = JSON.stringify(value);
+    return serialized === undefined ? "undefined" : serialized;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((v) => stableStringify(v)).join(",")}]`;
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
+function tryGetToolUiResourceUri(tool) {
+  try {
+    return getToolUiResourceUri({ _meta: tool._meta });
+  } catch {
+    return;
+  }
+}

package/extensions/dm-mcp-adapter/namespace-tools.js

@@ -0,0 +1,155 @@
+import { Type } from "typebox";
+import { isServerDisabled } from "./types.js";
+import { isServerCacheValid } from "./metadata-cache.js";
+import { executeCall } from "./proxy-modes.js";
+import { createMcpProxyToolCallRenderer, createMcpToolResultRenderer, resolveMcpToolRenderOptions } from "./tool-result-renderer.js";
+export { namespaceProxyName } from "./mcp-references.js";
+import { hasCallableCachedTargets, isMcpServerDirectlyRegistered, namespaceProxyName } from "./mcp-references.js";
+function namespaceProxyCandidate(config, cache, envOverride, existingDirectNames, serverName) {
+  const definition = config.mcpServers[serverName];
+  if (!definition || isServerDisabled(definition))
+    return null;
+  if (isMcpServerDirectlyRegistered(definition, config.settings, serverName, envOverride))
+    return null;
+  const entry = cache.servers?.[serverName];
+  if (!entry || !isServerCacheValid(entry, definition) || !hasCallableCachedTargets(entry, definition))
+    return null;
+  const toolName = namespaceProxyName(serverName);
+  if (existingDirectNames.has(toolName))
+    return null;
+  return {
+    serverName,
+    toolName,
+    description: `Namespace-proxy for MCP server "${serverName}". ` + `Forwards \`{tool, args}\` through the adapter's executeCall, so it inherits ` + `the same auth / lifecycle / output-guard rules as the \`mcp\` proxy.`
+  };
+}
+function filterCollidingNamespaceProxyTools(candidates) {
+  const names = new Map;
+  for (const spec of candidates) {
+    const colliding = names.get(spec.toolName) ?? [];
+    colliding.push(spec);
+    names.set(spec.toolName, colliding);
+  }
+  return candidates.filter((spec) => {
+    const colliding = names.get(spec.toolName);
+    if (colliding.length === 1)
+      return true;
+    if (colliding[0] === spec) {
+      console.warn(`MCP: skipping namespace proxy "${spec.toolName}" because servers ${colliding.map(({ serverName }) => `"${serverName}"`).sort().join(", ")} normalize to the same name`);
+    }
+    return false;
+  });
+}
+function resolveNamespaceProxyTools(config, cache, envOverride, existingDirectNames, unavailableServers) {
+  if (!config || !cache)
+    return [];
+  return filterCollidingNamespaceProxyTools(Object.keys(config.mcpServers).map((serverName) => namespaceProxyCandidate(config, cache, envOverride, existingDirectNames, serverName)).filter((spec) => spec !== null)).filter((spec) => !unavailableServers.has(spec.serverName));
+}
+function namespaceExecute(getState, getInitPromise, serverName, getPiTools) {
+  return async (_toolCallId, params, signal) => {
+    if (typeof params.tool !== "string" || params.tool.length === 0) {
+      return {
+        content: [{ type: "text", text: `mcp__${serverName} requires a \`tool\` parameter naming the underlying MCP tool.` }],
+        details: { error: "missing_tool", server: serverName }
+      };
+    }
+    let state = getState();
+    if (!state) {
+      const initPromise = getInitPromise();
+      if (initPromise) {
+        try {
+          state = await initPromise;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return {
+            content: [{ type: "text", text: `MCP initialization failed for ${serverName}: ${message}` }],
+            details: { error: "init_failed", server: serverName, message }
+          };
+        }
+      }
+    }
+    if (!state) {
+      return {
+        content: [{ type: "text", text: `MCP not initialized for ${serverName}.` }],
+        details: { error: "not_initialized", server: serverName }
+      };
+    }
+    return executeCall(state, params.tool, params.args ?? {}, serverName, getPiTools, signal, "proxy");
+  };
+}
+const parameters = Type.Object({
+  tool: Type.String({ description: "Underlying MCP tool name to call on this server." }),
+  args: Type.Optional(Type.Object({}, {
+    additionalProperties: true,
+    description: "Arguments for the underlying tool. The exact shape depends on the tool being called; use mcp({ describe: 'server/tool' }) to inspect."
+  }))
+});
+function createNamespaceRenderCall(renderOptions, serverName) {
+  const renderCall = createMcpProxyToolCallRenderer(renderOptions);
+  return (args, theme, context) => renderCall({
+    ...args.tool !== undefined ? { tool: args.tool } : {},
+    ...args.args !== undefined ? { args: args.args } : {},
+    server: serverName
+  }, theme, context);
+}
+function registerNamespaceProxyTool(input, spec, renderOptions, renderShell, renderResult) {
+  input.pi.registerTool({
+    name: spec.toolName,
+    label: `MCP: ${spec.serverName}`,
+    description: spec.description,
+    promptSnippet: `MCP namespace proxy for ${spec.serverName}`,
+    parameters,
+    renderShell,
+    renderCall: createNamespaceRenderCall(renderOptions, spec.serverName),
+    renderResult,
+    execute: namespaceExecute(input.getState, input.getInitPromise, spec.serverName, input.getPiTools)
+  });
+}
+function getActiveToolsForStaleCleanup(pi, staleNames) {
+  if (staleNames.length === 0)
+    return;
+  try {
+    return pi.getActiveTools?.();
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Action methods cannot be called during extension loading"))
+      return;
+    throw error;
+  }
+}
+function deactivateStaleNamespaceTools(input, nextNames) {
+  const activeDirectNames = input.activeDirectNames ?? new Set;
+  const staleNames = [...input.existingNamespaceNames].filter((name) => !nextNames.has(name) && !activeDirectNames.has(name));
+  const deactivated = [];
+  const unregisterTool = input.pi.unregisterTool;
+  for (const stale of staleNames) {
+    if (unregisterTool?.(stale))
+      deactivated.push(stale);
+  }
+  const activeTools = getActiveToolsForStaleCleanup(input.pi, staleNames);
+  if (!activeTools)
+    return deactivated;
+  const stale = new Set(staleNames);
+  const nextActiveTools = activeTools.filter((name) => !stale.has(name));
+  if (nextActiveTools.length === activeTools.length)
+    return deactivated;
+  input.pi.setActiveTools(nextActiveTools);
+  for (const name of staleNames) {
+    if (!deactivated.includes(name))
+      deactivated.push(name);
+  }
+  return deactivated;
+}
+export function syncNamespaceProxyTools(input) {
+  const specs = resolveNamespaceProxyTools(input.config, input.cache, input.envOverride, input.existingDirectNames, input.unavailableServers ?? new Set);
+  const nextNames = new Set(specs.map((s) => s.toolName));
+  const result = { specs, added: [], updated: [], deactivated: [] };
+  const renderOptions = input.renderOptions ?? resolveMcpToolRenderOptions();
+  const renderShell = input.renderShell ?? (renderOptions.resultRendering === "compact" ? "self" : "default");
+  const renderResult = input.renderResult ?? createMcpToolResultRenderer(renderOptions);
+  for (const spec of specs) {
+    registerNamespaceProxyTool(input, spec, renderOptions, renderShell, renderResult);
+    (input.existingNamespaceNames.has(spec.toolName) ? result.updated : result.added).push(spec.toolName);
+  }
+  result.deactivated.push(...deactivateStaleNamespaceTools(input, nextNames));
+  return result;
+}