@duckmind/dm-windows-x64 0.63.4 → 0.63.9

package/extensions/dm-mcp-adapter/consent-manager.js

@@ -0,0 +1,60 @@
+import { ConsentError } from "./errors.js";
+import { logger } from "./logger.js";
+
+export class ConsentManager {
+  mode;
+  approvedServers = new Set;
+  deniedServers = new Set;
+  log = logger.child({ component: "ConsentManager" });
+  constructor(mode = "once-per-server") {
+    this.mode = mode;
+    this.log.debug("Initialized", { mode });
+  }
+  requiresPrompt(serverName) {
+    if (this.mode === "never")
+      return false;
+    if (this.deniedServers.has(serverName))
+      return true;
+    if (this.mode === "always")
+      return true;
+    return !this.approvedServers.has(serverName);
+  }
+  shouldCacheConsent() {
+    return this.mode !== "always";
+  }
+  registerDecision(serverName, approved) {
+    this.deniedServers.delete(serverName);
+    this.approvedServers.delete(serverName);
+    if (approved) {
+      this.approvedServers.add(serverName);
+      this.log.debug("Consent granted", { server: serverName });
+      return;
+    }
+    this.deniedServers.add(serverName);
+    this.log.debug("Consent denied", { server: serverName });
+  }
+  ensureApproved(serverName) {
+    if (this.mode === "never")
+      return;
+    if (this.deniedServers.has(serverName)) {
+      throw new ConsentError(serverName, { denied: true });
+    }
+    if (!this.approvedServers.has(serverName)) {
+      throw new ConsentError(serverName, { requiresApproval: true });
+    }
+    if (this.mode === "always") {
+      this.approvedServers.delete(serverName);
+    }
+  }
+  clear(serverName) {
+    if (serverName) {
+      this.approvedServers.delete(serverName);
+      this.deniedServers.delete(serverName);
+      this.log.debug("Cleared consent for server", { server: serverName });
+      return;
+    }
+    this.approvedServers.clear();
+    this.deniedServers.clear();
+    this.log.debug("Cleared all consent records");
+  }
+}

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

@@ -0,0 +1,544 @@
+import { UrlElicitationRequiredError } from "@modelcontextprotocol/client";
+import { lazyConnect, getFailureAgeSeconds, clearFailure } from "./init.js";
+import { abortable, throwIfAborted } from "./abort.js";
+import { isServerCacheValid, parseDirectToolSelectors } from "./metadata-cache.js";
+export { getMissingConfiguredDirectToolServers } from "./metadata-cache.js";
+import { formatSchema } from "./tool-metadata.js";
+import { resolveMcpResultContent, transformMcpContent, transformMcpResourceContents } from "./tool-registrar.js";
+import { guardMcpOutput, guardedMcpDetails, resolveMcpOutputGuardOptions } from "./mcp-output-guard.js";
+import { maybeStartUiSession, summarizeUiSessionResult } from "./ui-session.js";
+import { createToolSelectorCandidateIndex, formatToolName, getToolNameCandidates, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
+import { isUiToolVisibleToModel } from "./ui-tool-visibility.js";
+import { resourceNameToToolName } from "./resource-tools.js";
+import { authenticate, supportsOAuth } from "./mcp-auth-flow.js";
+import { formatAuthRequiredMessage, normalizeToolArguments, resolveServerUrl } from "./utils.js";
+import { SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
+import { combineAbortSignals, isAbortError } from "./runtime-owner.js";
+import { ensureToolCallApproved } from "./tool-approval.js";
+import { Check, Errors } from "typebox/value";
+import { getInputRequiredNeedsUiDetails } from "./errors.js";
+const BUILTIN_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls", "mcp"]);
+export const DIRECT_TOOLS_ADVISORY_THRESHOLD = 75;
+export function prepareDirectToolArguments(inputSchema, args) {
+  if (!inputSchema || typeof inputSchema !== "object" || Array.isArray(inputSchema))
+    return args;
+  const schema = inputSchema;
+  if (schema.type !== "object")
+    return args;
+  const input = args && typeof args === "object" && !Array.isArray(args) ? args : null;
+  const properties = schema.properties;
+  let prepared;
+  if (input && properties && typeof properties === "object" && !Array.isArray(properties)) {
+    for (const [name, propertySchema] of Object.entries(properties)) {
+      if (!Object.hasOwn(input, name) || typeof input[name] !== "string" || !propertySchema || typeof propertySchema !== "object" || Array.isArray(propertySchema))
+        continue;
+      const expectedType = propertySchema.type;
+      if (expectedType !== "object" && expectedType !== "array")
+        continue;
+      try {
+        const parsed = JSON.parse(input[name]);
+        const matches = expectedType === "array" ? Array.isArray(parsed) : parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
+        if (matches) {
+          prepared ??= { ...input };
+          prepared[name] = parsed;
+        }
+      } catch {}
+    }
+  }
+  const candidate = prepared ?? args;
+  if (!Check(inputSchema, candidate)) {
+    const errors = Errors(inputSchema, candidate);
+    const issues = errors.slice(0, 8).map((error) => ({
+      instancePath: error.instancePath || "/",
+      keyword: error.keyword,
+      message: error.message
+    }));
+    throw new TypeError(`MCP direct tool arguments do not match the advertised input schema: ${JSON.stringify({
+      issues,
+      total: errors.length,
+      truncated: errors.length > issues.length
+    })}`);
+  }
+  return candidate;
+}
+function getDirectAuthRequiredMessage(state, serverName, defaultMessage = `MCP server "${serverName}" requires OAuth authentication. Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`) {
+  return formatAuthRequiredMessage(state.config, serverName, defaultMessage);
+}
+function getDirectAuthFailedMessage(state, serverName, message) {
+  const customGuidance = state.config.settings?.authRequiredMessage;
+  if (customGuidance) {
+    return `OAuth authentication failed for "${serverName}": ${message}. ${getDirectAuthRequiredMessage(state, serverName)}`;
+  }
+  return `OAuth authentication failed for "${serverName}": ${message}. Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`;
+}
+async function attemptDirectAutoAuth(state, serverName, signal) {
+  if (state.config.settings?.autoAuth !== true) {
+    return { status: "skipped" };
+  }
+  const definition = state.config.mcpServers[serverName];
+  if (!definition || isServerDisabled(definition) || !supportsOAuth(definition)) {
+    return { status: "skipped" };
+  }
+  let serverUrl;
+  try {
+    serverUrl = resolveServerUrl(definition);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { status: "failed", message: getDirectAuthFailedMessage(state, serverName, message) };
+  }
+  if (!serverUrl) {
+    return { status: "skipped" };
+  }
+  const grantType = definition.oauth ? definition.oauth.grantType ?? "authorization_code" : "authorization_code";
+  if (!state.ui && grantType !== "client_credentials") {
+    return {
+      status: "failed",
+      message: getDirectAuthRequiredMessage(state, serverName, `MCP server "${serverName}" requires OAuth authentication. Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`)
+    };
+  }
+  try {
+    if (state.authStorageOptions) {
+      await authenticate(serverName, serverUrl, definition, signal ? { authStorageOptions: state.authStorageOptions, signal, runtime: state.oauthRuntime } : { authStorageOptions: state.authStorageOptions, runtime: state.oauthRuntime });
+    } else {
+      await authenticate(serverName, serverUrl, definition, {
+        ...signal ? { signal } : {},
+        runtime: state.oauthRuntime
+      });
+    }
+    return { status: "success" };
+  } catch (error) {
+    if (isAbortError(error, signal))
+      throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      status: "failed",
+      message: getDirectAuthFailedMessage(state, serverName, message)
+    };
+  }
+}
+export function resolveDirectTools(config, cache, prefix, envOverride, unavailableServers = new Set, reservedNames) {
+  const specs = [];
+  if (!cache)
+    return specs;
+  const seenNames = new Set;
+  const envSelection = envOverride ? parseDirectToolSelectors(envOverride) : null;
+  const globalDirect = config.settings?.directTools;
+  for (const [serverName, definition] of Object.entries(config.mcpServers)) {
+    if (isServerDisabled(definition))
+      continue;
+    const serverCache = cache.servers[serverName];
+    if (!serverCache || !isServerCacheValid(serverCache, definition))
+      continue;
+    let toolFilter = false;
+    if (envSelection) {
+      if (envSelection.servers.has(serverName)) {
+        toolFilter = true;
+      } else if (envSelection.tools.has(serverName)) {
+        toolFilter = [...envSelection.tools.get(serverName)];
+      }
+    } else {
+      if (definition.directTools !== undefined) {
+        toolFilter = definition.directTools;
+      } else if (globalDirect) {
+        toolFilter = globalDirect;
+      }
+    }
+    if (!toolFilter)
+      continue;
+    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 ? (() => {
+      const candidates = new Set;
+      for (const [otherServerName, otherDefinition] of Object.entries(config.mcpServers)) {
+        const otherCache = cache.servers[otherServerName];
+        if (!otherCache || !isServerCacheValid(otherCache, otherDefinition) || isServerDisabled(otherDefinition))
+          continue;
+        const otherPrefix = resolveToolPrefix(otherDefinition, prefix);
+        for (const otherTool of otherCache.tools ?? []) {
+          if (!isUiToolVisibleToModel(otherTool.uiVisibility))
+            continue;
+          for (const candidate of getToolNameCandidates(otherTool.name, otherServerName, otherPrefix, false))
+            candidates.add(candidate);
+        }
+        if (otherDefinition.exposeResources !== false) {
+          for (const resource of otherCache.resources ?? []) {
+            const baseName = `read_${resourceNameToToolName(resource.name)}`;
+            for (const candidate of getToolNameCandidates(baseName, otherServerName, otherPrefix, false))
+              candidates.add(candidate);
+          }
+        }
+      }
+      return createToolSelectorCandidateIndex(candidates);
+    })() : undefined;
+    for (const tool of serverCache.tools ?? []) {
+      if (!isUiToolVisibleToModel(tool.uiVisibility))
+        continue;
+      if (toolFilter !== true && !toolFilter.includes(tool.name))
+        continue;
+      if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex))
+        continue;
+      const prefixedName = formatToolName(tool.name, serverName, effectivePrefix);
+      if (BUILTIN_NAMES.has(prefixedName)) {
+        console.warn(`MCP: skipping direct tool "${prefixedName}" (collides with builtin)`);
+        continue;
+      }
+      if (seenNames.has(prefixedName)) {
+        console.warn(`MCP: skipping duplicate direct tool "${prefixedName}" from "${serverName}"`);
+        continue;
+      }
+      seenNames.add(prefixedName);
+      specs.push({
+        serverName,
+        originalName: tool.name,
+        prefixedName,
+        description: tool.description ?? "",
+        ...tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {},
+        ...tool.uiResourceUri !== undefined ? { uiResourceUri: tool.uiResourceUri } : {},
+        ...tool.uiStreamMode !== undefined ? { uiStreamMode: tool.uiStreamMode } : {}
+      });
+    }
+    if (definition.exposeResources !== false) {
+      for (const resource of serverCache.resources ?? []) {
+        const baseName = `read_${resourceNameToToolName(resource.name)}`;
+        if (toolFilter !== true && !toolFilter.includes(baseName))
+          continue;
+        if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex))
+          continue;
+        const prefixedName = formatToolName(baseName, serverName, effectivePrefix);
+        if (BUILTIN_NAMES.has(prefixedName)) {
+          console.warn(`MCP: skipping direct resource tool "${prefixedName}" (collides with builtin)`);
+          continue;
+        }
+        if (seenNames.has(prefixedName)) {
+          console.warn(`MCP: skipping duplicate direct resource tool "${prefixedName}" from "${serverName}"`);
+          continue;
+        }
+        seenNames.add(prefixedName);
+        specs.push({
+          serverName,
+          originalName: baseName,
+          prefixedName,
+          description: resource.description ?? `Read resource: ${resource.uri}`,
+          resourceUri: resource.uri
+        });
+      }
+    }
+  }
+  for (const spec of specs)
+    reservedNames?.add(spec.prefixedName);
+  const emittedSpecs = unavailableServers.size === 0 ? specs : specs.filter((spec) => !unavailableServers.has(spec.serverName));
+  if (config.settings?.warnOnLargeDirectTools !== false && emittedSpecs.length >= DIRECT_TOOLS_ADVISORY_THRESHOLD) {
+    console.warn(`MCP: ${emittedSpecs.length} direct tools resolved. Each direct tool adds prompt context; README guidance recommends targeted sets of 5-20 tools and using the proxy or an explicit string[] when 75+ direct tools would be registered. Set settings.warnOnLargeDirectTools to false to hide this advisory.`);
+  }
+  return emittedSpecs;
+}
+export function buildProxyDescription(config) {
+  let desc = `MCP gateway — server status, tool search/describe, auth, and single MCP tool calls. When one request needs several MCP calls with logic between them, use mcpScript. Non-MCP DM tools should be called directly, not through mcp.
+`;
+  const serverNames = Object.keys(config.mcpServers).filter((serverName) => !isServerDisabled(config.mcpServers[serverName]));
+  if (serverNames.length > 0) {
+    desc += `
+Servers: ${serverNames.join(", ")}
+`;
+  }
+  const disabledServers = Object.entries(config.mcpServers).filter(([, definition]) => isServerDisabled(definition)).map(([serverName]) => serverName);
+  if (disabledServers.length > 0) {
+    desc += `
+Disabled servers (enable with /mcp enable <server> and /reload): ${disabledServers.join(", ")}
+`;
+  }
+  desc += `
+Usage:
+`;
+  desc += `  mcp({ })                              → Show server status and tool counts
+`;
+  desc += `  mcp({ server: "name" })               → List tools from server
+`;
+  desc += `  mcp({ search: "query" })              → Search MCP tools by name/description
+`;
+  desc += `  mcp({ describe: "tool_name" })        → Show tool details and parameters
+`;
+  desc += `  mcp({ instructions: "name" })         → Show full server usage instructions
+`;
+  desc += `  mcp({ connect: "server-name" })       → Connect to a server and refresh metadata
+`;
+  desc += `  mcp({ tool: "name", args: { key: "value" } })         → Call a tool (object args; JSON string also accepted)
+`;
+  desc += `  mcp({ action: "ui-messages" })        → Retrieve accumulated messages from completed UI sessions
+`;
+  desc += `  mcp({ action: "auth-start", server: "name" })      → Start manual OAuth and get a browser URL
+`;
+  desc += `  mcp({ action: "auth-complete", server: "name", args: { redirectUrl: "..." } }) → Complete manual OAuth
+`;
+  desc += `
+Mode: action > tool (call) > connect > describe > instructions > search > server (list) > nothing (status)`;
+  return desc;
+}
+export function createDirectToolExecutor(getState, getInitPromise, spec) {
+  return async function execute(_toolCallId, params, signal) {
+    throwIfAborted(signal);
+    let state = getState();
+    const initPromise = getInitPromise();
+    if (!state && initPromise) {
+      try {
+        state = await initPromise;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `MCP initialization failed: ${message}` }],
+          details: { error: "init_failed", message }
+        };
+      }
+    }
+    if (!state) {
+      return {
+        content: [{ type: "text", text: "MCP not initialized" }],
+        details: { error: "not_initialized" }
+      };
+    }
+    const definition = state.config.mcpServers[spec.serverName];
+    if (isServerDisabled(definition)) {
+      const message = `MCP server "${spec.serverName}" is disabled. Run /mcp enable ${spec.serverName} and /reload to enable it.`;
+      return {
+        content: [{ type: "text", text: message }],
+        details: { error: "server_disabled", server: spec.serverName, message }
+      };
+    }
+    const ownedSignal = combineAbortSignals(state.owner?.signal, signal);
+    throwIfAborted(ownedSignal);
+    let connected = await lazyConnect(state, spec.serverName, ownedSignal);
+    let autoAuthAttempted = false;
+    if (!connected && state.manager.getConnection(spec.serverName)?.status === "needs-auth") {
+      autoAuthAttempted = true;
+      const autoAuth = await attemptDirectAutoAuth(state, spec.serverName, ownedSignal);
+      if (autoAuth.status === "failed") {
+        return {
+          content: [{ type: "text", text: autoAuth.message }],
+          details: { error: "auth_required", server: spec.serverName, message: autoAuth.message }
+        };
+      }
+      if (autoAuth.status === "success") {
+        await state.manager.close(spec.serverName);
+        clearFailure(state, spec.serverName);
+        connected = await lazyConnect(state, spec.serverName, ownedSignal);
+      }
+    }
+    if (!connected) {
+      const authConnection = state.manager.getConnection(spec.serverName);
+      if (authConnection?.status === "needs-auth") {
+        const message = getDirectAuthRequiredMessage(state, spec.serverName);
+        return {
+          content: [{ type: "text", text: message }],
+          details: { error: "auth_required", server: spec.serverName, message, autoAuthAttempted }
+        };
+      }
+      const failedAgo = getFailureAgeSeconds(state, spec.serverName);
+      return {
+        content: [{ type: "text", text: `MCP server "${spec.serverName}" not available${failedAgo !== null ? ` (failed ${failedAgo}s ago)` : ""}` }],
+        details: { error: "server_unavailable", server: spec.serverName }
+      };
+    }
+    const connection = state.manager.getConnection(spec.serverName);
+    if (!connection || connection.status !== "connected") {
+      return {
+        content: [{ type: "text", text: `MCP server "${spec.serverName}" not connected` }],
+        details: { error: "not_connected", server: spec.serverName }
+      };
+    }
+    const normalizedParams = spec.resourceUri ? params : normalizeToolArguments(params);
+    const approval = await ensureToolCallApproved(state, spec.serverName, {
+      name: spec.prefixedName,
+      originalName: spec.originalName,
+      description: spec.description,
+      ...spec.inputSchema !== undefined ? { inputSchema: spec.inputSchema } : {},
+      ...spec.resourceUri !== undefined ? { resourceUri: spec.resourceUri } : {},
+      ...spec.uiResourceUri !== undefined ? { uiResourceUri: spec.uiResourceUri } : {},
+      ...spec.uiStreamMode !== undefined ? { uiStreamMode: spec.uiStreamMode } : {}
+    }, normalizedParams, ownedSignal, spec.resourceUri ? "resource" : "direct");
+    if (approval.ok === false) {
+      const denied = approval.reason === "denied";
+      const message = denied ? `The user declined approval to run MCP tool "${spec.originalName}" on server "${spec.serverName}".` : `MCP tool "${spec.originalName}" on server "${spec.serverName}" is approval-gated and requires an interactive session.`;
+      return {
+        content: [{ type: "text", text: message }],
+        details: {
+          error: denied ? "approval_denied" : "approval_required",
+          server: spec.serverName,
+          tool: spec.originalName
+        }
+      };
+    }
+    let uiSession = null;
+    const requestOptions = state.manager.getRequestOptions?.(spec.serverName, ownedSignal) ?? (ownedSignal ? { signal: ownedSignal } : undefined);
+    const outputGuardOptions = resolveMcpOutputGuardOptions(state.config.settings);
+    const recoverAuthConnection = async () => {
+      const current = state.manager.getConnection(spec.serverName);
+      if (current?.status === "connected")
+        return current;
+      if (!autoAuthAttempted) {
+        autoAuthAttempted = true;
+        const autoAuth = await attemptDirectAutoAuth(state, spec.serverName, ownedSignal);
+        if (autoAuth.status === "failed") {
+          throw new SessionRecoveryAuthRequiredError(spec.serverName, autoAuth.message);
+        }
+        if (autoAuth.status === "success") {
+          const afterAuth = state.manager.getConnection(spec.serverName);
+          if (afterAuth?.status === "connected")
+            return afterAuth;
+          if (afterAuth?.status === "needs-auth") {
+            await state.manager.close(spec.serverName);
+          }
+          clearFailure(state, spec.serverName);
+          const reconnected = await lazyConnect(state, spec.serverName, ownedSignal);
+          return reconnected ? state.manager.getConnection(spec.serverName) : undefined;
+        }
+      }
+      return state.manager.getConnection(spec.serverName);
+    };
+    try {
+      state.manager.touch(spec.serverName);
+      state.manager.incrementInFlight(spec.serverName);
+      if (spec.resourceUri) {
+        const result = await withSessionRecovery({
+          manager: state.manager,
+          config: state.config,
+          ...ownedSignal ? { signal: ownedSignal } : {},
+          onNeedsAuth: recoverAuthConnection
+        }, spec.serverName, async (conn) => {
+          const refreshRead = await state.manager.prepareResourceUse?.(spec.serverName, spec.resourceUri, conn);
+          return conn.client.readResource({ uri: spec.resourceUri }, refreshRead ? { ...requestOptions, cacheMode: "refresh" } : requestOptions);
+        });
+        const content = transformMcpResourceContents(result.contents ?? [], state.owner?.signal);
+        const guarded = await guardMcpOutput(content.length > 0 ? content : [{ type: "text", text: "(empty resource)" }], {
+          ...outputGuardOptions,
+          ...state.config.settings?.directToolResultDetails === "bounded" ? { rawMcpResult: result } : {}
+        });
+        return {
+          content: guarded.content,
+          details: { server: spec.serverName, resourceUri: spec.resourceUri, ...guardedMcpDetails(guarded) }
+        };
+      }
+      const hasUi = !!spec.uiResourceUri;
+      uiSession = hasUi ? await maybeStartUiSession(state, {
+        serverName: spec.serverName,
+        toolName: spec.originalName,
+        toolArgs: normalizedParams,
+        uiResourceUri: spec.uiResourceUri,
+        ...spec.uiStreamMode !== undefined ? { streamMode: spec.uiStreamMode } : {},
+        ...signal ? { signal } : {},
+        onNeedsAuth: recoverAuthConnection
+      }) : null;
+      const result = await withSessionRecovery({
+        manager: state.manager,
+        config: state.config,
+        ...ownedSignal ? { signal: ownedSignal } : {},
+        onNeedsAuth: recoverAuthConnection
+      }, spec.serverName, async (conn) => {
+        await state.manager.ensureListen?.(spec.serverName, conn);
+        return abortable(conn.client.callTool({
+          name: spec.originalName,
+          arguments: normalizedParams,
+          _meta: uiSession?.requestMeta
+        }, requestOptions), ownedSignal);
+      });
+      uiSession?.sendToolResult(result);
+      if (result.isError) {
+        const mcpContent = result.content ?? [];
+        const content = transformMcpContent(mcpContent, state.owner?.signal);
+        const outputContent = content.length > 0 ? content : [{ type: "text", text: "(empty result)" }];
+        const schemaText = spec.inputSchema ? `
+
+Expected parameters:
+${formatSchema(spec.inputSchema)}` : "";
+        const guarded = await guardMcpOutput(outputContent, {
+          ...outputGuardOptions,
+          prefix: "Error: ",
+          suffix: schemaText,
+          emptyTextFallback: "Tool execution failed",
+          ...state.config.settings?.directToolResultDetails === "bounded" ? { rawMcpResult: result } : {}
+        });
+        return {
+          content: guarded.content,
+          details: { error: "tool_error", server: spec.serverName, ...guardedMcpDetails(guarded) }
+        };
+      }
+      const content = resolveMcpResultContent(result, state.owner?.signal);
+      const outputContent = content.length > 0 ? content : [{ type: "text", text: "(empty result)" }];
+      if (hasUi) {
+        const uiSummary = summarizeUiSessionResult(uiSession);
+        const guarded = await guardMcpOutput(outputContent, {
+          ...outputGuardOptions,
+          suffix: `
+
+${uiSummary.message}`,
+          ...state.config.settings?.directToolResultDetails === "bounded" ? { rawMcpResult: result } : {}
+        });
+        return {
+          content: guarded.content,
+          details: {
+            server: spec.serverName,
+            tool: spec.originalName,
+            uiOpen: uiSummary.uiOpen,
+            uiViewer: uiSummary.uiViewer,
+            uiUrl: uiSummary.uiUrl,
+            ...guardedMcpDetails(guarded)
+          }
+        };
+      }
+      const guarded = await guardMcpOutput(outputContent, {
+        ...outputGuardOptions,
+        ...state.config.settings?.directToolResultDetails === "bounded" ? { rawMcpResult: result } : {}
+      });
+      return {
+        content: guarded.content,
+        details: { server: spec.serverName, tool: spec.originalName, ...guardedMcpDetails(guarded) }
+      };
+    } catch (error) {
+      if (error instanceof SessionRecoveryAuthRequiredError) {
+        const message = error.authMessage ?? getDirectAuthRequiredMessage(state, spec.serverName);
+        uiSession?.sendToolCancelled(message);
+        return {
+          content: [{ type: "text", text: message }],
+          details: { error: "auth_required", server: spec.serverName, message, autoAuthAttempted }
+        };
+      }
+      if (error instanceof UrlElicitationRequiredError) {
+        const action = await state.manager.handleUrlElicitationRequired(spec.serverName, error);
+        const message = action === "accept" ? "The original MCP tool did not run. Complete the opened browser interaction, then retry the tool." : `The URL interaction was ${action === "decline" ? "declined" : "cancelled"}.`;
+        uiSession?.sendToolCancelled(message);
+        return {
+          content: [{ type: "text", text: message }],
+          details: { error: "url_elicitation_required", server: spec.serverName, action }
+        };
+      }
+      const inputRequired = getInputRequiredNeedsUiDetails(error, spec.resourceUri ? { server: spec.serverName, resourceUri: spec.resourceUri } : { server: spec.serverName, tool: spec.originalName });
+      if (inputRequired) {
+        uiSession?.sendToolCancelled(inputRequired.message);
+        return {
+          content: [{ type: "text", text: inputRequired.message }],
+          details: { ...inputRequired }
+        };
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      const aborted = isAbortError(error, ownedSignal);
+      if (!aborted) {
+        await state.manager.close(spec.serverName).catch(() => {});
+      }
+      uiSession?.sendToolCancelled(message);
+      const schemaText = spec.inputSchema ? `
+
+Expected parameters:
+${formatSchema(spec.inputSchema)}` : "";
+      const guarded = await guardMcpOutput([{ type: "text", text: message }], { ...outputGuardOptions, prefix: "Failed to call tool: ", suffix: schemaText });
+      return {
+        content: guarded.content,
+        details: { error: aborted ? "aborted" : "call_failed", server: spec.serverName, ...guardedMcpDetails(guarded) }
+      };
+    } finally {
+      if (uiSession?.reused) {
+        uiSession.close();
+      }
+      state.manager.decrementInFlight(spec.serverName);
+      state.manager.touch(spec.serverName);
+    }
+  };
+}

package/extensions/dm-mcp-adapter/dist/agent-dir.js

@@ -0,0 +1,45 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+export function getConfigDirName() {
+  const configDir = readPiConfig()?.configDir;
+  return typeof configDir === "string" && configDir.trim() ? configDir.trim() : ".dm";
+}
+export function getAgentDir() {
+  const piConfig = readPiConfig();
+  const name = piConfig?.name;
+  const appName = typeof name === "string" && name.trim() ? name.trim() : "pi";
+  const configured = process.env[`${appName.toUpperCase()}_CODING_AGENT_DIR`]?.trim();
+  if (!configured) {
+    return join(homedir(), getConfigDirName(), "agent");
+  }
+  if (configured === "~") {
+    return homedir();
+  }
+  if (configured.startsWith("~/")) {
+    return resolve(homedir(), configured.slice(2));
+  }
+  return resolve(configured);
+}
+export function getAgentPath(...segments) {
+  return join(getAgentDir(), ...segments);
+}
+function readPiConfig() {
+  const dir = process.env.PI_PACKAGE_DIR?.trim();
+  if (!dir)
+    return;
+  try {
+    const manifest = JSON.parse(readFileSync(join(resolve(dir), "package.json"), "utf8"));
+    return manifest.piConfig;
+  } catch {
+    return;
+  }
+}
+export function getAppName() {
+  const name = readPiConfig()?.name;
+  return typeof name === "string" && name.trim() ? name.trim() : "pi";
+}
+export function getAppClientUri() {
+  const uri = readPiConfig()?.clientUri;
+  return typeof uri === "string" && uri.trim() ? uri.trim() : undefined;
+}