@duckmind/dm-windows-x64 0.63.4 → 0.63.9

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

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import stripJsonComments from "strip-json-comments";
+import { getAgentDir, getConfigDirName } from "./agent-dir.js";
+export function loadPackageMcpConfigs(cwd = process.cwd()) {
+  const mcpServers = {};
+  const seen = new Set;
+  for (const packageRoot of getConfiguredPackageRoots(cwd)) {
+    const manifest = readPackageManifest(packageRoot);
+    if (!manifest || typeof manifest.name !== "string" || !manifest.name)
+      continue;
+    const paths = getManifestMcpPaths(manifest.pi?.mcp, manifest.name);
+    if (!paths)
+      continue;
+    const packagePrefix = formatPackageName(manifest.name);
+    const packageServers = new Set;
+    for (const path of paths) {
+      const configPath = resolvePackageConfigPath(packageRoot, path);
+      if (!configPath) {
+        console.warn(`DM package ${manifest.name} skips MCP config ${path}: file must stay inside the package`);
+        continue;
+      }
+      const config = readMcpConfig(configPath, manifest.name);
+      if (!config)
+        continue;
+      for (const [serverName, server] of Object.entries(config.mcpServers)) {
+        const normalizedName = `${packagePrefix}__${formatServerName(serverName)}`;
+        if (packageServers.has(normalizedName) || seen.has(normalizedName)) {
+          console.warn(`DM package ${manifest.name} skips duplicate normalized MCP server ${normalizedName}`);
+          continue;
+        }
+        packageServers.add(normalizedName);
+        seen.add(normalizedName);
+        mcpServers[normalizedName] = server;
+      }
+    }
+  }
+  return { mcpServers };
+}
+function getConfiguredPackageRoots(cwd) {
+  const roots = [];
+  for (const [settingsPath, scope] of [
+    [join(cwd, getConfigDirName(), "settings.json"), "project"],
+    [join(getAgentDir(), "settings.json"), "user"]
+  ]) {
+    const settings = readOptionalJson(settingsPath, `${scope} DM settings`);
+    if (settings === undefined)
+      continue;
+    if (typeof settings !== "object" || settings === null || Array.isArray(settings)) {
+      throw new Error(`${scope} DM settings ${settingsPath} must be a JSON object`);
+    }
+    const packages = settings.packages;
+    if (packages === undefined)
+      continue;
+    if (!Array.isArray(packages))
+      throw new Error(`${scope} DM settings ${settingsPath} packages must be an array`);
+    for (const entry of packages) {
+      const source = typeof entry === "string" ? entry : entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.source === "string" ? entry.source : undefined;
+      if (!source)
+        throw new Error(`${scope} DM settings ${settingsPath} package entries must be strings or objects with a string source`);
+      const root = resolvePackageRoot(source, scope, cwd);
+      if (root && !roots.includes(root))
+        roots.push(root);
+    }
+  }
+  return roots;
+}
+function resolvePackageRoot(source, scope, cwd) {
+  const baseDir = scope === "user" ? getAgentDir() : join(cwd, getConfigDirName());
+  if (source.startsWith("npm:")) {
+    const name = source.slice(4).trim().match(/^(@?[^@]+(?:\/[^@]+)?)/)?.[1];
+    return name ? resolveContainedPath(join(baseDir, "npm", "node_modules"), name) : null;
+  }
+  const gitSource = source.startsWith("git:") ? source.slice(4).trim() : /^(?:(?:https?|ssh):\/\/|git@[^:]+:)/.test(source) ? source : null;
+  if (gitSource) {
+    const value = gitSource.replace(/^ssh:\/\/git@/, "").replace(/^git@([^:]+):/, "$1/").replace(/^[a-z]+:\/\//i, "");
+    const path = value.replace(/@[^/]+$/, "").replace(/\.git$/, "");
+    return path && !path.startsWith("/") ? resolveContainedPath(join(baseDir, "git"), path) : null;
+  }
+  return isAbsolute(source) ? resolve(source) : resolve(baseDir, source);
+}
+function readPackageManifest(packageRoot) {
+  const manifest = readOptionalJson(join(packageRoot, "package.json"), `DM package manifest ${packageRoot}`);
+  return manifest && typeof manifest === "object" && !Array.isArray(manifest) ? manifest : null;
+}
+function getManifestMcpPaths(value, packageName) {
+  const paths = typeof value === "string" ? [value] : Array.isArray(value) && value.every((path) => typeof path === "string") ? value : null;
+  if (value !== undefined && !paths)
+    console.warn(`DM package ${packageName} ignores invalid pi.mcp manifest entry`);
+  return paths;
+}
+function readMcpConfig(path, packageName) {
+  const config = readRequiredJson(path, `DM package ${packageName} MCP config`);
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error(`DM package ${packageName} MCP config ${path} must be a JSON object`);
+  }
+  const servers = config.mcpServers;
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+    throw new Error(`DM package ${packageName} MCP config ${path} must contain a JSON object mcpServers field`);
+  }
+  const mcpServers = {};
+  for (const [name, server] of Object.entries(servers)) {
+    if (!server || typeof server !== "object" || Array.isArray(server)) {
+      throw new Error(`DM package ${packageName} MCP config ${path} server ${name} must be a JSON object`);
+    }
+    mcpServers[name] = server;
+  }
+  return { mcpServers };
+}
+function readRequiredJson(path, description) {
+  try {
+    return JSON.parse(stripJsonComments(readFileSync(path, "utf8"), { trailingCommas: true }));
+  } catch (error) {
+    throw new Error(`${description} ${path} contains invalid JSON: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+function readOptionalJson(path, description) {
+  if (!existsSync(path))
+    return;
+  return readRequiredJson(path, description);
+}
+function resolveContainedPath(root, path) {
+  const resolved = resolve(root, path);
+  const rel = relative(root, resolved);
+  return rel === "" || !rel.startsWith("..") && !rel.startsWith(sep) && !isAbsolute(rel) ? resolved : null;
+}
+function resolvePackageConfigPath(packageRoot, path) {
+  const lexicalPath = resolveContainedPath(packageRoot, path);
+  if (!lexicalPath || !existsSync(lexicalPath) || !statSync(lexicalPath).isFile())
+    return null;
+  try {
+    const realPackageRoot = realpathSync(packageRoot);
+    const realConfigPath = realpathSync(lexicalPath);
+    return resolveContainedPath(realPackageRoot, realConfigPath);
+  } catch {
+    return null;
+  }
+}
+function formatPackageName(name) {
+  return name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "") || "package";
+}
+function formatServerName(name) {
+  return name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "") || "server";
+}

package/extensions/dm-mcp-adapter/dist/resource-tools.js

@@ -0,0 +1,7 @@
+export function resourceNameToToolName(name) {
+  let result = name.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_+/, "").replace(/_+$/, "").toLowerCase();
+  if (!result || /^\d/.test(result)) {
+    result = "resource" + (result ? "_" + result : "");
+  }
+  return result;
+}

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

@@ -0,0 +1,247 @@
+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/dist/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/dist/ui-stream-types.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+export const UI_STREAM_HOST_CONTEXT_KEY = "dm-mcp-adapter/stream";
+export const UI_STREAM_REQUEST_META_KEY = "dm-mcp-adapter/stream-token";
+export const UI_STREAM_RESULT_PATCH_METHOD = "notifications/dm-mcp-adapter/ui-result-patch";
+export const SERVER_STREAM_RESULT_PATCH_METHOD = "notifications/dm-mcp-adapter/result-patch";
+export const UI_STREAM_STRUCTURED_CONTENT_KEY = "dm-mcp-adapter/stream";
+export const uiStreamModeSchema = z.enum(["eager", "stream-first"]);
+export const visualizationStreamPhaseSchema = z.enum(["shell", "narrative", "structure", "detail", "settled"]);
+export const visualizationStreamFrameTypeSchema = z.enum(["patch", "checkpoint", "final"]);
+export const visualizationStreamStatusSchema = z.enum(["ok", "error"]);
+const looseRecordSchema = z.record(z.string(), z.unknown());
+const looseArraySchema = z.array(z.unknown());
+export const uiStreamHostContextSchema = z.object({
+  mode: uiStreamModeSchema,
+  streamId: z.string().min(1),
+  intermediateResultPatches: z.boolean(),
+  partialInput: z.boolean()
+});
+export const visualizationStreamEnvelopeSchema = z.object({
+  streamId: z.string().min(1),
+  sequence: z.number().int().nonnegative(),
+  frameType: visualizationStreamFrameTypeSchema,
+  phase: visualizationStreamPhaseSchema,
+  status: visualizationStreamStatusSchema,
+  message: z.string().optional(),
+  spec: looseRecordSchema.optional(),
+  checkpoint: looseRecordSchema.optional()
+});
+export const uiStreamCallToolResultSchema = z.object({
+  content: looseArraySchema.optional(),
+  structuredContent: looseRecordSchema.optional(),
+  isError: z.boolean().optional(),
+  _meta: looseRecordSchema.optional()
+}).passthrough();
+export const uiStreamResultPatchNotificationSchema = z.object({
+  method: z.literal(UI_STREAM_RESULT_PATCH_METHOD),
+  params: uiStreamCallToolResultSchema
+});
+export const serverStreamResultPatchNotificationSchema = z.object({
+  method: z.literal(SERVER_STREAM_RESULT_PATCH_METHOD),
+  params: z.object({
+    streamToken: z.string().min(1),
+    result: uiStreamCallToolResultSchema
+  })
+});
+export function getUiStreamHostContext(hostContext) {
+  const candidate = hostContext?.[UI_STREAM_HOST_CONTEXT_KEY];
+  const parsed = uiStreamHostContextSchema.safeParse(candidate);
+  return parsed.success ? parsed.data : undefined;
+}
+export function getVisualizationStreamEnvelope(structuredContent) {
+  if (!structuredContent || typeof structuredContent !== "object" || Array.isArray(structuredContent)) {
+    return;
+  }
+  const candidate = structuredContent[UI_STREAM_STRUCTURED_CONTENT_KEY];
+  const parsed = visualizationStreamEnvelopeSchema.safeParse(candidate);
+  return parsed.success ? parsed.data : undefined;
+}

package/extensions/dm-mcp-adapter/dist/ui-tool-visibility.js

@@ -0,0 +1,26 @@
+export function extractUiToolVisibility(meta) {
+  if (!meta || typeof meta !== "object")
+    return;
+  const ui = meta.ui;
+  if (!ui || typeof ui !== "object" || Array.isArray(ui))
+    return;
+  const visibility = ui.visibility;
+  if (visibility === undefined)
+    return;
+  if (!Array.isArray(visibility))
+    return [];
+  const values = [];
+  for (const entry of visibility) {
+    if (entry !== "model" && entry !== "app")
+      return [];
+    if (!values.includes(entry))
+      values.push(entry);
+  }
+  return values;
+}
+export function isUiToolVisibleToModel(visibility) {
+  return visibility === undefined || visibility.includes("model");
+}
+export function isUiToolCallableByApp(visibility) {
+  return visibility === undefined || visibility.includes("app");
+}