@duckmind/dm-windows-x64 0.63.6 → 0.63.9

package/extensions/dm-mcp-adapter/ts-shape.js

@@ -0,0 +1,157 @@
+const UNSUPPORTED_KEYWORDS = ["if", "then", "else", "allOf", "not", "patternProperties", "additionalProperties"];
+export function renderTsShape(inputSchema) {
+  try {
+    if (!isSchema(inputSchema))
+      return null;
+    const definitions = new Map;
+    for (const key of ["$defs", "definitions"]) {
+      const rawDefinitions = inputSchema[key];
+      if (rawDefinitions === undefined)
+        continue;
+      if (!isSchema(rawDefinitions))
+        return null;
+      for (const [name, definition] of Object.entries(rawDefinitions)) {
+        if (!isSchema(definition))
+          return null;
+        definitions.set(`${key}/${decodePointerToken(name)}`, definition);
+      }
+    }
+    const aliases = new Map;
+    const usedAliases = new Set;
+    let aliasIndex = 0;
+    const aliasFor = (definitionKey) => {
+      let alias = aliases.get(definitionKey);
+      if (alias)
+        return alias;
+      const name = definitionKey.slice(definitionKey.indexOf("/") + 1);
+      alias = /^[A-Za-z_$][\w$]*$/.test(name) && !usedAliases.has(name) ? name : `Definition${++aliasIndex}`;
+      while (usedAliases.has(alias))
+        alias = `Definition${++aliasIndex}`;
+      aliases.set(definitionKey, alias);
+      usedAliases.add(alias);
+      return alias;
+    };
+    const render = (schema) => {
+      if (!isSchema(schema) || hasUnsupportedKeyword(schema))
+        return null;
+      if ("$ref" in schema) {
+        if (typeof schema.$ref !== "string")
+          return null;
+        const match = schema.$ref.match(/^#\/(\$defs|definitions)\/([^/]+)$/);
+        if (!match)
+          return null;
+        const definitionGroup = match[1];
+        const definitionName = match[2];
+        if (definitionGroup === undefined || definitionName === undefined)
+          return null;
+        const definitionKey = `${definitionGroup}/${decodePointerToken(definitionName)}`;
+        if (!definitions.has(definitionKey))
+          return null;
+        return aliasFor(definitionKey);
+      }
+      if (Array.isArray(schema.enum)) {
+        const values = schema.enum.map(renderLiteral);
+        return values.every((value) => value !== null) ? values.join(" | ") : null;
+      }
+      if (Object.hasOwn(schema, "const"))
+        return renderLiteral(schema.const);
+      if (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf)) {
+        const variants = schema.anyOf ?? schema.oneOf;
+        if (variants.length === 0)
+          return null;
+        const rendered = variants.map(render);
+        return rendered.every((value) => value !== null) ? rendered.join(" | ") : null;
+      }
+      if (schema.type === "object" || schema.properties !== undefined) {
+        if (schema.properties === undefined)
+          return "{}";
+        if (!isSchema(schema.properties))
+          return null;
+        const required = new Set(Array.isArray(schema.required) ? schema.required.filter((name) => typeof name === "string") : []);
+        const properties = [];
+        for (const [name, property] of Object.entries(schema.properties)) {
+          const rendered = render(property);
+          if (rendered === null)
+            return null;
+          properties.push(`${formatPropertyName(name)}${required.has(name) ? "" : "?"}: ${rendered};`);
+        }
+        return properties.length === 0 ? "{}" : `{ ${properties.join(" ")} }`;
+      }
+      if (schema.type === "array") {
+        if (schema.items === undefined)
+          return "unknown[]";
+        const item = render(schema.items);
+        return item === null ? null : `${needsParentheses(item) ? `(${item})` : item}[]`;
+      }
+      if (Array.isArray(schema.type)) {
+        const types = schema.type.map(renderType);
+        return types.every((type) => type !== null) ? types.join(" | ") : null;
+      }
+      if (typeof schema.type === "string")
+        return renderType(schema.type);
+      return "unknown";
+    };
+    const root = render(inputSchema);
+    if (root === null)
+      return null;
+    const definitionsText = [];
+    for (const [key, alias] of aliases) {
+      const definition = definitions.get(key);
+      if (!definition)
+        return null;
+      const rendered = render(definition);
+      if (rendered === null)
+        return null;
+      definitionsText.push(`type ${alias} = ${rendered};`);
+    }
+    return definitionsText.length > 0 ? `${definitionsText.join(`
+`)}
+
+${root}` : root;
+  } catch {
+    return null;
+  }
+}
+function isSchema(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasUnsupportedKeyword(schema) {
+  return UNSUPPORTED_KEYWORDS.some((keyword) => {
+    if (!Object.hasOwn(schema, keyword))
+      return false;
+    return keyword !== "additionalProperties" || schema.additionalProperties !== false;
+  });
+}
+function decodePointerToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function renderType(type) {
+  switch (type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "object":
+      return "{}";
+    case "array":
+      return "unknown[]";
+    default:
+      return null;
+  }
+}
+function renderLiteral(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return JSON.stringify(value);
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : null;
+}
+function formatPropertyName(name) {
+  return /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function needsParentheses(type) {
+  return type.includes(" | ");
+}

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

@@ -0,0 +1,264 @@
+export const MCP_STATUS_EVENT = "dm-mcp-adapter/status/v1";
+export const MCP_STATUS_SNAPSHOT_VERSION = 1;
+export {
+  UI_STREAM_HOST_CONTEXT_KEY,
+  UI_STREAM_REQUEST_META_KEY,
+  UI_STREAM_RESULT_PATCH_METHOD,
+  SERVER_STREAM_RESULT_PATCH_METHOD,
+  UI_STREAM_STRUCTURED_CONTENT_KEY,
+  uiStreamModeSchema,
+  visualizationStreamPhaseSchema,
+  visualizationStreamFrameTypeSchema,
+  visualizationStreamStatusSchema,
+  uiStreamHostContextSchema,
+  visualizationStreamEnvelopeSchema,
+  uiStreamCallToolResultSchema,
+  uiStreamResultPatchNotificationSchema,
+  serverStreamResultPatchNotificationSchema,
+  getUiStreamHostContext,
+  getVisualizationStreamEnvelope
+} from "./ui-stream-types.js";
+export function extractUiPromptText(params) {
+  if (params.type === "prompt" || params.prompt) {
+    const prompt = params.prompt ?? String(params.message ?? "");
+    return prompt || undefined;
+  }
+  if (params.role === "user" && Array.isArray(params.content)) {
+    const text = params.content.map((block) => block && typeof block === "object" && ("text" in block) ? String(block.text ?? "") : "").filter(Boolean).join(`
+
+`);
+    return text || undefined;
+  }
+  return;
+}
+export function parseUiPromptHandoff(prompt) {
+  const newlineIndex = prompt.indexOf(`
+`);
+  if (newlineIndex <= 0) {
+    return;
+  }
+  const intent = prompt.slice(0, newlineIndex).trim();
+  const payloadText = prompt.slice(newlineIndex + 1).trim();
+  if (!intent || !payloadText) {
+    return;
+  }
+  if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(intent)) {
+    return;
+  }
+  try {
+    const parsed = JSON.parse(payloadText);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return;
+    }
+    return {
+      intent,
+      params: parsed,
+      raw: prompt
+    };
+  } catch {
+    return;
+  }
+}
+export function createUiModelContextUpdate(params, maxChars = 12000) {
+  const payload = Object.fromEntries(Object.entries(params).filter(([, value]) => value !== undefined));
+  if (Object.keys(payload).length === 0)
+    return;
+  const serialized = JSON.stringify(payload);
+  if (serialized.length <= maxChars) {
+    return { payload, summary: serialized, truncated: false };
+  }
+  return {
+    summary: `${serialized.slice(0, Math.max(0, maxChars - 1))}…`,
+    truncated: true
+  };
+}
+export function isServerDisabled(definition) {
+  return definition?.disabled === true;
+}
+export const MCP_TOOL_APPROVAL_REQUEST_EVENT = "dm-mcp-adapter:tool-approval-request";
+function sanitizeServerPrefix(serverName, preserveProviderValid = true) {
+  const validCharacters = preserveProviderValid ? /^[A-Za-z0-9_-]$/ : /^[A-Za-z0-9]$/;
+  return Array.from(serverName, (char) => validCharacters.test(char) ? char : `_${char.codePointAt(0).toString(16)}_`).join("");
+}
+export function getServerPrefix(serverName, mode) {
+  if (mode === "none")
+    return "";
+  if (mode === "short") {
+    let short = sanitizeServerPrefix(serverName.replace(/-?mcp$/i, ""));
+    if (!short)
+      short = "mcp";
+    return short;
+  }
+  if (mode === "mcp")
+    return `mcp__${sanitizeServerPrefix(serverName)}`;
+  return sanitizeServerPrefix(serverName);
+}
+export function formatToolName(toolName, serverName, prefix) {
+  const p = getServerPrefix(serverName, prefix);
+  const sanitized = toolName.replace(/\./g, "_");
+  return p ? `${p}_${sanitized}` : sanitized;
+}
+export function resolveToolPrefix(definition, globalPrefix) {
+  return definition?.toolPrefix ?? globalPrefix ?? "server";
+}
+export function resolveServerFromToolName(toolName, serverNames, prefix) {
+  if (prefix === "none")
+    return;
+  const candidates = [];
+  for (const name of serverNames) {
+    const p = getServerPrefix(name, prefix);
+    if (p && toolName.startsWith(p + "_"))
+      candidates.push({ name, prefix: p });
+  }
+  if (candidates.length === 0)
+    return;
+  candidates.sort((a, b) => b.prefix.length - a.prefix.length);
+  const best = candidates[0];
+  if (candidates.some((c) => c.prefix === best.prefix && c.name !== best.name)) {
+    return;
+  }
+  return best?.name;
+}
+export function sanitizePromptName(name) {
+  const cleaned = name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "");
+  if (!cleaned)
+    return "prompt";
+  return /^[0-9]/.test(cleaned) ? `_${cleaned}` : cleaned;
+}
+export function formatPromptCommandName(promptName, serverName, prefix) {
+  const serverPart = getServerPrefix(serverName, prefix) || sanitizeServerPrefix(serverName) || "server";
+  return `mcp__${serverPart}__${sanitizePromptName(promptName)}`;
+}
+function getLegacyServerPrefix(serverName, mode) {
+  if (mode === "none")
+    return "";
+  if (mode === "short")
+    return sanitizeServerPrefix(serverName.replace(/-?mcp$/i, ""), false) || "mcp";
+  if (mode === "mcp")
+    return `mcp__${sanitizeServerPrefix(serverName, false)}`;
+  return sanitizeServerPrefix(serverName, false);
+}
+function formatLegacyToolName(toolName, serverName, prefix) {
+  const serverPrefix = getLegacyServerPrefix(serverName, prefix);
+  const sanitizedToolName = toolName.replace(/[.-]/g, "_");
+  return serverPrefix ? `${serverPrefix}_${sanitizedToolName}` : sanitizedToolName;
+}
+export function getToolNameCandidates(toolName, serverName, prefix, includeLegacy = true) {
+  const candidates = new Set([
+    toolName,
+    formatToolName(toolName, serverName, prefix),
+    formatToolName(toolName, serverName, "server"),
+    formatToolName(toolName, serverName, "short"),
+    formatToolName(toolName, serverName, "mcp")
+  ]);
+  if (includeLegacy) {
+    const legacyToolName = toolName.replace(/-/g, "_");
+    candidates.add(legacyToolName);
+    candidates.add(formatToolName(legacyToolName, serverName, prefix));
+    candidates.add(formatToolName(legacyToolName, serverName, "server"));
+    candidates.add(formatToolName(legacyToolName, serverName, "short"));
+    candidates.add(formatToolName(legacyToolName, serverName, "mcp"));
+    candidates.add(formatLegacyToolName(toolName, serverName, prefix));
+    candidates.add(formatLegacyToolName(toolName, serverName, "server"));
+    candidates.add(formatLegacyToolName(toolName, serverName, "short"));
+    candidates.add(formatLegacyToolName(toolName, serverName, "mcp"));
+    candidates.add(formatToolName(toolName, serverName, prefix).replace(/-/g, "_"));
+    candidates.add(formatToolName(toolName, serverName, "server").replace(/-/g, "_"));
+    candidates.add(formatToolName(toolName, serverName, "short").replace(/-/g, "_"));
+    candidates.add(formatToolName(toolName, serverName, "mcp").replace(/-/g, "_"));
+  }
+  return candidates;
+}
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`);
+}
+export function createToolSelectorCandidateIndex(allCurrentCandidates, additionalCurrentCandidatesByToolName) {
+  return {
+    allCurrentCandidates,
+    matchingCountByPattern: new Map,
+    matcherByPattern: new Map,
+    ...additionalCurrentCandidatesByToolName ? { additionalCurrentCandidatesByToolName } : {}
+  };
+}
+export function matchesToolPattern(candidates, patterns) {
+  if (!Array.isArray(patterns) || patterns.length === 0)
+    return false;
+  for (const pattern of patterns) {
+    if (typeof pattern !== "string")
+      continue;
+    if (!pattern.includes("*") && !pattern.includes("?") && candidates.has(pattern)) {
+      return true;
+    }
+    if ((pattern.includes("*") || pattern.includes("?")) && [...candidates].some((candidate) => globToRegExp(pattern).test(candidate))) {
+      return true;
+    }
+  }
+  return false;
+}
+function indexHasOtherCurrentMatch(index, toolName, currentCandidates, pattern) {
+  const additionalCandidates = index.additionalCurrentCandidatesByToolName?.get(toolName);
+  const hasCandidate = (candidate) => index.allCurrentCandidates.has(candidate) || additionalCandidates?.has(candidate) === true;
+  const isGlob = pattern.includes("*") || pattern.includes("?");
+  if (!isGlob) {
+    return hasCandidate(pattern) && !currentCandidates.has(pattern);
+  }
+  let matcher = index.matcherByPattern.get(pattern);
+  if (!matcher) {
+    matcher = globToRegExp(pattern);
+    index.matcherByPattern.set(pattern, matcher);
+  }
+  let matchingCount = index.matchingCountByPattern.get(pattern);
+  if (matchingCount === undefined) {
+    matchingCount = 0;
+    for (const candidate of index.allCurrentCandidates) {
+      if (matcher.test(candidate))
+        matchingCount++;
+    }
+    index.matchingCountByPattern.set(pattern, matchingCount);
+  }
+  let totalMatchingCount = matchingCount;
+  if (additionalCandidates) {
+    for (const candidate of additionalCandidates) {
+      if (!index.allCurrentCandidates.has(candidate) && matcher.test(candidate))
+        totalMatchingCount++;
+    }
+  }
+  if (totalMatchingCount === 0)
+    return false;
+  let currentMatchingCount = 0;
+  for (const candidate of currentCandidates) {
+    if (hasCandidate(candidate) && matcher.test(candidate))
+      currentMatchingCount++;
+  }
+  return totalMatchingCount > currentMatchingCount;
+}
+function matchesToolSelector(toolName, serverName, prefix, patterns, otherCurrentCandidates) {
+  if (!Array.isArray(patterns) || patterns.length === 0)
+    return false;
+  const currentCandidates = getToolNameCandidates(toolName, serverName, prefix, false);
+  if (matchesToolPattern(currentCandidates, patterns))
+    return true;
+  if (!otherCurrentCandidates)
+    return matchesToolPattern(getToolNameCandidates(toolName, serverName, prefix), patterns);
+  const legacyCandidates = getToolNameCandidates(toolName, serverName, prefix);
+  for (const candidate of currentCandidates)
+    legacyCandidates.delete(candidate);
+  return patterns.some((pattern) => {
+    if (typeof pattern !== "string" || !matchesToolPattern(legacyCandidates, [pattern]))
+      return false;
+    const hasCollision = otherCurrentCandidates instanceof Set ? matchesToolPattern(otherCurrentCandidates, [pattern]) : indexHasOtherCurrentMatch(otherCurrentCandidates, toolName, currentCandidates, pattern);
+    return !hasCollision;
+  });
+}
+export function isToolIncluded(toolName, serverName, prefix, includeTools, otherCurrentCandidates) {
+  if (!Array.isArray(includeTools) || includeTools.length === 0)
+    return true;
+  return matchesToolSelector(toolName, serverName, prefix, includeTools, otherCurrentCandidates);
+}
+export function isToolExcluded(toolName, serverName, prefix, excludeTools, otherCurrentCandidates) {
+  return matchesToolSelector(toolName, serverName, prefix, excludeTools, otherCurrentCandidates);
+}
+export function isToolAllowed(toolName, serverName, prefix, includeTools, excludeTools, otherCurrentCandidates) {
+  return isToolIncluded(toolName, serverName, prefix, includeTools, otherCurrentCandidates) && !isToolExcluded(toolName, serverName, prefix, excludeTools, otherCurrentCandidates);
+}

package/extensions/dm-mcp-adapter/ui-app-bridge-helpers.js

@@ -0,0 +1,36 @@
+export const RESOURCE_MIME_TYPE = "text/html;profile=mcp-app";
+const RESOURCE_URI_META_KEY = "ui/resourceUri";
+export function getToolUiResourceUri(tool) {
+  const meta = tool._meta;
+  let resourceUri = getNestedResourceUri(meta);
+  if (resourceUri === undefined) {
+    resourceUri = meta?.[RESOURCE_URI_META_KEY];
+  }
+  if (typeof resourceUri === "string" && resourceUri.startsWith("ui://")) {
+    return resourceUri;
+  }
+  if (resourceUri !== undefined) {
+    throw new Error(`Invalid UI resource URI: ${JSON.stringify(resourceUri)}`);
+  }
+  return;
+}
+export function buildAllowAttribute(permissions) {
+  if (!permissions)
+    return "";
+  const allowed = [];
+  if (permissions.camera)
+    allowed.push("camera");
+  if (permissions.microphone)
+    allowed.push("microphone");
+  if (permissions.geolocation)
+    allowed.push("geolocation");
+  if (permissions.clipboardWrite)
+    allowed.push("clipboard-write");
+  return allowed.join("; ");
+}
+function getNestedResourceUri(meta) {
+  const ui = meta?.ui;
+  if (!ui || typeof ui !== "object")
+    return;
+  return ui.resourceUri;
+}

package/extensions/dm-mcp-adapter/ui-resource-handler.js

@@ -0,0 +1,209 @@
+import { RESOURCE_MIME_TYPE } from "./ui-app-bridge-helpers.js";
+import { UrlElicitationRequiredError } from "@modelcontextprotocol/client";
+import {
+  getInputRequiredNeedsUiDetails,
+  InputRequiredNeedsUiError,
+  ResourceFetchError,
+  ResourceParseError
+} from "./errors.js";
+import { logger } from "./logger.js";
+import { SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
+import { isServerDisabled } from "./types.js";
+
+export class UiResourceHandler {
+  manager;
+  config;
+  log = logger.child({ component: "UiResourceHandler" });
+  constructor(manager, config = undefined) {
+    this.manager = manager;
+    this.config = config;
+  }
+  async readUiResource(serverName, uri, options = {}) {
+    const log = this.log.child({ server: serverName, uri });
+    if (!uri.startsWith("ui://")) {
+      throw new ResourceParseError(uri, "URI must start with ui://", { server: serverName });
+    }
+    log.debug("Fetching UI resource");
+    let result;
+    try {
+      const config = options.config ?? this.config;
+      if (config && isServerDisabled(config.mcpServers[serverName])) {
+        throw new Error(`MCP server "${serverName}" is disabled`);
+      }
+      if (config) {
+        this.manager.touch(serverName);
+        this.manager.incrementInFlight(serverName);
+        try {
+          result = await withSessionRecovery({
+            manager: this.manager,
+            config,
+            ...options.signal ? { signal: options.signal } : {},
+            ...options.onNeedsAuth ? { onNeedsAuth: options.onNeedsAuth } : {}
+          }, serverName, async (connection) => {
+            const refreshRead = await this.manager.prepareResourceUse?.(serverName, uri, connection);
+            const requestOptions = this.manager.getRequestOptions(serverName, options.signal);
+            return connection.client.readResource({ uri }, refreshRead ? { ...requestOptions, cacheMode: "refresh" } : requestOptions);
+          });
+        } finally {
+          this.manager.decrementInFlight(serverName);
+          this.manager.touch(serverName);
+        }
+      } else {
+        result = await this.manager.readResource(serverName, uri, options.signal);
+      }
+    } catch (error) {
+      if (error instanceof UrlElicitationRequiredError || error instanceof SessionRecoveryAuthRequiredError)
+        throw error;
+      const inputRequired = getInputRequiredNeedsUiDetails(error, { server: serverName, resourceUri: uri });
+      if (inputRequired) {
+        throw new InputRequiredNeedsUiError(inputRequired, error instanceof Error ? error : undefined);
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      log.error("Failed to read resource", error instanceof Error ? error : undefined);
+      throw new ResourceFetchError(uri, message, {
+        server: serverName,
+        ...error instanceof Error ? { cause: error } : {}
+      });
+    }
+    const content = selectContent(result, uri);
+    const mimeType = content.mimeType;
+    if (mimeType && !isHtmlMimeType(mimeType)) {
+      log.warn("Unsupported MIME type", { mimeType });
+      throw new ResourceParseError(uri, `unsupported MIME type "${mimeType}" (expected text/html or ${RESOURCE_MIME_TYPE})`, { server: serverName, mimeType });
+    }
+    const html = toHtml(content);
+    if (!html.trim()) {
+      log.warn("Resource content is empty");
+      throw new ResourceParseError(uri, "content is empty", { server: serverName });
+    }
+    const contentMeta = extractUiMeta(content._meta);
+    const listMeta = extractUiMeta(this.getListResourceMeta(serverName, uri));
+    log.debug("Resource loaded successfully", {
+      contentLength: html.length,
+      hasCsp: !!contentMeta.csp || !!listMeta.csp
+    });
+    return {
+      uri: content.uri ?? uri,
+      html,
+      mimeType: mimeType ?? RESOURCE_MIME_TYPE,
+      meta: {
+        ...(contentMeta.csp ?? listMeta.csp) !== undefined ? { csp: contentMeta.csp ?? listMeta.csp } : {},
+        ...(contentMeta.permissions ?? listMeta.permissions) !== undefined ? { permissions: contentMeta.permissions ?? listMeta.permissions } : {},
+        ...(contentMeta.domain ?? listMeta.domain) !== undefined ? { domain: contentMeta.domain ?? listMeta.domain } : {},
+        ...(contentMeta.prefersBorder ?? listMeta.prefersBorder) !== undefined ? { prefersBorder: contentMeta.prefersBorder ?? listMeta.prefersBorder } : {}
+      }
+    };
+  }
+  getListResourceMeta(serverName, uri) {
+    const connection = this.manager.getConnection(serverName);
+    if (!connection?.resources?.length)
+      return;
+    const resource = connection.resources.find((entry) => entry.uri === uri);
+    if (!resource || !resource._meta || typeof resource._meta !== "object")
+      return;
+    return resource._meta;
+  }
+}
+function selectContent(result, preferredUri) {
+  const contents = result.contents ?? [];
+  if (contents.length === 0) {
+    throw new Error(`No contents returned for UI resource: ${preferredUri}`);
+  }
+  const byUri = contents.find((content) => content.uri === preferredUri);
+  if (byUri)
+    return byUri;
+  const byHtmlMime = contents.find((content) => content.mimeType && isHtmlMimeType(content.mimeType));
+  if (byHtmlMime)
+    return byHtmlMime;
+  const firstContent = contents[0];
+  if (!firstContent) {
+    throw new Error(`No contents returned for UI resource: ${preferredUri}`);
+  }
+  return firstContent;
+}
+function isHtmlMimeType(mimeType) {
+  const normalized = mimeType.toLowerCase();
+  return normalized.startsWith("text/html") || normalized === RESOURCE_MIME_TYPE.toLowerCase();
+}
+function toHtml(content) {
+  if (typeof content.text === "string") {
+    return content.text;
+  }
+  if (typeof content.blob === "string") {
+    return Buffer.from(content.blob, "base64").toString("utf-8");
+  }
+  throw new Error(`UI resource ${content.uri ?? "(unknown)"} did not include text or blob content`);
+}
+const OPENAI_CSP_FIELD_MAPPINGS = [
+  ["resource_domains", "resourceDomains"],
+  ["connect_domains", "connectDomains"],
+  ["frame_domains", "frameDomains"]
+];
+const UI_CSP_DOMAIN_FIELDS = [
+  "resourceDomains",
+  "connectDomains",
+  "frameDomains",
+  "baseUriDomains"
+];
+function extractUiMeta(meta) {
+  if (!meta || typeof meta !== "object")
+    return {};
+  const ui = isRecord(meta.ui) ? meta.ui : undefined;
+  const out = {};
+  const openAiCsp = Object.hasOwn(meta, "openai/widgetCSP") ? normalizeOpenAiWidgetCsp(meta["openai/widgetCSP"]) : undefined;
+  const hasStandardCsp = !!ui && Object.hasOwn(ui, "csp");
+  const standardCspValue = hasStandardCsp ? ui.csp : undefined;
+  if (hasStandardCsp && !isRecord(standardCspValue)) {
+    out.csp = {};
+  } else {
+    const standardCsp = hasStandardCsp ? normalizeUiResourceCsp(standardCspValue) : undefined;
+    if (openAiCsp || standardCsp) {
+      out.csp = { ...openAiCsp, ...standardCsp };
+      if (isRecord(standardCspValue)) {
+        for (const [, standardField] of OPENAI_CSP_FIELD_MAPPINGS) {
+          if (Object.hasOwn(standardCspValue, standardField) && !copyStringArray(standardCspValue[standardField])) {
+            delete out.csp[standardField];
+          }
+        }
+      }
+    }
+  }
+  if (ui && isRecord(ui.permissions)) {
+    out.permissions = ui.permissions;
+  }
+  if (ui && typeof ui.domain === "string") {
+    out.domain = ui.domain;
+  }
+  if (ui && typeof ui.prefersBorder === "boolean") {
+    out.prefersBorder = ui.prefersBorder;
+  }
+  return out;
+}
+function normalizeUiResourceCsp(value) {
+  if (!isRecord(value))
+    return {};
+  const csp = {};
+  for (const field of UI_CSP_DOMAIN_FIELDS) {
+    const domains = copyStringArray(value[field]);
+    if (domains)
+      csp[field] = domains;
+  }
+  return csp;
+}
+function normalizeOpenAiWidgetCsp(value) {
+  if (!isRecord(value))
+    return {};
+  const csp = {};
+  for (const [sourceField, targetField] of OPENAI_CSP_FIELD_MAPPINGS) {
+    const domains = copyStringArray(value[sourceField]);
+    if (domains)
+      csp[targetField] = domains;
+  }
+  return csp;
+}
+function copyStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? [...value] : undefined;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}