@fitchmultz/pi-mcp-adapter 8.0.6 → 8.0.8

package/dist/tool-loader.js

@@ -1,17 +1,29 @@
 import { Type } from "typebox";
 import { createDirectToolExecutor, directToolSelection } from "./direct-tools.js";
-import { isServerCacheValid, reconstructToolMetadata } from "./metadata-cache.js";
+import { isServerCacheValid, reconstructToolMetadata, } from "./metadata-cache.js";
 import { createMcpDirectToolCallRenderer, renderMcpToolResult } from "./tool-result-renderer.js";
-import { isServerDisabled } from "./types.js";
+import { isServerDisabled, } from "./types.js";
 import { normalizeDirectToolInputSchema } from "./utils.js";
 import { nativeMcpOutputSchema } from "./tool-registrar.js";
 import { toolErrorOverride } from "./error-signal.js";
 const featureNames = { gateway: "mcp", script: "mcp_script" };
 const ENTRY = "mcp-tool-selection";
 const key = (value) => JSON.stringify([value.server, value.tool]);
-const reserved = new Set(["read", "bash", "powershell", "edit", "write", "grep", "find", "ls", "mcp", "mcp_search", "mcp_script"]);
+const reserved = new Set([
+    "read",
+    "bash",
+    "powershell",
+    "edit",
+    "write",
+    "grep",
+    "find",
+    "ls",
+    "mcp",
+    "mcp_search",
+    "mcp_script",
+]);
 export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
-    pi.registerEntryRenderer(ENTRY, () => undefined);
+    pi.registerEntryRenderer(ENTRY, () => { });
     const registered = new Map();
     const fingerprints = new WeakMap();
     let available = new Set();
@@ -25,49 +37,64 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
     const active = () => pi.getActiveTools();
     const setActive = (names) => {
         const unique = [...new Set(names)];
-        if (JSON.stringify(active()) === JSON.stringify(unique))
+        if (JSON.stringify(active()) === JSON.stringify(unique)) {
             return;
+        }
         pi.setActiveTools(unique);
     };
     function registerFeature(feature, definition) {
-        pi.registerTool({ defaultActive: false, ...definition, async execute(...args) {
+        pi.registerTool({
+            defaultActive: false,
+            ...definition,
+            async execute(...args) {
                 const result = await definition.execute(...args);
                 return { ...result, ...toolErrorOverride(result.details) };
-            } });
+            },
+        });
         registeredFeatures.add(feature);
     }
     function capture() {
         const current = new Set(active());
         for (const feature of Object.keys(features)) {
             if (current.has(featureNames[feature])) {
-                if (!features[feature]?.eager)
+                if (!features[feature]?.eager) {
                     selectedFeatures.add(feature);
+                }
                 inactiveFeatures.delete(feature);
             }
             else {
                 selectedFeatures.delete(feature);
-                if (features[feature]?.eager)
+                if (features[feature]?.eager) {
                     inactiveFeatures.add(feature);
+                }
             }
         }
         for (const [id, { selection, name, pinned }] of registered) {
-            if (!available.has(id))
+            if (!available.has(id)) {
                 continue;
+            }
             if (current.has(name)) {
-                if (!pinned)
+                if (!pinned) {
                     selected.set(id, selection);
+                }
                 inactive.delete(id);
             }
             else {
                 selected.delete(id);
-                if (pinned)
+                if (pinned) {
                     inactive.set(id, selection);
+                }
             }
         }
     }
     function persist() {
         capture();
-        pi.appendEntry(ENTRY, { selected: [...selected.values()], inactive: [...inactive.values()], features: [...selectedFeatures], inactiveFeatures: [...inactiveFeatures] });
+        pi.appendEntry(ENTRY, {
+            selected: [...selected.values()],
+            inactive: [...inactive.values()],
+            features: [...selectedFeatures],
+            inactiveFeatures: [...inactiveFeatures],
+        });
     }
     function restore(ctx) {
         selected = new Map();
@@ -79,27 +106,43 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
             let id = manager.getLeafId();
             while (id) {
                 const entry = manager.getEntry(id);
-                if (!entry)
+                if (!entry) {
                     break;
+                }
                 yield entry;
                 id = entry.parentId;
             }
         }
         for (const entry of snapshots()) {
-            if (entry?.type !== "custom" || entry.customType !== ENTRY || !entry.data || typeof entry.data !== "object")
+            if (entry?.type !== "custom" ||
+                entry.customType !== ENTRY ||
+                !entry.data ||
+                typeof entry.data !== "object") {
                 continue;
+            }
             const data = entry.data;
-            if (!Array.isArray(data.selected) || [data.inactive, data.features, data.inactiveFeatures].some(value => value !== undefined && !Array.isArray(value)))
+            if (!Array.isArray(data.selected) ||
+                [data.inactive, data.features, data.inactiveFeatures].some((value) => value !== undefined && !Array.isArray(value))) {
                 continue;
-            if ([...data.selected, ...(data.inactive ?? [])].some(value => !value || typeof value.server !== "string" || typeof value.tool !== "string"))
+            }
+            if ([...data.selected, ...(data.inactive ?? [])].some((value) => !value || typeof value.server !== "string" || typeof value.tool !== "string")) {
                 continue;
-            selectedFeatures = new Set(Array.isArray(data.features) ? data.features.filter(value => value === "gateway" || value === "script") : []);
-            inactiveFeatures = new Set(Array.isArray(data.inactiveFeatures) ? data.inactiveFeatures.filter(value => value === "gateway" || value === "script") : []);
-            for (const [field, target] of [[data.selected, selected], [data.inactive, inactive]]) {
+            }
+            selectedFeatures = new Set(Array.isArray(data.features)
+                ? data.features.filter((value) => value === "gateway" || value === "script")
+                : []);
+            inactiveFeatures = new Set(Array.isArray(data.inactiveFeatures)
+                ? data.inactiveFeatures.filter((value) => value === "gateway" || value === "script")
+                : []);
+            for (const [field, target] of [
+                [data.selected, selected],
+                [data.inactive, inactive],
+            ]) {
                 target.clear();
                 for (const selection of Array.isArray(field) ? field : []) {
-                    if (typeof selection?.server === "string" && typeof selection.tool === "string")
+                    if (typeof selection?.server === "string" && typeof selection.tool === "string") {
                         target.set(key(selection), selection);
+                    }
                 }
             }
             break;
@@ -107,53 +150,86 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
         restoring = true;
     }
     function sync(config, cache, env, registerGateways) {
-        if (!restoring)
+        if (!restoring) {
             capture();
-        const previousNames = new Set([...registered.values()].map(item => item.name));
-        const existing = new Set(pi.getAllTools().map(tool => tool.name));
+        }
+        const previousNames = new Set([...registered.values()].map((item) => item.name));
+        const existing = new Set(pi.getAllTools().map((tool) => tool.name));
         const specs = [];
         for (const [server, definition] of Object.entries(env === null ? {} : config.mcpServers)) {
-            if (isServerDisabled(definition))
+            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 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 source of metadata) {
                 const { name: prefixedName, ...tool } = source;
-                if (tool.resourceUri)
+                if (tool.resourceUri) {
                     continue;
+                }
                 const pinned = selection === true || (Array.isArray(selection) && selection.includes(tool.originalName));
-                specs.push({ spec: { ...tool, prefixedName, serverName: server }, source, selection: { server, tool: tool.originalName }, name: prefixedName, pinned });
+                specs.push({
+                    spec: { ...tool, prefixedName, serverName: server },
+                    source,
+                    selection: { server, tool: tool.originalName },
+                    name: prefixedName,
+                    pinned,
+                });
             }
         }
         const counts = new Map();
-        for (const { name } of specs)
+        for (const { name } of specs) {
             counts.set(name, (counts.get(name) ?? 0) + 1);
+        }
         available = new Set();
         const enabled = [];
         for (const { spec, source, selection, name, pinned } of specs) {
             const id = key(selection);
-            if (reserved.has(name) || counts.get(name) > 1 || (existing.has(name) && !previousNames.has(name)))
+            if (reserved.has(name) ||
+                counts.get(name) > 1 ||
+                (existing.has(name) && !previousNames.has(name))) {
                 continue;
+            }
             available.add(id);
-            const instructions = getState()?.serverInstructions.get(spec.serverName) ?? cache?.servers[spec.serverName]?.instructions;
+            const instructions = getState()?.serverInstructions.get(spec.serverName) ??
+                cache?.servers[spec.serverName]?.instructions;
             const previous = Object.isFrozen(source) ? fingerprints.get(source) : undefined;
             const fingerprint = previous?.server === spec.serverName && previous.instructions === instructions
-                ? previous.value : JSON.stringify({ spec, name, instructions });
-            if (Object.isFrozen(source))
+                ? previous.value
+                : JSON.stringify({ spec, name, instructions });
+            if (Object.isFrozen(source)) {
                 fingerprints.set(source, { server: spec.serverName, instructions, value: fingerprint });
+            }
             if (registered.get(id)?.fingerprint !== fingerprint) {
                 pi.registerTool({
                     name,
-                    namespace: { name: `mcp_${spec.serverName}`, ...(instructions !== undefined ? { instructions } : {}) },
+                    namespace: {
+                        name: `mcp_${spec.serverName}`,
+                        ...(instructions !== undefined ? { instructions } : {}),
+                    },
                     ...(spec.outputSchema ? { outputSchema: nativeMcpOutputSchema(spec.outputSchema) } : {}),
-                    ...(spec.annotations ? { annotations: {
-                            ...(typeof spec.annotations.readOnlyHint === "boolean" ? { readOnlyHint: spec.annotations.readOnlyHint } : {}),
-                            ...(typeof spec.annotations.destructiveHint === "boolean" ? { destructiveHint: spec.annotations.destructiveHint } : {}),
-                            ...(typeof spec.annotations.idempotentHint === "boolean" ? { idempotentHint: spec.annotations.idempotentHint } : {}),
-                            ...(typeof spec.annotations.openWorldHint === "boolean" ? { openWorldHint: spec.annotations.openWorldHint } : {}),
-                        } } : {}),
+                    ...(spec.annotations
+                        ? {
+                            annotations: {
+                                ...(typeof spec.annotations.readOnlyHint === "boolean"
+                                    ? { readOnlyHint: spec.annotations.readOnlyHint }
+                                    : {}),
+                                ...(typeof spec.annotations.destructiveHint === "boolean"
+                                    ? { destructiveHint: spec.annotations.destructiveHint }
+                                    : {}),
+                                ...(typeof spec.annotations.idempotentHint === "boolean"
+                                    ? { idempotentHint: spec.annotations.idempotentHint }
+                                    : {}),
+                                ...(typeof spec.annotations.openWorldHint === "boolean"
+                                    ? { openWorldHint: spec.annotations.openWorldHint }
+                                    : {}),
+                            },
+                        }
+                        : {}),
                     // Inactive direct tools are not callable through codemode or nested execution.
                     defaultActive: false,
                     ...(beforeExecute ? { executionMode: "sequential" } : {}),
@@ -166,21 +242,26 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
                 });
             }
             registered.set(id, { selection, name, fingerprint, pinned });
-            if (selected.has(id) || (pinned && !inactive.has(id)))
+            if (selected.has(id) || (pinned && !inactive.has(id))) {
                 enabled.push(name);
+            }
         }
-        const permitted = new Set(pi.getAllTools().map(tool => tool.name));
-        const pins = specs.filter(item => item.pinned && available.has(key(item.selection)) && permitted.has(item.name)).map(item => item.spec);
+        const permitted = new Set(pi.getAllTools().map((tool) => tool.name));
+        const pins = specs
+            .filter((item) => item.pinned && available.has(key(item.selection)) && permitted.has(item.name))
+            .map((item) => item.spec);
         const policy = registerGateways?.(pins);
         if (policy) {
-            const permittedFeatures = new Set(pi.getAllTools().map(tool => tool.name));
+            const permittedFeatures = new Set(pi.getAllTools().map((tool) => tool.name));
             const loaderMissing = !permittedFeatures.has("mcp_search");
             features = {};
             for (const feature of Object.keys(featureNames)) {
                 if (policy[feature] && permittedFeatures.has(featureNames[feature])) {
                     features[feature] = { eager: policy[feature].eager || loaderMissing };
-                    if (selectedFeatures.has(feature) || (features[feature]?.eager && !inactiveFeatures.has(feature)))
+                    if (selectedFeatures.has(feature) ||
+                        (features[feature]?.eager && !inactiveFeatures.has(feature))) {
                         enabled.push(featureNames[feature]);
+                    }
                 }
                 else {
                     selectedFeatures.delete(feature);
@@ -189,10 +270,14 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
             }
         }
         // Retain the journal: official 1.0 initial SDK resume has a native loadout restoration gap.
-        const ownedNames = new Set([...previousNames, ...[...registered.values()].map(item => item.name)]);
-        for (const feature of registeredFeatures)
+        const ownedNames = new Set([
+            ...previousNames,
+            ...[...registered.values()].map((item) => item.name),
+        ]);
+        for (const feature of registeredFeatures) {
             ownedNames.add(featureNames[feature]);
-        setActive([...active().filter(name => !ownedNames.has(name)), ...enabled]);
+        }
+        setActive([...active().filter((name) => !ownedNames.has(name)), ...enabled]);
         restoring = false;
         return pins;
     }
@@ -203,22 +288,36 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
             return registration ? [registration] : [];
         });
         // No await between reading and extending the current loadout: parallel searches union their selections.
-        const permitted = new Set(pi.getAllTools().map(tool => tool.name));
-        const requestedFeatures = [...new Set(enable)].filter(feature => features[feature] && permitted.has(featureNames[feature]));
-        setActive([...active(), ...requested.map(item => item.name), ...requestedFeatures.map(feature => featureNames[feature])]);
+        const permitted = new Set(pi.getAllTools().map((tool) => tool.name));
+        const requestedFeatures = [...new Set(enable)].filter((feature) => features[feature] && permitted.has(featureNames[feature]));
+        setActive([
+            ...active(),
+            ...requested.map((item) => item.name),
+            ...requestedFeatures.map((feature) => featureNames[feature]),
+        ]);
         const current = new Set(active());
-        const tools = requested.filter(item => current.has(item.name)).map(({ selection, name }) => {
+        const tools = requested
+            .filter((item) => current.has(item.name))
+            .map(({ selection, name }) => {
             selected.set(key(selection), selection);
             return { name };
         });
         for (const feature of requestedFeatures) {
-            if (!current.has(featureNames[feature]))
+            if (!current.has(featureNames[feature])) {
                 continue;
+            }
             selectedFeatures.add(feature);
             tools.push({ name: featureNames[feature] });
         }
         persist();
         return tools;
     }
-    return { registerFeature, restore, sync, activate, persist, selectedServers: () => [...new Set([...selected.values()].map(item => item.server))] };
+    return {
+        registerFeature,
+        restore,
+        sync,
+        activate,
+        persist,
+        selectedServers: () => [...new Set([...selected.values()].map((item) => item.server))],
+    };
 }

package/dist/tool-metadata.d.ts

@@ -1,5 +1,5 @@
 import type { McpExtensionState } from "./state.ts";
-import type { ToolMetadata, McpTool, McpResource, ServerEntry, ToolPrefix } from "./types.ts";
+import { type ToolMetadata, type McpTool, type McpResource, type ServerEntry, type ToolPrefix } from "./types.ts";
 export declare function buildToolMetadata(tools: McpTool[], resources: McpResource[], definition: ServerEntry, serverName: string, prefix: ToolPrefix): {
     metadata: ToolMetadata[];
     failedTools: string[];

package/dist/tool-metadata.js

@@ -1,11 +1,12 @@
-import { formatToolName, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
+import { formatToolName, isServerDisabled, isToolAllowed, resolveToolPrefix, } from "./types.js";
 import { extractToolUiStreamMode } from "./utils.js";
 import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.js";
 export function buildToolMetadata(tools, resources, definition, serverName, prefix) {
     const metadata = [];
     const failedTools = [];
-    if (isServerDisabled(definition))
+    if (isServerDisabled(definition)) {
         return { metadata, failedTools };
+    }
     const effectivePrefix = resolveToolPrefix(definition, prefix);
     for (const tool of tools) {
         if (!tool?.name) {
@@ -25,10 +26,12 @@ export function buildToolMetadata(tools, resources, definition, serverName, pref
             // MCP Apps metadata must also be readable from the cache before loading the SDK.
             const uri = tool._meta?.ui?.resourceUri;
             const resourceUri = uri === undefined ? tool._meta?.["ui/resourceUri"] : uri;
-            if (typeof resourceUri === "string" && resourceUri.startsWith("ui://"))
+            if (typeof resourceUri === "string" && resourceUri.startsWith("ui://")) {
                 uiResourceUri = resourceUri;
-            else if (resourceUri !== undefined)
+            }
+            else if (resourceUri !== undefined) {
                 failedTools.push(tool.name);
+            }
         }
         catch {
             failedTools.push(tool.name);
@@ -46,8 +49,9 @@ export function buildToolMetadata(tools, resources, definition, serverName, pref
     }
     if (definition.exposeResources !== false) {
         for (const resource of resources) {
-            if (!resource?.name || !resource?.uri)
+            if (!resource?.name || !resource?.uri) {
                 continue;
+            }
             const baseName = `read_${resourceNameToToolName(resource.name)}`;
             if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools)) {
                 continue;
@@ -67,7 +71,7 @@ export function buildToolMetadata(tools, resources, definition, serverName, pref
 export function totalToolCount(state) {
     let count = 0;
     for (const metadata of state.toolMetadata.values()) {
-        count += metadata.filter(tool => tool.resourceUri === undefined).length;
+        count += metadata.filter((tool) => tool.resourceUri === undefined).length;
     }
     return count;
 }
@@ -76,19 +80,21 @@ export function toToolDescriptor(server, tool) {
     return { ...descriptor, server, path, name };
 }
 export function catalogCoverage(state, server) {
-    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));
+    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, toolName) {
-    if (!metadata)
+    if (!metadata) {
         return undefined;
-    const exact = metadata.filter(m => m.name === toolName);
-    if (exact.length > 0)
+    }
+    const exact = metadata.filter((m) => m.name === toolName);
+    if (exact.length > 0) {
         return exact.length === 1 ? exact[0] : undefined;
+    }
     const normalized = toolName.replace(/-/g, "_");
-    const matches = metadata.filter(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, indent = "  ") {
@@ -96,9 +102,14 @@ export function formatSchema(schema, indent = "  ") {
         return `${indent}(no schema)`;
     }
     const s = schema;
-    if (s.type === "object" && s.properties && typeof s.properties === "object" && !Array.isArray(s.properties)) {
+    if (s.type === "object" &&
+        s.properties &&
+        typeof s.properties === "object" &&
+        !Array.isArray(s.properties)) {
         const props = s.properties;
-        const required = Array.isArray(s.required) ? s.required.filter((name) => typeof name === "string") : [];
+        const required = Array.isArray(s.required)
+            ? s.required.filter((name) => typeof name === "string")
+            : [];
         if (Object.keys(props).length === 0) {
             return `${indent}(no parameters)`;
         }
@@ -125,10 +136,12 @@ function formatProperty(name, schema, required, indent) {
     const s = schema;
     const parts = [`${indent}${name}`];
     const typeStr = formatType(s);
-    if (typeStr)
+    if (typeStr) {
         parts.push(`(${typeStr})`);
-    if (required)
+    }
+    if (required) {
         parts.push("*required*");
+    }
     appendSchemaAnnotations(parts, s);
     return [parts.join(" "), ...formatNestedSchema(s, `${indent}  `)];
 }
@@ -143,8 +156,12 @@ function formatNestedSchema(schema, indent) {
     if (schema.items !== undefined) {
         lines.push(...formatProperty("items", schema.items, false, indent));
     }
-    if (schema.properties && typeof schema.properties === "object" && !Array.isArray(schema.properties)) {
-        const required = Array.isArray(schema.required) ? schema.required.filter((name) => typeof name === "string") : [];
+    if (schema.properties &&
+        typeof schema.properties === "object" &&
+        !Array.isArray(schema.properties)) {
+        const required = Array.isArray(schema.required)
+            ? schema.required.filter((name) => typeof name === "string")
+            : [];
         for (const [name, propSchema] of Object.entries(schema.properties)) {
             lines.push(...formatProperty(name, propSchema, required.includes(name), indent));
         }
@@ -172,15 +189,17 @@ function formatType(schema) {
         return `const ${JSON.stringify(schema.const)}`;
     }
     if (Array.isArray(schema.enum)) {
-        return `enum: ${schema.enum.map(v => JSON.stringify(v)).join(", ")}`;
+        return `enum: ${schema.enum.map((v) => JSON.stringify(v)).join(", ")}`;
     }
     if (Array.isArray(schema.type)) {
-        return schema.type.map(type => String(type)).join(" | ");
+        return schema.type.map((type) => String(type)).join(" | ");
     }
     if (schema.type) {
         return String(schema.type);
     }
-    if (schema.properties && typeof schema.properties === "object" && !Array.isArray(schema.properties)) {
+    if (schema.properties &&
+        typeof schema.properties === "object" &&
+        !Array.isArray(schema.properties)) {
         return "object";
     }
     if (schema.items !== undefined) {
@@ -192,7 +211,16 @@ function appendSchemaAnnotations(parts, schema) {
     if (schema.description && typeof schema.description === "string") {
         parts.push(`- ${schema.description}`);
     }
-    for (const key of ["minLength", "maxLength", "minimum", "maximum", "minItems", "maxItems", "format", "pattern"]) {
+    for (const key of [
+        "minLength",
+        "maxLength",
+        "minimum",
+        "maximum",
+        "minItems",
+        "maxItems",
+        "format",
+        "pattern",
+    ]) {
         if (schema[key] !== undefined) {
             parts.push(`[${key}: ${JSON.stringify(schema[key])}]`);
         }

package/dist/tool-registrar.js

@@ -4,13 +4,16 @@ import { Type } from "typebox";
 import { toolErrorOverride } from "./error-signal.js";
 /** Overflow/not-run outcomes are receipts, never a fabricated server-schema result. */
 export function nativeMcpOutputSchema(schema) {
-    return Type.Union([Type.Unsafe(schema), Type.Object({
+    return Type.Union([
+        Type.Unsafe(schema),
+        Type.Object({
             mcpAdapter: Type.Object({
                 omitted: Type.Literal(true),
                 resultRef: Type.Optional(Type.String()),
                 error: Type.Optional(Type.String()),
             }),
-        })]);
+        }),
+    ]);
 }
 export function nativeMcpResult(result, structured = false) {
     const { details } = result;
@@ -18,16 +21,30 @@ export function nativeMcpResult(result, structured = false) {
     return {
         ...result,
         ...toolErrorOverride(details),
-        ...(structured ? { structuredContent: !details.outputGuard && (!details.error || details.error === "tool_error") && raw?.structuredContent !== undefined
-                ? raw.structuredContent
-                : { mcpAdapter: { omitted: true, ...(typeof details.resultRef === "string" ? { resultRef: details.resultRef } : {}), ...(typeof details.error === "string" ? { error: details.error } : {}) } } } : {}),
+        ...(structured
+            ? {
+                structuredContent: !details.outputGuard &&
+                    (!details.error || details.error === "tool_error") &&
+                    raw?.structuredContent !== undefined
+                    ? raw.structuredContent
+                    : {
+                        mcpAdapter: {
+                            omitted: true,
+                            ...(typeof details.resultRef === "string"
+                                ? { resultRef: details.resultRef }
+                                : {}),
+                            ...(typeof details.error === "string" ? { error: details.error } : {}),
+                        },
+                    },
+            }
+            : {}),
     };
 }
 /**
  * Transform MCP content types to Pi content blocks.
  */
 export function transformMcpContent(content) {
-    return content.map(c => {
+    return content.map((c) => {
         if (c.type === "text") {
             return { type: "text", text: c.text ?? "" };
         }
@@ -40,7 +57,8 @@ export function transformMcpContent(content) {
         }
         if (c.type === "resource") {
             const resourceUri = c.resource?.uri ?? "(no URI)";
-            const resourceContent = c.resource?.text ?? (c.resource?.blob !== undefined ? "[Binary content; not rendered]" : "(no content)");
+            const resourceContent = c.resource?.text ??
+                (c.resource?.blob !== undefined ? "[Binary content; not rendered]" : "(no content)");
             return {
                 type: "text",
                 text: `[Resource: ${resourceUri}]\n${resourceContent}`,
@@ -74,10 +92,14 @@ export function resolveMcpResultContent(result) {
 /** Persist content the model cannot consume; never imply an audio/blob payload was rendered. */
 export function renderMcpResultContent(result, payloadFiles = []) {
     const content = 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 : [];
+        ? 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);
+        const file = payloadFiles.find((file) => file.index === index);
         return file ? { type: "text", text: formatMcpPayloadFile(file) } : block;
     });
     return resolveMcpResultContent({ ...result, content: rendered });