@fitchmultz/pi-mcp-adapter 5.0.0 → 6.0.0

package/tool-loader.ts

@@ -0,0 +1,153 @@
+import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Type, type TSchema } from "typebox";
+import { createDirectToolExecutor, directToolSelection } from "./direct-tools.ts";
+import { isServerCacheValid, reconstructToolMetadata, type MetadataCache } from "./metadata-cache.ts";
+import type { McpExtensionState } from "./state.ts";
+import { createMcpDirectToolCallRenderer, renderMcpToolResult } from "./tool-result-renderer.ts";
+import { isServerDisabled, type DirectToolSpec, type McpAdapterOptions, type McpConfig, type ToolMetadata } from "./types.ts";
+import { normalizeDirectToolInputSchema } from "./utils.ts";
+import { isToolCallApprovalRequired } from "./tool-approval.ts";
+
+type Reference = { name: string; namespace?: string };
+type Selection = { server: string; tool: string };
+type SearchDefinition<TParams extends TSchema, TDetails> = Omit<ToolDefinition<TParams, TDetails>, "execute"> & {
+  execute: (...args: Parameters<ToolDefinition<TParams, TDetails>["execute"]>) => Promise<AgentToolResult<TDetails> & { tools: Reference[] }>;
+};
+// Optional fork APIs; official Pi uses the same loader as an ordinary tool.
+export type SearchAPI = ExtensionAPI & {
+  registerToolSearch?: <TParams extends TSchema, TDetails>(definition: SearchDefinition<TParams, TDetails>) => void;
+  getActiveToolReferences?: () => Reference[];
+  setActiveToolReferences?: (tools: Reference[]) => void;
+};
+const ENTRY = "mcp-tool-selection";
+const key = (value: Selection) => JSON.stringify([value.server, value.tool]);
+const refKey = (value: Reference) => JSON.stringify([value.namespace ?? null, value.name]);
+const reserved = new Set(["read", "bash", "powershell", "edit", "write", "grep", "find", "ls", "mcp", "mcp_search", "mcp_script"]);
+
+export function supportsNativeAsync(ctx: ExtensionContext): boolean {
+  const compat = ctx.model?.compat;
+  return "getPendingToolCalls" in ctx && typeof ctx.getPendingToolCalls === "function"
+    && !!compat && "supportsAsyncTools" in compat && compat.supportsAsyncTools === true;
+}
+
+export function createToolLoader(
+  pi: SearchAPI,
+  getState: () => McpExtensionState | null,
+  getInitPromise: () => Promise<McpExtensionState> | null,
+  beforeExecute?: McpAdapterOptions["beforeExecute"],
+) {
+  const native = typeof pi.registerToolSearch === "function"
+    && typeof pi.getActiveToolReferences === "function"
+    && typeof pi.setActiveToolReferences === "function";
+  pi.registerEntryRenderer(ENTRY, () => undefined);
+  const registered = new Map<string, { selection: Selection; ref: Reference; fingerprint: string; pinned: boolean }>();
+  let available = new Set<string>();
+  let selected = new Map<string, Selection>();
+  let inactive = new Map<string, Selection>();
+  let restoring = true;
+  const active = (): Reference[] => native ? pi.getActiveToolReferences!() : pi.getActiveTools().map(name => ({ name }));
+  const setActive = (refs: Reference[]) => {
+    const unique = [...new Map(refs.map(ref => [refKey(ref), ref])).values()];
+    if (JSON.stringify(active()) === JSON.stringify(unique)) return;
+    if (native) pi.setActiveToolReferences!(unique);
+    else pi.setActiveTools(unique.map(ref => ref.name));
+  };
+  function capture() {
+    const current = new Set(active().map(refKey));
+    for (const [id, { selection, ref, pinned }] of registered) {
+      if (!available.has(id)) continue;
+      if (current.has(refKey(ref))) { if (!pinned) selected.set(id, selection); inactive.delete(id); }
+      else { selected.delete(id); if (pinned) inactive.set(id, selection); }
+    }
+  }
+  function persist() {
+    capture();
+    pi.appendEntry(ENTRY, { selected: [...selected.values()], inactive: [...inactive.values()] });
+  }
+  function restore(ctx: ExtensionContext) {
+    selected = new Map();
+    inactive = new Map();
+    for (const entry of ctx.sessionManager.getBranch()) {
+      if (entry.type !== "custom" || entry.customType !== ENTRY || !entry.data || typeof entry.data !== "object") continue;
+      const data = entry.data as { selected?: Selection[]; inactive?: Selection[] };
+      for (const [field, target] of [[data.selected, selected], [data.inactive, inactive]] as const) {
+        target.clear();
+        for (const selection of Array.isArray(field) ? field : []) {
+          if (typeof selection?.server === "string" && typeof selection.tool === "string") target.set(key(selection), selection);
+        }
+      }
+    }
+    restoring = true;
+  }
+  function sync(config: McpConfig, cache: MetadataCache | null, env?: string[] | null, asyncSupported = false, registerGateways?: (pins: DirectToolSpec[]) => void) {
+    if (!restoring) capture();
+    const previousRefs = new Set([...registered.values()].map(item => refKey(item.ref)));
+    const existing = new Set(pi.getAllTools().map(tool => refKey(tool)));
+    const specs: Array<{ spec: DirectToolSpec; selection: Selection; ref: Reference; pinned: boolean }> = [];
+    for (const [server, definition] of Object.entries(env === null ? {} : config.mcpServers)) {
+      if (isServerDisabled(definition)) continue;
+      const entry = cache?.servers[server];
+      const metadata = getState()?.toolMetadata.get(server) ?? (entry && isServerCacheValid(entry, definition)
+        ? reconstructToolMetadata(server, entry, config.settings?.toolPrefix ?? "server", definition) : []);
+      const selection = directToolSelection(config, server, env ?? undefined);
+      for (const { name: prefixedName, ...tool } of metadata) {
+        if (tool.resourceUri) continue;
+        const pinned = selection === true || (Array.isArray(selection) && selection.includes(tool.originalName));
+        const ref = native && !pinned ? { namespace: `mcp_${server}`, name: tool.originalName } : { name: prefixedName };
+        specs.push({ spec: { ...tool, prefixedName, serverName: server }, selection: { server, tool: tool.originalName }, ref, pinned });
+      }
+    }
+    const counts = new Map<string, number>();
+    for (const { ref } of specs) counts.set(refKey(ref), (counts.get(refKey(ref)) ?? 0) + 1);
+    available = new Set();
+    const enabled: Reference[] = [];
+    for (const { spec, selection, ref, pinned } of specs) {
+      const id = key(selection);
+      const refId = refKey(ref);
+      if ((!ref.namespace && reserved.has(ref.name)) || counts.get(refId)! > 1 || (existing.has(refId) && !previousRefs.has(refId))) continue;
+      available.add(id);
+      const asyncTool = asyncSupported && !beforeExecute && !spec.uiResourceUri && !isToolCallApprovalRequired(config, spec.serverName, spec);
+      const fingerprint = JSON.stringify({ spec, ref, asyncTool });
+      if (registered.get(id)?.fingerprint !== fingerprint) {
+        pi.registerTool({
+          ...ref,
+          ...(asyncTool ? { async: true } : {}),
+          ...(beforeExecute ? { executionMode: "sequential" as const } : {}),
+          label: spec.title ?? `MCP: ${spec.originalName}`,
+          description: spec.description || "(no description)",
+          parameters: Type.Unsafe<Record<string, unknown>>(normalizeDirectToolInputSchema(spec.inputSchema)),
+          execute: createDirectToolExecutor(getState, getInitPromise, spec, beforeExecute),
+          renderCall: createMcpDirectToolCallRenderer(spec.prefixedName),
+          renderResult: renderMcpToolResult,
+        });
+      }
+      registered.set(id, { selection, ref, fingerprint, pinned });
+      if (selected.has(id) || (pinned && !inactive.has(id))) enabled.push(ref);
+    }
+    const permitted = new Set(pi.getAllTools().map(refKey));
+    const pins = specs.filter(item => item.pinned && available.has(key(item.selection)) && permitted.has(refKey(item.ref))).map(item => item.spec);
+    registerGateways?.(pins);
+    // Official 0.87 reactivates allowlisted definitions on registration. Apply our loadout last.
+    const ownedRefs = new Set([...previousRefs, ...[...registered.values()].map(item => refKey(item.ref))]);
+    setActive([...active().filter(ref => !ownedRefs.has(refKey(ref))), ...enabled]);
+    restoring = false;
+    return pins;
+  }
+  function activate(matches: Array<{ server: string; tool: ToolMetadata }>) {
+    const requested = matches.flatMap(({ server, tool }) => {
+      const id = key({ server, tool: tool.originalName });
+      const registration = available.has(id) ? registered.get(id) : undefined;
+      return registration ? [registration] : [];
+    });
+    // No await between reading and extending the current loadout: parallel searches union their selections.
+    setActive([...active(), ...requested.map(item => item.ref)]);
+    const current = new Set(active().map(refKey));
+    const tools = requested.filter(item => current.has(refKey(item.ref))).map(({ selection, ref }) => {
+      selected.set(key(selection), selection);
+      return ref;
+    });
+    persist();
+    return tools;
+  }
+  return { native, restore, sync, activate, persist, selectedServers: () => [...new Set([...selected.values()].map(item => item.server))] };
+}

package/tool-metadata.ts

@@ -1,7 +1,7 @@
 import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
 import type { McpExtensionState } from "./state.ts";
 import type { ToolMetadata, McpTool, McpResource, ServerEntry, ToolPrefix } from "./types.ts";
-import { formatToolName, isToolAllowed, resolveToolPrefix } from "./types.ts";
+import { formatToolName, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.ts";
 import { resourceNameToToolName } from "./resource-tools.ts";
 import { extractToolUiStreamMode } from "./utils.ts";
 import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.ts";
@@ -15,7 +15,7 @@ export function buildToolMetadata(
 ): { metadata: ToolMetadata[]; failedTools: string[] } {
   const metadata: ToolMetadata[] = [];
   const failedTools: string[] = [];
-  const seenNames = new Set<string>();
+  if (isServerDisabled(definition)) return { metadata, failedTools };
   const effectivePrefix = resolveToolPrefix(definition, prefix);
 
   for (const tool of tools) {
@@ -28,16 +28,11 @@ export function buildToolMetadata(
     }
 
     const name = formatToolName(tool.name, serverName, effectivePrefix);
-    if (seenNames.has(name)) {
-      continue;
-    }
 
     const uiVisibility = extractUiToolVisibility(tool._meta);
     if (!isUiToolVisibleToModel(uiVisibility)) {
       continue;
     }
-    seenNames.add(name);
-
     let uiResourceUri: string | undefined;
     try {
       uiResourceUri = getToolUiResourceUri({ _meta: tool._meta });
@@ -46,11 +41,10 @@ export function buildToolMetadata(
     }
     const uiStreamMode = extractToolUiStreamMode(tool._meta);
     metadata.push({
+      ...tool,
       name,
       originalName: tool.name,
       description: tool.description ?? "",
-      ...(tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {}),
-      ...(tool.annotations !== undefined ? { annotations: tool.annotations } : {}),
       ...(uiResourceUri !== undefined ? { uiResourceUri } : {}),
       ...(uiVisibility !== undefined ? { uiVisibility } : {}),
       ...(uiStreamMode !== undefined ? { uiStreamMode } : {}),
@@ -59,22 +53,20 @@ export function buildToolMetadata(
 
   if (definition.exposeResources !== false) {
     for (const resource of resources) {
+      if (!resource?.name || !resource?.uri) continue;
       const baseName = `read_${resourceNameToToolName(resource.name)}`;
       if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools)) {
         continue;
       }
 
       const name = formatToolName(baseName, serverName, effectivePrefix);
-      if (seenNames.has(name)) {
-        continue;
-      }
-      seenNames.add(name);
 
       metadata.push({
         name,
         originalName: baseName,
         description: resource.description ?? `Read resource: ${resource.uri}`,
         resourceUri: resource.uri,
+        resourceDescriptor: resource,
       });
     }
   }
@@ -85,17 +77,30 @@ export function buildToolMetadata(
 export function totalToolCount(state: McpExtensionState): number {
   let count = 0;
   for (const metadata of state.toolMetadata.values()) {
-    count += metadata.length;
+    count += metadata.filter(tool => tool.resourceUri === undefined).length;
   }
   return count;
 }
 
+export function toToolDescriptor(server: string, tool: ToolMetadata) {
+  const { name: path, originalName: name, resourceUri: _resourceUri, resourceDescriptor: _resourceDescriptor, uiResourceUri: _uiResourceUri, uiVisibility: _uiVisibility, uiStreamMode: _uiStreamMode, ...descriptor } = tool;
+  return { ...descriptor, server, path, name };
+}
+
+export function catalogCoverage(state: McpExtensionState, server?: string) {
+  const servers = Object.keys(state.config.mcpServers).filter(name => (!server || name === server) && !isServerDisabled(state.config.mcpServers[name]));
+  const knownServers = servers.filter(name => state.toolMetadata.has(name));
+  const unknownServers = servers.filter(name => !state.toolMetadata.has(name));
+  return { complete: unknownServers.length === 0, knownServers, unknownServers };
+}
+
 export function findToolByName(metadata: ToolMetadata[] | undefined, toolName: string): ToolMetadata | undefined {
   if (!metadata) return undefined;
-  const exact = metadata.find(m => m.name === toolName);
-  if (exact) return exact;
+  const exact = metadata.filter(m => m.name === toolName);
+  if (exact.length > 0) return exact.length === 1 ? exact[0] : undefined;
   const normalized = toolName.replace(/-/g, "_");
-  return metadata.find(m => m.name.replace(/-/g, "_") === normalized);
+  const matches = metadata.filter(m => m.name.replace(/-/g, "_") === normalized);
+  return matches.length === 1 ? matches[0] : undefined;
 }
 
 export function formatSchema(schema: unknown, indent = "  "): string {

package/tool-registrar.ts

@@ -1,8 +1,7 @@
-// tool-registrar.ts - MCP content transformation
-// NOTE: Tools are NOT registered with Pi - only the unified `mcp` proxy tool is registered.
-// This keeps the LLM context small (1 tool instead of 100s).
+// MCP protocol content to model-visible content.
 
 import type { McpContent, ContentBlock } from "./types.ts";
+import { formatMcpPayloadFile, type McpPayloadFile } from "./mcp-output-guard.ts";
 
 /**
  * Transform MCP content types to Pi content blocks.
@@ -21,7 +20,7 @@ export function transformMcpContent(content: McpContent[]): ContentBlock[] {
     }
     if (c.type === "resource") {
       const resourceUri = c.resource?.uri ?? "(no URI)";
-      const resourceContent = c.resource?.text ?? (c.resource ? JSON.stringify(c.resource) : "(no content)");
+      const resourceContent = c.resource?.text ?? (c.resource?.blob !== undefined ? "[Binary content; not rendered]" : "(no content)");
       return {
         type: "text" as const,
         text: `[Resource: ${resourceUri}]\n${resourceContent}`,
@@ -38,26 +37,32 @@ export function transformMcpContent(content: McpContent[]): ContentBlock[] {
     if (c.type === "audio") {
       return {
         type: "text" as const,
-        text: `[Audio content: ${c.mimeType ?? "audio/*"}]`,
+        text: `[Audio content: ${c.mimeType ?? "audio/*"}; not rendered]`,
       };
     }
     return { type: "text" as const, text: JSON.stringify(c) };
   });
 }
 
-/**
- * Resolve a tool result's content blocks, falling back to structuredContent
- * when content is empty.
- */
+/** Human content and structured content are complementary protocol fields. */
 export function resolveMcpResultContent(result: Record<string, unknown>): ContentBlock[] {
   const blocks = transformMcpContent((Array.isArray(result.content) ? result.content : []) as McpContent[]);
-  if (blocks.length > 0) return blocks;
-
   if (result.structuredContent !== undefined) {
-    return [{ type: "text" as const, text: stringifyStructuredContent(result.structuredContent) }];
+    blocks.push({ type: "text", text: stringifyStructuredContent(result.structuredContent) });
   }
+  return blocks;
+}
 
-  return [];
+/** Persist content the model cannot consume; never imply an audio/blob payload was rendered. */
+export function renderMcpResultContent(result: Record<string, unknown>, payloadFiles: McpPayloadFile[] = []): ContentBlock[] {
+  const content: McpContent[] = Array.isArray(result.contents)
+    ? result.contents.map(resource => typeof resource.text === "string" ? { type: "text", text: resource.text } : { type: "resource", resource })
+    : Array.isArray(result.content) ? result.content : [];
+  const rendered = content.map((block, index) => {
+    const file = payloadFiles.find(file => file.index === index);
+    return file ? { type: "text" as const, text: formatMcpPayloadFile(file) } : block;
+  });
+  return resolveMcpResultContent({ ...result, content: rendered });
 }
 
 function stringifyStructuredContent(value: unknown): string {

package/tool-result-renderer.ts

@@ -17,6 +17,9 @@ export interface McpProxyToolCallInput {
   connect?: string;
   describe?: string;
   search?: string;
+  query?: string;
+  uri?: string;
+  ref?: string;
   includeSchemas?: boolean;
   server?: string;
   action?: string;
@@ -112,7 +115,13 @@ export function formatMcpProxyToolCallLines(
   args: McpProxyToolCallInput,
   maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS,
 ): string[] {
-  if (args.action === "ui-messages") return [`mcp ${args.action}`];
+  if (args.action === "ui-messages" || args.action === "status") return [`mcp ${args.action}`];
+  if (args.action) {
+    const target = args.tool ?? args.query ?? args.uri ?? args.ref;
+    let line = `mcp ${args.action}${target ? ` ${target}` : ""}${args.server ? `${target ? " @" : ""} ${args.server}` : ""}`;
+    if (args.action === "search" && args.includeSchemas === false) line += " (schemas hidden)";
+    return args.action === "call" && args.args ? [line, formatJsonish(args.args, maxInputChars)] : [line];
+  }
 
   if (args.tool) {
     const target = args.server ? `${args.tool} @ ${args.server}` : args.tool;
@@ -132,7 +141,6 @@ export function formatMcpProxyToolCallLines(
   }
 
   if (args.server) return [`mcp list ${args.server}`];
-  if (args.action) return [`mcp ${args.action}`];
 
   return ["mcp status"];
 }

package/types.ts

@@ -30,6 +30,8 @@ export interface McpServerStatusSnapshot {
   readonly name: string;
   readonly status: McpServerRuntimeStatus;
   readonly toolCount: number;
+  /** False means the server has not been discovered, rather than an empty inventory. */
+  readonly catalogKnown?: boolean;
   readonly resourceCount?: number;
   readonly failedAgoSeconds?: number;
   readonly disabled: boolean;
@@ -59,24 +61,12 @@ type SdkResource = ListResourcesResult["resources"][number];
 type SdkPrompt = ListPromptsResult["prompts"][number];
 type SdkPromptArgument = NonNullable<SdkPrompt["arguments"]>[number];
 
-// MCP wire definitions derive their field types from the installed SDK while
-// retaining the adapter's deliberately smaller public surface.
-export interface McpTool {
-  name: SdkTool["name"];
-  title?: SdkTool["title"];
-  description?: SdkTool["description"];
-  inputSchema?: SdkTool["inputSchema"]; // JSON Schema
-  annotations?: SdkTool["annotations"];
-  _meta?: SdkTool["_meta"];
+// Legacy cache records may omit inputSchema; otherwise retain the native descriptor.
+export interface McpTool extends Omit<SdkTool, "inputSchema"> {
+  inputSchema?: SdkTool["inputSchema"];
 }
 
-export interface McpResource {
-  uri: SdkResource["uri"];
-  name: SdkResource["name"];
-  description?: SdkResource["description"];
-  mimeType?: SdkResource["mimeType"];
-  _meta?: SdkResource["_meta"];
-}
+export type McpResource = SdkResource;
 
 export interface McpPromptArgument {
   name: SdkPromptArgument["name"];
@@ -509,7 +499,7 @@ export interface McpSettings {
   /** Freeze direct-tool registration after the initial sync. Automatic metadata updates
    * (reconnects, lazy-connect, tool-list-changed) won't rebuild the system prompt,
    * preserving the prompt-cache prefix. The agent rediscovers explicitly via
-   * mcp({ connect: "server" }). Default: false. */
+   * mcp({ action: "connect", server: "server" }). Default: false. */
   freezeDirectTools?: boolean;
   autoAuth?: boolean;
   sampling?: boolean;
@@ -596,15 +586,14 @@ export interface McpAdapterOptions {
 // Alias for clarity
 export type ServerDefinition = ServerEntry;
 
-export interface ToolMetadata {
+export interface ToolMetadata extends Omit<McpTool, "name" | "description"> {
   name: string;           // Prefixed tool name (e.g., "xcodebuild_list_sims")
   originalName: string;   // Original MCP tool name (e.g., "list_sims")
   description: string;
-  resourceUri?: string;   // For resource tools: the URI to read
+  resourceUri?: string;   // Legacy resource alias; new calls address server + URI.
+  resourceDescriptor?: McpResource;
   uiResourceUri?: string; // For app-enabled tools: the UI resource URI
   uiVisibility?: UiToolVisibility[];
-  inputSchema?: unknown;  // JSON Schema for parameters (stored for describe/errors)
-  annotations?: McpTool["annotations"];
   uiStreamMode?: UiStreamMode;
 }
 
@@ -617,16 +606,9 @@ export interface PromptMetadata {
   arguments: McpPromptArgument[];
 }
 
-export interface DirectToolSpec {
+export interface DirectToolSpec extends Omit<ToolMetadata, "name"> {
   serverName: string;
-  originalName: string;
   prefixedName: string;
-  description: string;
-  inputSchema?: unknown;
-  annotations?: McpTool["annotations"];
-  resourceUri?: string;
-  uiResourceUri?: string;
-  uiStreamMode?: UiStreamMode;
 }
 
 export interface ServerProvenance {
@@ -640,21 +622,14 @@ export interface McpAuthResult {
   message?: string;
 }
 
-export interface CachedTool {
-  name: string;
-  description?: string;
-  inputSchema?: unknown;
-  annotations?: McpTool["annotations"];
+export interface CachedTool extends McpTool {
+  // Version-1 caches stored flattened UI fields instead of the raw _meta.
   uiResourceUri?: string;
   uiVisibility?: UiToolVisibility[];
-  uiStreamMode?: "eager" | "stream-first";
+  uiStreamMode?: UiStreamMode;
 }
 
-export interface CachedResource {
-  uri: string;
-  name: string;
-  description?: string;
-}
+export type CachedResource = McpResource;
 
 export interface CachedPrompt {
   name: string;

package/utils.ts

@@ -274,11 +274,9 @@ export function truncateAtWord(text: string, target: number): string {
 }
 
 export function normalizeDirectToolInputSchema(schema: unknown): Record<string, unknown> {
-  const inputSchema = schema && typeof schema === "object" && !Array.isArray(schema)
-    ? schema as Record<string, unknown>
+  return schema && typeof schema === "object" && !Array.isArray(schema)
+    ? structuredClone(schema) as Record<string, unknown>
     : { type: "object", properties: {} };
-  const { $schema, additionalProperties, ...normalized } = inputSchema;
-  return normalized;
 }
 
 export function formatAuthRequiredMessage(

package/dist/ts-shape.d.ts

@@ -1,2 +0,0 @@
-/** Renders the useful JSON Schema subset as TypeScript, or null for unsupported schemas. */
-export declare function renderTsShape(inputSchema: unknown): string | null;

package/dist/ts-shape.js

@@ -1,147 +0,0 @@
-const UNSUPPORTED_KEYWORDS = ["if", "then", "else", "allOf", "not", "patternProperties", "additionalProperties"];
-/** Renders the useful JSON Schema subset as TypeScript, or null for unsupported schemas. */
-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("\n")}\n\n${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 => Object.hasOwn(schema, keyword));
-}
-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(" | ");
-}