@bitkyc08/opencodex 2.52.0 → 2.53.0

package/src/remote-control/workspace-tool-bridge.ts

@@ -0,0 +1,192 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import type { RemoteWorkspaceCoordinator } from "./workspace-coordinator";
+import {
+  REMOTE_WORKSPACE_DYNAMIC_TOOLS,
+  REMOTE_WORKSPACE_TOOL_NAMESPACE,
+  isRemoteWorkspaceToolName,
+  type RemoteWorkspaceToolName,
+} from "./workspace-tools";
+
+const MAX_BRIDGE_BODY_BYTES = 512 * 1024;
+const MAX_BRIDGE_ACTIVE_REQUESTS = 8;
+function json(body: unknown, status = 200): Response {
+  return Response.json(body, { status, headers: { "cache-control": "no-store" } });
+}
+
+function errorText(value: unknown): string {
+  return (value instanceof Error ? value.message : "Remote Workspace tool failed")
+    .replace(/[^\x20-\x7e\n\t]/g, " ")
+    .slice(0, 4_096);
+}
+
+function record(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+async function readBoundedJson(req: Request): Promise<unknown> {
+  if (!req.body) throw new Error("invalid JSON");
+  const reader = req.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      total += next.value.byteLength;
+      if (total > MAX_BRIDGE_BODY_BYTES) {
+        await reader.cancel("request too large").catch(() => {});
+        throw new Error("request too large");
+      }
+      chunks.push(next.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(body));
+}
+
+export interface RemoteWorkspaceToolBridge {
+  url: string;
+  token: string;
+  stop(): Promise<void>;
+}
+
+/**
+ * Loopback-only bridge used by Hub-owned CLIs whose extension boundary is HTTP.
+ * The random bearer is passed only to the child process. The model sees tool schemas,
+ * never this endpoint or token, and every invocation still goes through the E2EE coordinator.
+ */
+export function startRemoteWorkspaceToolBridge(options: {
+  coordinator: RemoteWorkspaceCoordinator;
+  threadId: string | (() => string);
+  tools: readonly RemoteWorkspaceToolName[];
+  onTool?: (tool: RemoteWorkspaceToolName) => void;
+}): RemoteWorkspaceToolBridge {
+  const token = randomBytes(32).toString("base64url");
+  const toolNames = new Set(options.tools);
+  const definitions = REMOTE_WORKSPACE_DYNAMIC_TOOLS[0].tools.filter(tool => toolNames.has(tool.name));
+  if (definitions.length < 1) throw new Error("Remote Workspace bridge needs at least one tool");
+  const invoke = async (tool: unknown, args: unknown): Promise<{ success: boolean; text: string }> => {
+    if (!isRemoteWorkspaceToolName(tool) || !toolNames.has(tool)) {
+      return { success: false, text: JSON.stringify({ ok: false, error: "unknown Remote Workspace tool" }) };
+    }
+    options.onTool?.(tool);
+    const threadId = typeof options.threadId === "function" ? options.threadId() : options.threadId;
+    if (!threadId) return { success: false, text: JSON.stringify({ ok: false, error: "remote workspace thread is not ready" }) };
+    const result = await options.coordinator.handle({
+      method: "item/tool/call",
+      id: randomUUID(),
+      params: {
+        threadId,
+        turnId: randomUUID(),
+        callId: randomUUID(),
+        namespace: REMOTE_WORKSPACE_TOOL_NAMESPACE,
+        tool,
+        arguments: args,
+      },
+    });
+    return { success: result.result.success, text: result.result.contentItems[0]!.text };
+  };
+  let activeRequests = 0;
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (req.headers.get("origin")) return json({ error: "browser origins are not allowed" }, 403);
+      if (req.headers.get("authorization") !== `Bearer ${token}`) return json({ error: "unauthorized" }, 401);
+      if (req.method !== "POST" || (url.pathname !== "/invoke" && url.pathname !== "/mcp")) {
+        return json({ error: "not found" }, 404);
+      }
+      if (activeRequests >= MAX_BRIDGE_ACTIVE_REQUESTS) return json({ error: "Remote Workspace bridge is busy" }, 429);
+      activeRequests += 1;
+      try {
+        const length = Number(req.headers.get("content-length") ?? "0");
+        if (!Number.isFinite(length) || length > MAX_BRIDGE_BODY_BYTES) return json({ error: "request too large" }, 413);
+        let parsed: unknown;
+        try { parsed = await readBoundedJson(req); }
+        catch (error) {
+          return json({ error: error instanceof Error && error.message === "request too large" ? error.message : "invalid JSON" },
+            error instanceof Error && error.message === "request too large" ? 413 : 400);
+        }
+        const body = record(parsed);
+        if (!body) return json({ error: "invalid request" }, 400);
+
+        if (url.pathname === "/invoke") {
+          try {
+            return json(await invoke(body.tool, body.arguments));
+          } catch (error) {
+            return json({ success: false, text: JSON.stringify({ ok: false, error: errorText(error) }) }, 502);
+          }
+        }
+
+        const id = body.id;
+        const method = body.method;
+        const params = record(body.params) ?? {};
+        if (typeof method !== "string") return json({ jsonrpc: "2.0", id: id ?? null, error: { code: -32_600, message: "invalid MCP request" } });
+        if (method === "notifications/initialized") return new Response(null, { status: 202 });
+        if (method === "initialize") {
+          return json({
+            jsonrpc: "2.0",
+            id: id ?? null,
+            result: {
+              protocolVersion: typeof params.protocolVersion === "string" ? params.protocolVersion : "2025-06-18",
+              capabilities: { tools: { listChanged: false } },
+              serverInfo: { name: "opencodex-remote-workspace", version: "1" },
+            },
+          });
+        }
+        if (method === "ping") return json({ jsonrpc: "2.0", id: id ?? null, result: {} });
+        if (method === "tools/list") {
+          return json({
+            jsonrpc: "2.0",
+            id: id ?? null,
+            result: {
+              tools: definitions.map(tool => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+              })),
+            },
+          });
+        }
+        if (method === "tools/call") {
+          try {
+            const called = await invoke(params.name, params.arguments);
+            return json({
+              jsonrpc: "2.0",
+              id: id ?? null,
+              result: { content: [{ type: "text", text: called.text }], isError: !called.success },
+            });
+          } catch (error) {
+            return json({
+              jsonrpc: "2.0",
+              id: id ?? null,
+              result: { content: [{ type: "text", text: errorText(error) }], isError: true },
+            });
+          }
+        }
+        return json({ jsonrpc: "2.0", id: id ?? null, error: { code: -32_601, message: "MCP method not found" } });
+      } finally {
+        activeRequests -= 1;
+      }
+    },
+  });
+  let stopping: Promise<void> | null = null;
+  return {
+    url: new URL("/", server.url).toString().replace(/\/$/, ""),
+    token,
+    stop() {
+      stopping ??= server.stop(true);
+      return stopping;
+    },
+  };
+}

package/src/responses/code-mode-helper-compat.ts

@@ -31,7 +31,10 @@ function unwrapPatchInput(value: string): string {
  */
 export function compileCodeModeHelperInput(argumentsText: unknown, toolName: string): string {
   if (typeof argumentsText !== "string") return "";
-  if (toolName === "apply_patch") {
+  const helperName = toolName.startsWith("default.")
+    ? toolName.slice("default.".length)
+    : toolName;
+  if (helperName === "apply_patch") {
     const patch = normalizeApplyPatchDelimiters(unwrapPatchInput(argumentsText));
     return `const result = await tools.apply_patch(${JSON.stringify(patch)});\ntext(result);`;
   }
@@ -43,7 +46,7 @@ export function compileCodeModeHelperInput(argumentsText: unknown, toolName: str
   }
   const args: unknown = isPlainObject(parsed) ? { ...parsed } : parsed;
   if (
-    toolName === "shell_command"
+    helperName === "shell_command"
     && isPlainObject(args)
     && typeof args.command === "string"
     && args.cmd === undefined
@@ -51,9 +54,25 @@ export function compileCodeModeHelperInput(argumentsText: unknown, toolName: str
     args.cmd = args.command;
     delete args.command;
   }
-  if (toolName === "write_stdin") {
+  if (helperName === "write_stdin") {
     return `const result = await tools.write_stdin(${JSON.stringify(args)});\ntext(result);`;
   }
+  if (helperName === "view_image") {
+    // Codex code-mode `exec` exposes `tools.view_image({path, detail?})`; the host answers
+    // with a custom_tool_call_output carrying `input_image`, which `image()` surfaces back
+    // to the model. Aliases map onto Codex's `path`/`detail`; anything else is passed as
+    // data so nested validation can reject it.
+    const viewArgs: unknown = isPlainObject(args) ? { ...args } : args;
+    if (isPlainObject(viewArgs)) {
+      for (const alias of ["file_path", "file", "image_path"]) {
+        if (typeof viewArgs.path !== "string" && typeof viewArgs[alias] === "string") {
+          viewArgs.path = viewArgs[alias];
+        }
+        delete viewArgs[alias];
+      }
+    }
+    return `const result = await tools.view_image(${JSON.stringify(viewArgs)});\nif (result && result.image_url) { image(result.image_url); } else { text(result); }`;
+  }
   return `const result = await tools.exec_command(${JSON.stringify(args)});\ntext(result);`;
 }
 

package/src/responses/hosted-tool-policy.ts

@@ -3,7 +3,6 @@ const UNSUPPORTED_HOSTED_TOOLS: ReadonlyArray<{
   match: (model: string, baseUrl?: string) => boolean;
   tools: ReadonlySet<string>;
 }> = [
-  { match: model => model.includes("codex-spark"), tools: new Set(["image_generation", "tool_search"]) },
   {
     match: (model, baseUrl) => model === "grok-4.6"
       && baseUrl?.replace(/\/+$/, "") === "https://opencode.ai/zen/go/v1",

package/src/responses/muse-tool-name-alias.ts

@@ -0,0 +1,379 @@
+import { createHash } from "node:crypto";
+import { wireToolInnerName } from "./tool-name-aliases";
+
+const MUSE_TOOL_NAME_MAX = 64;
+const MUSE_TOOL_NAME_PREFIX = 55;
+const MUSE_TOOL_NAME_HASH_LEN = 8;
+const MUSE_SAFE_NAME = /^[a-zA-Z0-9_-]+$/;
+
+export type MuseToolNameAliases = ReadonlyMap<string, string>;
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+/** Direct Meta Muse / Meta Model Responses host. Path, port, and model id do not matter. */
+export function isMetaAiResponsesDestination(responseUrl: string): boolean {
+  try {
+    return new URL(responseUrl).hostname.toLowerCase() === "api.meta.ai";
+  } catch {
+    return false;
+  }
+}
+
+function sanitizeMuseToolName(name: string): string {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+
+function isPassThroughMuseToolName(name: string): boolean {
+  return name.length >= 1
+    && name.length <= MUSE_TOOL_NAME_MAX
+    && MUSE_SAFE_NAME.test(name)
+    && sanitizeMuseToolName(name) === name;
+}
+
+function hashSuffix(originalName: string, salt: number): string {
+  const hashInput = salt === 0 ? originalName : originalName + "#" + salt;
+  return createHash("sha256").update(hashInput).digest("hex").slice(0, MUSE_TOOL_NAME_HASH_LEN);
+}
+
+/**
+ * Collision-safe wire name for one original tool identity. Pass-through when the name is
+ * already `^[a-zA-Z0-9_-]{1,64}$` and unclaimed; otherwise a 55-char sanitized prefix plus
+ * an 8-hex sha256 of the ORIGINAL name, salted with `original#N` until unique.
+ */
+export function museWireToolName(originalName: string, used?: Set<string>): string {
+  if (isPassThroughMuseToolName(originalName) && !(used?.has(originalName))) {
+    used?.add(originalName);
+    return originalName;
+  }
+  const base = sanitizeMuseToolName(originalName).slice(0, MUSE_TOOL_NAME_PREFIX) || "tool";
+  for (let salt = 0; ; salt++) {
+    const candidate = base + "_" + hashSuffix(originalName, salt);
+    if (!(used?.has(candidate))) {
+      used?.add(candidate);
+      return candidate;
+    }
+  }
+}
+
+/**
+ * Two-phase claim over a declaration-order name list: conforming <=64 names occupy the
+ * collision domain first, then long or charset-unsafe names alias in that same order.
+ * `aliases` is wireName -> originalName for identities that actually changed.
+ */
+export function buildMuseToolNameAliasPlan(originalNames: readonly string[]): {
+  wireByOriginal: Map<string, string>;
+  aliases: Map<string, string>;
+} {
+  const used = new Set<string>();
+  const wireByOriginal = new Map<string, string>();
+  const unique: string[] = [];
+  const seen = new Set<string>();
+  for (const name of originalNames) {
+    if (name.length === 0 || seen.has(name)) continue;
+    seen.add(name);
+    unique.push(name);
+  }
+  for (const name of unique) {
+    if (!isPassThroughMuseToolName(name)) continue;
+    used.add(name);
+    wireByOriginal.set(name, name);
+  }
+  for (const name of unique) {
+    if (wireByOriginal.has(name)) continue;
+    wireByOriginal.set(name, museWireToolName(name, used));
+  }
+  const aliases = new Map<string, string>();
+  for (const [original, wire] of wireByOriginal) {
+    if (wire !== original) aliases.set(wire, original);
+  }
+  return { wireByOriginal, aliases };
+}
+
+function addCollectedName(names: string[], seen: Set<string>, name: string | undefined): void {
+  if (!name || seen.has(name)) return;
+  seen.add(name);
+  names.push(name);
+}
+
+function collectDeclaredToolName(tool: unknown, names: string[], seen: Set<string>): void {
+  addCollectedName(names, seen, wireToolInnerName(tool));
+}
+
+function collectToolChoiceNames(choice: unknown, names: string[], seen: Set<string>): void {
+  if (!isPlainObject(choice)) return;
+  if ((choice.type === "function" || choice.type === "custom") && typeof choice.name === "string") {
+    addCollectedName(names, seen, choice.name);
+    return;
+  }
+  if (choice.type !== "allowed_tools" || !Array.isArray(choice.tools)) return;
+  for (const tool of choice.tools) {
+    if (!isPlainObject(tool)) continue;
+    if (tool.type !== "function" && tool.type !== "custom") continue;
+    if (typeof tool.name === "string") addCollectedName(names, seen, tool.name);
+  }
+}
+
+function collectMuseToolNames(body: unknown): string[] {
+  if (!isPlainObject(body)) return [];
+  const names: string[] = [];
+  const seen = new Set<string>();
+  if (Array.isArray(body.tools)) {
+    for (const tool of body.tools) collectDeclaredToolName(tool, names, seen);
+  }
+  if (Array.isArray(body.input)) {
+    for (const item of body.input) {
+      if (!isPlainObject(item)) continue;
+      if (item.type === "additional_tools" && Array.isArray(item.tools)) {
+        for (const tool of item.tools) collectDeclaredToolName(tool, names, seen);
+        continue;
+      }
+      if (
+        (item.type === "function_call" || item.type === "custom_tool_call")
+        && typeof item.name === "string"
+      ) addCollectedName(names, seen, item.name);
+    }
+  }
+  collectToolChoiceNames(body.tool_choice, names, seen);
+  return names;
+}
+
+function rewriteDeclaredTool(tool: unknown, wireByOriginal: ReadonlyMap<string, string>): unknown {
+  if (!isPlainObject(tool)) return tool;
+  const original = wireToolInnerName(tool);
+  if (!original) return tool;
+  const wire = wireByOriginal.get(original);
+  if (wire === undefined || wire === original) return tool;
+  let next: Record<string, unknown> = tool;
+  if (typeof tool.name === "string" && tool.name === original) {
+    next = { ...next, name: wire };
+  }
+  if (
+    tool.type === "function"
+    && isPlainObject(tool.function)
+    && typeof tool.function.name === "string"
+    && tool.function.name === original
+  ) {
+    next = { ...next, function: { ...tool.function, name: wire } };
+  }
+  return next;
+}
+
+function rewriteToolChoice(choice: unknown, wireByOriginal: ReadonlyMap<string, string>): unknown {
+  if (!isPlainObject(choice)) return choice;
+  if ((choice.type === "function" || choice.type === "custom") && typeof choice.name === "string") {
+    const wire = wireByOriginal.get(choice.name);
+    return wire === undefined || wire === choice.name ? choice : { ...choice, name: wire };
+  }
+  if (choice.type !== "allowed_tools" || !Array.isArray(choice.tools)) return choice;
+  let changed = false;
+  const tools = choice.tools.map(tool => {
+    if (!isPlainObject(tool) || (tool.type !== "function" && tool.type !== "custom")) return tool;
+    if (typeof tool.name !== "string") return tool;
+    const wire = wireByOriginal.get(tool.name);
+    if (wire === undefined || wire === tool.name) return tool;
+    changed = true;
+    return { ...tool, name: wire };
+  });
+  return changed ? { ...choice, tools } : choice;
+}
+
+function rewriteInputItem(item: unknown, wireByOriginal: ReadonlyMap<string, string>): unknown {
+  if (!isPlainObject(item)) return item;
+  if (item.type === "additional_tools" && Array.isArray(item.tools)) {
+    let changed = false;
+    const tools = item.tools.map(tool => {
+      const next = rewriteDeclaredTool(tool, wireByOriginal);
+      changed ||= next !== tool;
+      return next;
+    });
+    return changed ? { ...item, tools } : item;
+  }
+  if (
+    (item.type === "function_call" || item.type === "custom_tool_call")
+    && typeof item.name === "string"
+  ) {
+    const wire = wireByOriginal.get(item.name);
+    return wire === undefined || wire === item.name ? item : { ...item, name: wire };
+  }
+  return item;
+}
+
+/**
+ * Keep restoration inside the caller's per-turn authorization boundary, matching
+ * `authorizedAliases` in namespace-tool-compat. Upstream sees every declaration even when
+ * `tool_choice` narrows what it may call, so a wire name appearing in that catalog is not
+ * on its own evidence that restoring it into an executable client name is permitted.
+ * The selector is already rewritten to wire names here, so it compares against alias keys.
+ */
+function authorizedMuseAliases(
+  aliases: Map<string, string>,
+  toolChoice: unknown,
+): Map<string, string> {
+  if (toolChoice === undefined || toolChoice === "auto" || toolChoice === "required") return aliases;
+  if (toolChoice === "none" || !isPlainObject(toolChoice)) return new Map();
+
+  const authorized = new Set<string>();
+  if (
+    (toolChoice.type === "function" || toolChoice.type === "custom")
+    && typeof toolChoice.name === "string"
+  ) {
+    authorized.add(toolChoice.name);
+  } else if (toolChoice.type === "allowed_tools" && Array.isArray(toolChoice.tools)) {
+    for (const tool of toolChoice.tools) {
+      if (!isPlainObject(tool)) continue;
+      if (tool.type !== "function" && tool.type !== "custom") continue;
+      if (typeof tool.name === "string") authorized.add(tool.name);
+    }
+  } else {
+    // An explicit selector for another tool kind authorizes no function/custom call.
+    return new Map();
+  }
+
+  const kept = new Map<string, string>();
+  for (const [wire, original] of aliases) {
+    if (authorized.has(wire)) kept.set(wire, original);
+  }
+  return kept;
+}
+
+/**
+ * Rewrite function/custom tool identities for the Meta Muse 64-char wire limit.
+ * Arguments, user text, and schema property names stay untouched.
+ */
+export function rewriteMuseToolNamesForUpstream(body: unknown): {
+  body: unknown;
+  aliases: Map<string, string>;
+} {
+  if (!isPlainObject(body)) return { body, aliases: new Map() };
+  const { wireByOriginal, aliases } = buildMuseToolNameAliasPlan(collectMuseToolNames(body));
+  if (aliases.size === 0) return { body, aliases };
+
+  let tools = body.tools;
+  if (Array.isArray(body.tools)) {
+    let changed = false;
+    const rewritten = body.tools.map(tool => {
+      const next = rewriteDeclaredTool(tool, wireByOriginal);
+      changed ||= next !== tool;
+      return next;
+    });
+    if (changed) tools = rewritten;
+  }
+
+  let input = body.input;
+  if (Array.isArray(body.input)) {
+    let changed = false;
+    const rewritten = body.input.map(item => {
+      const next = rewriteInputItem(item, wireByOriginal);
+      changed ||= next !== item;
+      return next;
+    });
+    if (changed) input = rewritten;
+  }
+
+  const toolChoice = rewriteToolChoice(body.tool_choice, wireByOriginal);
+  // Upstream still receives the whole aliased catalog; only what may be restored narrows.
+  const restorable = authorizedMuseAliases(aliases, toolChoice);
+  if (tools === body.tools && input === body.input && toolChoice === body.tool_choice) {
+    return { body, aliases: restorable };
+  }
+  return {
+    body: {
+      ...body,
+      ...(tools !== body.tools ? { tools } : {}),
+      ...(input !== body.input ? { input } : {}),
+      ...(toolChoice !== body.tool_choice ? { tool_choice: toolChoice } : {}),
+    },
+    aliases: restorable,
+  };
+}
+
+/**
+ * Payload shapes whose `name` is a tool identity the client (and the undeclared-tool guard)
+ * reads. `response.function_call_arguments.done` carries the name outside any `function_call`
+ * item, so a hashed alias there would still reach the guard as an undeclared tool.
+ */
+function isMuseToolIdentityType(type: unknown): boolean {
+  return type === "function_call"
+    || type === "custom_tool_call"
+    || type === "function"
+    || type === "custom"
+    || type === "response.function_call_arguments.done"
+    || type === "response.function_call_arguments.delta";
+}
+
+function restoreNamedIdentity(
+  value: Record<string, unknown>,
+  aliases: MuseToolNameAliases,
+): { value: Record<string, unknown>; changed: boolean } {
+  let restored = value;
+  let changed = false;
+  if (isMuseToolIdentityType(value.type) && typeof restored.name === "string") {
+    const original = aliases.get(restored.name);
+    if (original && original !== restored.name) {
+      restored = { ...restored, name: original };
+      changed = true;
+    }
+  }
+  const fn = restored.function;
+  if (
+    restored.type === "function"
+    && isPlainObject(fn)
+    && typeof fn.name === "string"
+  ) {
+    const original = aliases.get(fn.name);
+    if (original && original !== fn.name) {
+      restored = { ...restored, function: { ...fn, name: original } };
+      changed = true;
+    }
+  }
+  return { value: restored, changed };
+}
+
+export function restoreMuseToolNames(
+  value: unknown,
+  aliases: MuseToolNameAliases,
+): { value: unknown; changed: boolean } {
+  if (aliases.size === 0) return { value, changed: false };
+  if (Array.isArray(value)) {
+    let changed = false;
+    const restored = value.map(entry => {
+      const result = restoreMuseToolNames(entry, aliases);
+      changed ||= result.changed;
+      return result.value;
+    });
+    return changed ? { value: restored, changed: true } : { value, changed: false };
+  }
+  if (!isPlainObject(value)) return { value, changed: false };
+
+  let changed = false;
+  const restored: Record<string, unknown> = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const result = restoreMuseToolNames(entry, aliases);
+    restored[key] = result.value;
+    changed ||= result.changed;
+  }
+  const node = changed ? restored : value;
+  const identity = restoreNamedIdentity(node, aliases);
+  if (identity.changed) return { value: identity.value, changed: true };
+  return changed ? { value: restored, changed: true } : { value, changed: false };
+}
+
+export function restoreMuseToolNamesInJson(text: string, aliases: MuseToolNameAliases): string {
+  if (aliases.size === 0) return text;
+  let payload: unknown;
+  try {
+    payload = JSON.parse(text);
+  } catch {
+    return text;
+  }
+  const restored = restoreMuseToolNames(payload, aliases);
+  return restored.changed ? JSON.stringify(restored.value) : text;
+}
+
+export function createMuseToolNameRestoreRewrite(
+  aliases: MuseToolNameAliases,
+): (payload: string) => string {
+  return payload => restoreMuseToolNamesInJson(payload, aliases);
+}