@duckmind/dm-windows-x64 0.63.4 → 0.63.9

package/extensions/dm-mcp-adapter/dist/utils.js

@@ -0,0 +1,307 @@
+import { spawnSync } from "node:child_process";
+import { homedir, platform } from "node:os";
+import { extname, isAbsolute, join } from "node:path";
+async function execOpen(pi, target, browser, signal) {
+  const os = platform();
+  if (os === "darwin") {
+    if (browser) {
+      return isAbsolute(browser) && extname(browser).toLowerCase() !== ".app" ? pi.exec(browser, [target], signal ? { signal } : {}) : pi.exec("open", ["-a", browser, target], signal ? { signal } : {});
+    }
+    return pi.exec("open", [target], signal ? { signal } : {});
+  }
+  if (os === "win32") {
+    return browser ? pi.exec("cmd", ["/c", "start", "", browser, target], signal ? { signal } : {}) : pi.exec("cmd", ["/c", "start", "", target], signal ? { signal } : {});
+  }
+  return browser ? pi.exec(browser, [target], signal ? { signal } : {}) : pi.exec("xdg-open", [target], signal ? { signal } : {});
+}
+export async function openUrl(pi, url, browser, signal) {
+  const result = await execOpen(pi, url, browser, signal);
+  if (result.code !== 0) {
+    throw new Error(result.stderr || `Failed to open browser (exit code ${result.code})`);
+  }
+}
+export async function openPath(pi, targetPath) {
+  const result = await execOpen(pi, targetPath);
+  if (result.code !== 0) {
+    throw new Error(result.stderr || `Failed to open path (exit code ${result.code})`);
+  }
+}
+export async function parallelLimit(items, limit, fn) {
+  const results = [];
+  const iterator = items.entries();
+  async function worker() {
+    while (true) {
+      const next = iterator.next();
+      if (next.done)
+        return;
+      const [index, item] = next.value;
+      results[index] = await fn(item);
+    }
+  }
+  const workers = Array(Math.min(limit, items.length)).fill(null).map(() => worker());
+  await Promise.all(workers);
+  return results;
+}
+export function getConfigPathFromArgv() {
+  const idx = process.argv.indexOf("--mcp-config");
+  if (idx >= 0 && idx + 1 < process.argv.length) {
+    return process.argv[idx + 1];
+  }
+  return;
+}
+export function interpolateEnvVars(value, environment = process.env) {
+  return value.replace(/\$\{(\w+)\}/g, (_, name) => environment[name] ?? "").replace(/\$env:(\w+)/g, (_, name) => environment[name] ?? "").replace(/\{env:(\w+)\}/g, (_, name) => environment[name] ?? "");
+}
+function getMissingEnvVars(value, environment) {
+  const missing = new Set;
+  for (const match of value.matchAll(/\$\{(\w+)\}|\$env:(\w+)|\{env:(\w+)\}/g)) {
+    const name = match[1] ?? match[2] ?? match[3];
+    if (name && environment[name] === undefined) {
+      missing.add(name);
+    }
+  }
+  return [...missing];
+}
+export function toStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string")
+      result[key] = entry;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+function interpolateSecretExpression(value, environment) {
+  if (value.startsWith("!!"))
+    return interpolateEnvVars(value.slice(1), environment);
+  return value.startsWith("!") ? value : interpolateEnvVars(value, environment);
+}
+export function interpolateEnvRecord(values, environment = process.env) {
+  if (!values)
+    return;
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+    key,
+    interpolateSecretExpression(value, environment)
+  ]));
+}
+const COMMAND_SECRET_TIMEOUT_MS = 1e4;
+const COMMAND_SECRET_MAX_OUTPUT_BYTES = 1024 * 1024;
+export function resolveCommandSecret(value, context) {
+  if (value === undefined)
+    return;
+  if (value.startsWith("!!"))
+    return interpolateEnvVars(value.slice(1));
+  if (!value.startsWith("!"))
+    return interpolateEnvVars(value);
+  const result = spawnSync(value.slice(1), {
+    shell: true,
+    encoding: "utf8",
+    timeout: COMMAND_SECRET_TIMEOUT_MS,
+    maxBuffer: COMMAND_SECRET_MAX_OUTPUT_BYTES,
+    stdio: ["ignore", "pipe", "ignore"],
+    windowsHide: true
+  });
+  if (result.error) {
+    const code = result.error.code;
+    const reason = code === "ETIMEDOUT" ? "command timed out after 10 seconds" : code === "ENOBUFS" ? "command output exceeded 1 MiB" : "command failed to start";
+    throw new Error(`Failed to resolve ${context}: ${reason}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`Failed to resolve ${context}: command exited with code ${result.status ?? "unknown"}`);
+  }
+  const resolved = result.stdout.trim();
+  if (!resolved)
+    throw new Error(`Failed to resolve ${context}: command returned empty output`);
+  return resolved;
+}
+export function resolveCommandSecretsRecord(values, context) {
+  if (!values)
+    return;
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+    key,
+    resolveCommandSecret(value, context(key))
+  ]));
+}
+export function resolveServerUrl(definition, environment = process.env) {
+  if (definition.url == null)
+    return;
+  if (typeof definition.url !== "string") {
+    throw new Error("MCP server URL must be a string");
+  }
+  const missing = getMissingEnvVars(definition.url, environment);
+  if (missing.length > 0) {
+    throw new Error(`Missing environment variable${missing.length === 1 ? "" : "s"} in MCP server URL: ${missing.join(", ")}`);
+  }
+  const resolved = interpolateEnvVars(definition.url, environment);
+  try {
+    new URL(resolved);
+  } catch (error) {
+    throw new Error(`Invalid MCP server URL after environment interpolation: ${resolved}`, { cause: error });
+  }
+  return resolved;
+}
+export function resolveConfigPath(value, environment = process.env) {
+  if (value === undefined)
+    return;
+  const resolved = interpolateEnvVars(value, environment);
+  if (resolved === "~")
+    return homedir();
+  if (resolved.startsWith("~/") || resolved.startsWith("~\\")) {
+    return join(homedir(), resolved.slice(2));
+  }
+  return resolved;
+}
+export function resolveBearerToken(definition, environment = process.env) {
+  if (definition.bearerToken !== undefined) {
+    return interpolateSecretExpression(definition.bearerToken, environment);
+  }
+  return definition.bearerTokenEnv ? environment[definition.bearerTokenEnv] : undefined;
+}
+export function stripOscSequences(text) {
+  let result = "";
+  let index = 0;
+  while (index < text.length) {
+    const isEscOsc = text.charCodeAt(index) === 27 && text[index + 1] === "]";
+    const isC1Osc = text.charCodeAt(index) === 157;
+    if (!isEscOsc && !isC1Osc) {
+      result += text[index++];
+      continue;
+    }
+    index += isEscOsc ? 2 : 1;
+    while (index < text.length) {
+      const code = text.charCodeAt(index++);
+      if (code === 7 || code === 156)
+        break;
+      if (code === 27 && text[index] === "\\") {
+        index++;
+        break;
+      }
+    }
+  }
+  return result;
+}
+export function sanitizeTerminalText(text) {
+  return stripOscSequences(text).replace(/(?:\x1b\[[0-?]*[ -/]*[@-~]|\x1b[@-Z\\-_])/g, "").replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ").replace(/\s+/g, " ").trim();
+}
+export function formatTerminalError(error) {
+  const messages = [];
+  const seen = new Set;
+  const collect = (value) => {
+    if (seen.has(value))
+      return;
+    if (typeof value === "object" && value !== null || typeof value === "function")
+      seen.add(value);
+    if (value instanceof AggregateError) {
+      const countBefore = messages.length;
+      for (const nested of value.errors)
+        collect(nested);
+      if (value.cause !== undefined)
+        collect(value.cause);
+      if (messages.length === countBefore && value.message)
+        messages.push(value.message);
+      return;
+    }
+    if (value instanceof Error) {
+      if (value.message)
+        messages.push(value.message);
+      if (value.cause !== undefined)
+        collect(value.cause);
+      return;
+    }
+    messages.push(String(value));
+  };
+  collect(error);
+  return sanitizeTerminalText([...new Set(messages)].join(": "));
+}
+export function truncateAtWord(text, target) {
+  if (!text || text.length <= target)
+    return text;
+  const truncated = text.slice(0, target);
+  const lastSpace = truncated.lastIndexOf(" ");
+  if (lastSpace > target * 0.6) {
+    return truncated.slice(0, lastSpace) + "...";
+  }
+  return truncated + "...";
+}
+export function normalizeDirectToolInputSchema(schema) {
+  const inputSchema = schema && typeof schema === "object" && !Array.isArray(schema) ? schema : { type: "object", properties: {} };
+  const { $schema, additionalProperties, ...normalized } = inputSchema;
+  return normalized;
+}
+export function normalizeToolArguments(value, context = "tool arguments") {
+  if (value === undefined || value === null || value === "")
+    return {};
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "")
+      return {};
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch (error) {
+      throw new Error(`${context}: invalid args JSON (${error instanceof SyntaxError ? error.message : String(error)}); ` + `pass args as a JSON object, or as a valid JSON string encoding one`, { cause: error });
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`${context}: expected a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`);
+    }
+    return parsed;
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${context}: expected a JSON object, got ${Array.isArray(value) ? "array" : typeof value}`);
+  }
+  assertJsonSerializable(value, context);
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch (error) {
+    throw new Error(`${context}: value is not JSON-serializable: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+function assertJsonSerializable(value, context, path = "") {
+  if (value === null)
+    return;
+  if (typeof value === "string" || typeof value === "boolean")
+    return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new Error(`${context}: value at ${path || "root"} is not a finite number`);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const [index, item] of value.entries())
+      assertJsonSerializable(item, context, `${path}[${index}]`);
+    return;
+  }
+  if (typeof value === "object") {
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+      throw new Error(`${context}: value at ${path || "root"} is not a plain JSON object`);
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new Error(`${context}: value at ${path || "root"} has symbol keys`);
+    }
+    for (const [key, item] of Object.entries(value)) {
+      assertJsonSerializable(item, context, path ? `${path}.${key}` : key);
+    }
+    return;
+  }
+  throw new Error(`${context}: value at ${path || "root"} is not JSON-serializable`);
+}
+export function formatAuthRequiredMessage(config, serverName, defaultMessage) {
+  const template = config.settings?.authRequiredMessage;
+  return template ? template.replaceAll("${server}", serverName) : defaultMessage;
+}
+export function formatMcpStatus(config, message) {
+  if (config.settings?.mcpFooterStatus === "off")
+    return;
+  return `${config.settings?.showStatusIcon === false ? "MCP: " : "\uD83D\uDD0C MCP: "}${message}`;
+}
+export function extractToolUiStreamMode(toolMeta) {
+  const uiMeta = toolMeta?.ui;
+  if (!uiMeta || typeof uiMeta !== "object")
+    return;
+  const streamMode = uiMeta["dm-mcp-adapter.streamMode"];
+  if (streamMode === "eager" || streamMode === "stream-first") {
+    return streamMode;
+  }
+  return;
+}

package/extensions/dm-mcp-adapter/elicitation-handler.js

@@ -0,0 +1,306 @@
+import {
+  ProtocolError,
+  ProtocolErrorCode
+} from "@modelcontextprotocol/client";
+import { AjvJsonSchemaValidator } from "@modelcontextprotocol/client/validators/ajv";
+import open from "open";
+export function registerElicitationHandler(client, options) {
+  client.setRequestHandler("elicitation/create", (request) => handleElicitationRequest(options, request));
+}
+export async function handleElicitationRequest(options, request) {
+  return request.params.mode === "url" ? handleUrlElicitation(options, request.params) : handleFormElicitation(options, request.params);
+}
+export async function handleFormElicitation(options, params) {
+  const properties = Object.entries(params.requestedSchema.properties);
+  const decision = await options.ui.select(`MCP Input Request
+Server: ${options.serverName}
+
+${params.message}`, ["Continue", "Decline"]);
+  if (decision === undefined)
+    return { action: "cancel" };
+  if (decision === "Decline")
+    return { action: "decline" };
+  if (properties.length === 0)
+    return { action: "accept", content: {} };
+  const values = {};
+  for (const [name, schema] of properties) {
+    const value = await collectValidField(options.ui, params, name, schema);
+    if (value.status === "cancelled")
+      return { action: "cancel" };
+    values[name] = value.value;
+  }
+  while (true) {
+    const content = coerceAndValidateFormValues(params, values);
+    const action = await options.ui.select(formatReview(options.serverName, properties, content), ["Submit", "Edit", "Decline"]);
+    if (action === undefined)
+      return { action: "cancel" };
+    if (action === "Decline")
+      return { action: "decline" };
+    if (action === "Submit")
+      return { action: "accept", content };
+    const labels = properties.map(([name, schema]) => `${schema.title ?? humanizeName(name)} (${name})`);
+    const selected = await options.ui.select("Choose a field to edit", labels);
+    if (selected === undefined)
+      return { action: "cancel" };
+    const property = properties[labels.indexOf(selected)];
+    if (!property)
+      continue;
+    const [name, schema] = property;
+    const value = await collectValidField(options.ui, params, name, schema, values[name]);
+    if (value.status === "cancelled")
+      return { action: "cancel" };
+    values[name] = value.value;
+  }
+}
+async function collectValidField(ui, params, name, schema, current) {
+  const required = params.requestedSchema.required?.includes(name) === true;
+  while (true) {
+    const result = await collectField(ui, params, name, schema, current);
+    if (result.status === "cancelled")
+      return result;
+    try {
+      coerceAndValidateFormValues({
+        ...params,
+        requestedSchema: {
+          type: "object",
+          properties: { [name]: schema },
+          ...required ? { required: [name] } : {}
+        }
+      }, { [name]: result.value });
+      return result;
+    } catch (error) {
+      ui.notify(error instanceof Error ? error.message : String(error), "error");
+      current = result.value;
+    }
+  }
+}
+async function collectField(ui, params, name, schema, current) {
+  const required = params.requestedSchema.required?.includes(name) === true;
+  const title = [schema.title ?? humanizeName(name), required ? "(required)" : "", schema.description].filter(Boolean).join(" ");
+  if (schema.type === "string" && (("enum" in schema) || ("oneOf" in schema))) {
+    const choices = "oneOf" in schema ? schema.oneOf.map((option) => ({ value: option.const, display: formatChoice(option.const, option.title) })) : schema.enum.map((value, index) => ({
+      value,
+      display: formatChoice(value, "enumNames" in schema ? schema.enumNames?.[index] : undefined)
+    }));
+    const displays = uniqueLabels(choices.map((choice) => choice.display));
+    const actions = [...displays];
+    const useDefault = schema.default === undefined ? undefined : uniqueAction("Use default", actions);
+    if (useDefault)
+      actions.push(useDefault);
+    const omit = required ? undefined : uniqueAction("Omit", actions);
+    if (omit)
+      actions.push(omit);
+    const action = await ui.select(title, actions);
+    if (action === undefined)
+      return { status: "cancelled" };
+    if (action === useDefault)
+      return { status: "collected", value: schema.default };
+    if (action === omit)
+      return { status: "collected", value: undefined };
+    return { status: "collected", value: choices[displays.indexOf(action)]?.value };
+  }
+  if (schema.type === "boolean") {
+    const actions = ["Yes", "No"];
+    if (schema.default !== undefined)
+      actions.push("Use default");
+    if (!required)
+      actions.push("Omit");
+    const action = await ui.select(title, actions);
+    if (action === undefined)
+      return { status: "cancelled" };
+    if (action === "Use default")
+      return { status: "collected", value: schema.default };
+    if (action === "Omit")
+      return { status: "collected", value: undefined };
+    return { status: "collected", value: action === "Yes" };
+  }
+  if (schema.type === "array") {
+    const actions = ["Choose values"];
+    if (schema.default !== undefined)
+      actions.push("Use default");
+    if (!required)
+      actions.push("Omit");
+    const action = await ui.select(title, actions);
+    if (action === undefined)
+      return { status: "cancelled" };
+    if (action === "Use default")
+      return { status: "collected", value: schema.default };
+    if (action === "Omit")
+      return { status: "collected", value: undefined };
+    const choices = extractMultiSelectOptions(schema);
+    const selected = new Set(Array.isArray(current) ? current : []);
+    while (true) {
+      const displays = uniqueLabels(choices.map((choice) => selected.has(choice.value) ? `✓ ${choice.display}` : choice.display));
+      const done = uniqueAction("Done", displays);
+      const picked = await ui.select(title, [...displays, done]);
+      if (picked === undefined)
+        return { status: "cancelled" };
+      if (picked === done)
+        return { status: "collected", value: [...selected] };
+      const choice = choices[displays.indexOf(picked)];
+      if (!choice)
+        continue;
+      if (selected.has(choice.value))
+        selected.delete(choice.value);
+      else
+        selected.add(choice.value);
+    }
+  }
+  const actions = ["Enter value"];
+  if (schema.default !== undefined)
+    actions.push("Use default");
+  if (!required)
+    actions.push("Omit");
+  const action = await ui.select(title, actions);
+  if (action === undefined)
+    return { status: "cancelled" };
+  if (action === "Use default")
+    return { status: "collected", value: schema.default };
+  if (action === "Omit")
+    return { status: "collected", value: undefined };
+  const entered = await ui.input(title, current === undefined ? undefined : String(current));
+  return entered === undefined ? { status: "cancelled" } : { status: "collected", value: entered };
+}
+export function coerceAndValidateFormValues(params, values) {
+  const output = {};
+  const required = new Set(params.requestedSchema.required ?? []);
+  for (const [name, schema] of Object.entries(params.requestedSchema.properties)) {
+    const value = values[name];
+    if (value === undefined) {
+      if (required.has(name))
+        throw new Error(`Missing required elicitation field: ${name}`);
+      continue;
+    }
+    if (schema.type === "string") {
+      const stringValue = String(value);
+      const limits = schema;
+      if (limits.minLength !== undefined && stringValue.length < limits.minLength) {
+        throw new Error(`Elicitation field ${name} is shorter than minimum length ${limits.minLength}`);
+      }
+      if (limits.maxLength !== undefined && stringValue.length > limits.maxLength) {
+        throw new Error(`Elicitation field ${name} is longer than maximum length ${limits.maxLength}`);
+      }
+      if ("enum" in schema && !schema.enum.includes(stringValue)) {
+        throw new Error(`Elicitation field ${name} is not an allowed value`);
+      }
+      if ("oneOf" in schema && !schema.oneOf.some((option) => option.const === stringValue)) {
+        throw new Error(`Elicitation field ${name} is not an allowed value`);
+      }
+      output[name] = stringValue;
+      continue;
+    }
+    if (schema.type === "number" || schema.type === "integer") {
+      if (typeof value === "string" && value.trim() === "") {
+        throw new Error(`Elicitation field ${name} must be a number`);
+      }
+      const numberValue = typeof value === "number" ? value : Number(value);
+      if (!Number.isFinite(numberValue))
+        throw new Error(`Elicitation field ${name} must be a number`);
+      if (schema.type === "integer" && !Number.isInteger(numberValue)) {
+        throw new Error(`Elicitation field ${name} must be an integer`);
+      }
+      if (schema.minimum !== undefined && numberValue < schema.minimum) {
+        throw new Error(`Elicitation field ${name} is below minimum ${schema.minimum}`);
+      }
+      if (schema.maximum !== undefined && numberValue > schema.maximum) {
+        throw new Error(`Elicitation field ${name} is above maximum ${schema.maximum}`);
+      }
+      output[name] = numberValue;
+      continue;
+    }
+    if (schema.type === "boolean") {
+      output[name] = typeof value === "boolean" ? value : value === "true";
+      continue;
+    }
+    if (schema.type === "array") {
+      if (!Array.isArray(value))
+        throw new Error(`Elicitation field ${name} must be a list`);
+      const allowed = new Set(extractMultiSelectOptions(schema).map((option) => option.value));
+      const arrayValue = value.map(String);
+      if (schema.minItems !== undefined && arrayValue.length < schema.minItems) {
+        throw new Error(`Elicitation field ${name} has fewer than ${schema.minItems} selections`);
+      }
+      if (schema.maxItems !== undefined && arrayValue.length > schema.maxItems) {
+        throw new Error(`Elicitation field ${name} has more than ${schema.maxItems} selections`);
+      }
+      if (arrayValue.some((item) => !allowed.has(item))) {
+        throw new Error(`Elicitation field ${name} contains an invalid selection`);
+      }
+      output[name] = arrayValue;
+    }
+  }
+  const validation = new AjvJsonSchemaValidator().getValidator(params.requestedSchema)(output);
+  if (!validation.valid) {
+    throw new Error(`Invalid elicitation response: ${validation.errorMessage}`);
+  }
+  return output;
+}
+function formatChoice(value, title) {
+  return title && title !== value ? `${title} (${value})` : value;
+}
+function uniqueLabels(labels) {
+  const used = new Set;
+  return labels.map((label) => {
+    let unique = label;
+    while (used.has(unique))
+      unique += "…";
+    used.add(unique);
+    return unique;
+  });
+}
+function uniqueAction(label, choices) {
+  let unique = label;
+  while (choices.includes(unique))
+    unique += "…";
+  return unique;
+}
+function extractMultiSelectOptions(schema) {
+  const items = schema.items;
+  return items.anyOf ? items.anyOf.map((option) => ({ value: option.const, display: formatChoice(option.const, option.title) })) : (items.enum ?? []).map((value) => ({ value, display: value }));
+}
+function formatReview(serverName, properties, content) {
+  const rows = properties.map(([name, schema]) => `${schema.title ?? humanizeName(name)}: ${content[name] === undefined ? "(omitted)" : String(content[name])}`);
+  return [`Review input for ${serverName}`, "", ...rows].join(`
+`);
+}
+export async function handleUrlElicitation(options, params) {
+  if (!options.allowUrl)
+    throw new ProtocolError(ProtocolErrorCode.InvalidParams, "URL elicitation is not supported");
+  let parsed;
+  try {
+    parsed = new URL(params.url);
+  } catch {
+    throw new ProtocolError(ProtocolErrorCode.InvalidParams, "URL elicitation supplied an invalid URL");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new ProtocolError(ProtocolErrorCode.InvalidParams, "URL elicitation only supports HTTP and HTTPS URLs");
+  }
+  const decision = await options.ui.select([
+    "MCP Browser Request",
+    `Server: ${options.serverName}`,
+    "",
+    params.message,
+    "",
+    `Host: ${parsed.host}`,
+    `Full URL: ${params.url}`,
+    "",
+    "Open this URL in your browser?"
+  ].join(`
+`), ["Open", "Decline"]);
+  if (decision === undefined)
+    return { action: "cancel" };
+  if (decision === "Decline")
+    return { action: "decline" };
+  try {
+    await open(params.url);
+  } catch (error) {
+    options.ui.notify(`Could not open MCP elicitation URL: ${error instanceof Error ? error.message : String(error)}`, "error");
+    return { action: "cancel" };
+  }
+  options.onUrlAccepted?.(params.elicitationId);
+  options.ui.notify("Opened browser for MCP elicitation.", "info");
+  return { action: "accept" };
+}
+function humanizeName(name) {
+  return name.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^./, (char) => char.toUpperCase());
+}

package/extensions/dm-mcp-adapter/error-signal.js

@@ -0,0 +1,16 @@
+import { INPUT_REQUIRED_NEEDS_UI } from "./errors.js";
+export function toolErrorOverride(details) {
+  if (details && typeof details === "object" && "error" in details) {
+    const code = details.error;
+    if (code === "tool_error" || code === "call_failed" || code === INPUT_REQUIRED_NEEDS_UI) {
+      return { isError: true };
+    }
+  }
+  if (details && typeof details === "object" && details.mode === "script") {
+    const calls = details.calls;
+    if (Array.isArray(calls) && calls.some((call) => !!call && typeof call === "object" && call.error === INPUT_REQUIRED_NEEDS_UI)) {
+      return { isError: true };
+    }
+  }
+  return;
+}