mcp-squared 0.6.0 → 0.7.0

package/README.md

@@ -222,6 +222,14 @@ Each capability tool uses a thin router contract:
 
 Every capability tool supports `action = "__describe_actions"` for introspection. This returns capability-local action IDs, summaries, and input schemas without exposing upstream namespace/tool identifiers.
 
+When multiple upstream instances expose the same capability action, MCP² now
+uses stable, instance-aware action IDs such as `create_issue__github_work`
+instead of order-dependent numeric suffixes. `__describe_actions` also includes
+`baseAction`, `instance`, and `instanceTitle` fields for colliding routes so
+clients can distinguish duplicate accounts or environments. Legacy numeric
+aliases such as `create_issue__2` are still accepted during the transition, but
+the instance-aware IDs are the preferred public contract.
+
 Recommended workflow for LLM clients:
 1. Call the relevant capability (for example `code_search`) with `action = "__describe_actions"`.
 2. Select an action ID and call the same capability with `arguments`.

package/dist/index.js

@@ -1530,6 +1530,14 @@ var LoggingSchema = z.object({
 var EmbeddingsSchema = z.object({
   enabled: z.boolean().default(false)
 });
+var ResponseResourceSchema = z.object({
+  enabled: z.boolean().default(false),
+  thresholdBytes: z.number().int().min(1024).default(51200),
+  maxInlineLines: z.number().int().min(1).default(20),
+  maxResources: z.number().int().min(1).default(100),
+  ttlMs: z.number().int().min(0).default(600000)
+});
+var DEFAULT_RESPONSE_RESOURCE_CONFIG = ResponseResourceSchema.parse({});
 var SelectionCacheSchema = z.object({
   enabled: z.boolean().default(true),
   minCooccurrenceThreshold: z.number().int().min(1).default(2),
@@ -1546,6 +1554,7 @@ var OperationsSchema = z.object({
   index: IndexSchema.default({ refreshIntervalMs: 30000 }),
   logging: LoggingSchema.default({ level: "info" }),
   embeddings: EmbeddingsSchema.default({ enabled: false }),
+  responseResource: ResponseResourceSchema.default(DEFAULT_RESPONSE_RESOURCE_CONFIG),
   selectionCache: SelectionCacheSchema.default({
     enabled: true,
     minCooccurrenceThreshold: 2,
@@ -1568,6 +1577,7 @@ var OperationsSchema = z.object({
   index: { refreshIntervalMs: 30000 },
   logging: { level: "info" },
   embeddings: { enabled: false },
+  responseResource: DEFAULT_RESPONSE_RESOURCE_CONFIG,
   selectionCache: {
     enabled: true,
     minCooccurrenceThreshold: 2,
@@ -6490,6 +6500,44 @@ init_inference();
 
 // src/capabilities/routing.ts
 var DESCRIBE_ACTION = "__describe_actions";
+function buildCanonicalRouteId(capability, instanceKey, toolName) {
+  return `${capability}:${instanceKey}:${toolName}`;
+}
+function buildInstanceActionBase(baseAction, instanceToken) {
+  return `${baseAction}__${instanceToken}`;
+}
+function allocateUniqueActionId(emittedActions, actionBase, index) {
+  let candidate = index === 0 ? actionBase : `${actionBase}__${index + 1}`;
+  const suffixMatch = actionBase.match(/^(.*)__(\d+)$/);
+  const dedupeBase = suffixMatch?.[1] ?? actionBase;
+  let dedupe = suffixMatch?.[2] ? Number.parseInt(suffixMatch[2], 10) + 1 : index + 2;
+  while (emittedActions.has(candidate)) {
+    candidate = `${dedupeBase}__${dedupe}`;
+    dedupe += 1;
+  }
+  emittedActions.add(candidate);
+  return candidate;
+}
+function resolveInstanceTokens(records) {
+  const byToken = new Map;
+  for (const record of records) {
+    const instanceKey = record.instanceKey ?? record.serverKey;
+    const token = toActionToken2(instanceKey);
+    const existing = byToken.get(token) ?? [];
+    if (!existing.includes(instanceKey)) {
+      existing.push(instanceKey);
+      existing.sort((a, b) => a.localeCompare(b));
+      byToken.set(token, existing);
+    }
+  }
+  const resolved = new Map;
+  for (const [token, instanceKeys] of [...byToken.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+    instanceKeys.forEach((instanceKey, index) => {
+      resolved.set(instanceKey, index === 0 ? token : `${token}__${index + 1}`);
+    });
+  }
+  return resolved;
+}
 function toActionToken2(value) {
   const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
   return normalized.length > 0 ? normalized : "tool";
@@ -6514,6 +6562,8 @@ function buildCapabilityRouters(inventories, grouping, summarize) {
   const reservedNormalized = toActionToken2(DESCRIBE_ACTION);
   for (const inventory of inventories) {
     const capability = grouping.byNamespace[inventory.namespace] ?? "general";
+    const instanceKey = inventory.namespace;
+    const instanceTitle = inventory.title ?? inventory.namespace;
     const sortedTools = [...inventory.tools].sort((a, b) => a.name.localeCompare(b.name));
     for (const tool of sortedTools) {
       let baseAction = toActionToken2(tool.name);
@@ -6525,8 +6575,12 @@ function buildCapabilityRouters(inventories, grouping, summarize) {
         action: baseAction,
         baseAction,
         serverKey: inventory.namespace,
+        instanceKey,
+        instanceTitle,
         toolName: tool.name,
         qualifiedName: `${inventory.namespace}:${tool.name}`,
+        canonicalRouteId: buildCanonicalRouteId(capability, instanceKey, tool.name),
+        collisionGroupSize: 1,
         inputSchema: tool.inputSchema ?? { type: "object" },
         summary: resolveSummary(tool.description ?? undefined, capability)
       });
@@ -6543,12 +6597,44 @@ function buildCapabilityRouters(inventories, grouping, summarize) {
   const sortedKeys = [...byCapabilityAction.keys()].sort((a, b) => a.localeCompare(b));
   for (const key of sortedKeys) {
     const records = (byCapabilityAction.get(key) ?? []).sort((a, b) => a.qualifiedName.localeCompare(b.qualifiedName));
+    if (records.length === 1) {
+      const [record] = records;
+      if (record) {
+        resolved.push({
+          ...record,
+          action: record.baseAction,
+          collisionGroupSize: 1,
+          legacyActions: []
+        });
+      }
+      continue;
+    }
+    const legacyActionsByQualifiedName = new Map;
     records.forEach((record, index) => {
-      resolved.push({
-        ...record,
-        action: index === 0 ? record.baseAction : `${record.baseAction}__${index + 1}`
-      });
+      legacyActionsByQualifiedName.set(record.qualifiedName, index === 0 ? [] : [`${record.baseAction}__${index + 1}`]);
     });
+    const instanceTokens = resolveInstanceTokens(records);
+    const byInstance = new Map;
+    for (const record of records) {
+      const instanceKey = record.instanceKey ?? record.serverKey;
+      const existing = byInstance.get(instanceKey) ?? [];
+      existing.push(record);
+      byInstance.set(instanceKey, existing);
+    }
+    const emittedActions = new Set;
+    for (const instanceKey of [...byInstance.keys()].sort((a, b) => a.localeCompare(b))) {
+      const instanceRecords = (byInstance.get(instanceKey) ?? []).sort((a, b) => a.qualifiedName.localeCompare(b.qualifiedName));
+      const instanceToken = instanceTokens.get(instanceKey) ?? toActionToken2(instanceKey);
+      const actionBase = buildInstanceActionBase(records[0]?.baseAction ?? "tool", instanceToken);
+      instanceRecords.forEach((record, index) => {
+        resolved.push({
+          ...record,
+          action: allocateUniqueActionId(emittedActions, actionBase, index),
+          collisionGroupSize: records.length,
+          legacyActions: legacyActionsByQualifiedName.get(record.qualifiedName) ?? []
+        });
+      });
+    }
   }
   const byCapability = new Map;
   for (const route of resolved) {
@@ -7718,10 +7804,15 @@ class Cataloger {
       name: bareToolName,
       arguments: args
     });
-    return {
+    const response = {
       content: callResult.content,
       isError: callResult.isError
     };
+    const sc = callResult["structuredContent"];
+    if (sc != null && typeof sc === "object" && !Array.isArray(sc)) {
+      response.structuredContent = sc;
+    }
+    return response;
   }
   async refreshTools(key) {
     const connection = this.connections.get(key);
@@ -8338,6 +8429,178 @@ class MonitorServer {
   }
 }
 
+// src/server/response-resource.ts
+import { randomBytes } from "crypto";
+class ResponseResourceManager {
+  static MAX_PREVIEW_BYTES = 2048;
+  config;
+  resources = new Map;
+  insertionOrder = [];
+  constructor(config) {
+    this.config = config;
+  }
+  isEnabled() {
+    return this.config.enabled;
+  }
+  shouldOffload(content) {
+    if (!this.config.enabled)
+      return false;
+    const { byteCount } = this.canonicalizeContent(content);
+    return byteCount > this.config.thresholdBytes;
+  }
+  offload(content, context) {
+    const { fullText, byteCount } = this.canonicalizeContent(content);
+    const id = this.generateId(context);
+    const uri = `mcp2://response/${context.capability}/${id}`;
+    const entry = {
+      uri,
+      name: `${context.capability}:${context.action} response`,
+      description: `Full response from ${context.capability}:${context.action} (${byteCount} bytes)`,
+      mimeType: "text/plain",
+      fullText,
+      byteCount,
+      createdAt: Date.now()
+    };
+    this.store(uri, entry);
+    const preview = this.buildPreview(fullText);
+    const pointer = {
+      truncated: true,
+      resource_uri: uri,
+      total_bytes: byteCount,
+      preview,
+      instructions: "Full response available via resources/read with the resource_uri above."
+    };
+    return {
+      resourceUri: uri,
+      inlineContent: [{ type: "text", text: JSON.stringify(pointer) }]
+    };
+  }
+  readResource(uri) {
+    const entry = this.resources.get(uri);
+    if (!entry)
+      return null;
+    if (Date.now() - entry.createdAt >= this.config.ttlMs) {
+      this.deleteResource(uri);
+      return null;
+    }
+    this.touchInsertionOrder(uri);
+    return {
+      contents: [
+        {
+          uri: entry.uri,
+          mimeType: entry.mimeType,
+          text: entry.fullText
+        }
+      ]
+    };
+  }
+  listResources() {
+    this.evictExpired();
+    const result = [];
+    for (const entry of this.resources.values()) {
+      result.push({
+        uri: entry.uri,
+        name: entry.name,
+        description: entry.description,
+        mimeType: entry.mimeType,
+        size: entry.byteCount
+      });
+    }
+    return result;
+  }
+  getResourceCount() {
+    return this.resources.size;
+  }
+  canonicalizeContent(content) {
+    const fullText = content.map((block) => block.text).join(`
+
+---
+
+`);
+    return {
+      fullText,
+      byteCount: this.measureBytes(fullText)
+    };
+  }
+  measureBytes(text) {
+    return Buffer.byteLength(text, "utf8");
+  }
+  generateId(context) {
+    const timestamp = Date.now().toString(36);
+    const random = randomBytes(4).toString("hex");
+    const actionSlug = context.action.toLowerCase().replace(/[^a-z0-9]+/g, "_").slice(0, 24);
+    return `${actionSlug}_${timestamp}_${random}`;
+  }
+  buildPreview(fullText) {
+    const lines = fullText.split(`
+`);
+    let preview;
+    if (lines.length <= this.config.maxInlineLines) {
+      preview = fullText;
+    } else {
+      preview = `${lines.slice(0, this.config.maxInlineLines).join(`
+`)}
+...`;
+    }
+    if (this.measureBytes(preview) > ResponseResourceManager.MAX_PREVIEW_BYTES) {
+      const truncated = this.truncateUtf8(preview, ResponseResourceManager.MAX_PREVIEW_BYTES);
+      return `${truncated}...`;
+    }
+    return preview;
+  }
+  truncateUtf8(text, maxBytes) {
+    const bytes = Buffer.from(text, "utf8");
+    if (bytes.length <= maxBytes)
+      return text;
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    for (let end = maxBytes;end > 0; end--) {
+      try {
+        return decoder.decode(bytes.subarray(0, end));
+      } catch {}
+    }
+    return "";
+  }
+  store(uri, entry) {
+    this.evictExpired();
+    while (this.resources.size >= this.config.maxResources && this.insertionOrder.length > 0) {
+      const oldest = this.insertionOrder[0];
+      if (!oldest)
+        break;
+      this.deleteResource(oldest);
+    }
+    this.resources.set(uri, entry);
+    this.touchInsertionOrder(uri);
+  }
+  evictExpired() {
+    const now = Date.now();
+    const toRemove = [];
+    for (const [uri, entry] of this.resources) {
+      if (now - entry.createdAt >= this.config.ttlMs) {
+        toRemove.push(uri);
+      }
+    }
+    for (const uri of toRemove) {
+      this.deleteResource(uri);
+    }
+  }
+  deleteResource(uri) {
+    this.resources.delete(uri);
+    this.removeFromInsertionOrder(uri);
+  }
+  removeFromInsertionOrder(uri) {
+    const idx = this.insertionOrder.indexOf(uri);
+    if (idx !== -1)
+      this.insertionOrder.splice(idx, 1);
+  }
+  appendToInsertionOrder(uri) {
+    this.insertionOrder.push(uri);
+  }
+  touchInsertionOrder(uri) {
+    this.removeFromInsertionOrder(uri);
+    this.appendToInsertionOrder(uri);
+  }
+}
+
 // src/server/stats.ts
 class StatsCollector {
   indexStore;
@@ -8542,6 +8805,7 @@ class McpSquaredServer {
   compiledPolicy;
   indexRefreshManager;
   statsCollector;
+  responseResourceManager;
   monitorServer;
   isCoreStarted = false;
   serverName;
@@ -8593,6 +8857,8 @@ class McpSquaredServer {
       policy: loadedPolicy,
       sink: this.obsSink
     });
+    const rrConfig = this.config.operations.responseResource ?? DEFAULT_RESPONSE_RESOURCE_CONFIG;
+    this.responseResourceManager = new ResponseResourceManager(rrConfig);
     this.mcpServer = this.createMcpServer(name, version);
     this.selectionTracker = new SelectionTracker;
     this.compiledPolicy = compilePolicy(this.config);
@@ -8629,7 +8895,8 @@ class McpSquaredServer {
       description: "Execute capability-first tools routed to connected upstream MCP servers."
     }, {
       capabilities: {
-        tools: {}
+        tools: {},
+        ...this.responseResourceManager.isEnabled() ? { resources: {} } : {}
       },
       instructions: this.buildServerInstructions()
     });
@@ -8649,6 +8916,32 @@ class McpSquaredServer {
   }
   registerConfiguredToolSurface(server) {
     this.registerCapabilityRouters(server);
+    if (this.responseResourceManager.isEnabled()) {
+      this.registerResponseResources(server);
+    }
+  }
+  registerResponseResources(server) {
+    const mgr = this.responseResourceManager;
+    server.registerResource("response-resources", "mcp2://response/{capability}/{id}", {
+      description: "Temporary resources containing full tool responses that exceeded the inline size threshold.",
+      mimeType: "text/plain"
+    }, async (uri) => {
+      const result = mgr.readResource(uri.href);
+      if (!result) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/plain",
+              text: JSON.stringify({
+                error: "Resource not found or expired"
+              })
+            }
+          ]
+        };
+      }
+      return result;
+    });
   }
   runTaskSpan(taskName, run) {
     return task_span(this.obsSink, {
@@ -8677,6 +8970,7 @@ class McpSquaredServer {
     const status = this.cataloger.getStatus();
     const inventories = [...status.entries()].filter(([, info]) => info.status === "connected").map(([namespace]) => ({
       namespace,
+      title: this.config.upstreams[namespace]?.label ?? namespace,
       tools: this.cataloger.getToolsForServer(namespace)
     })).sort((a, b) => a.namespace.localeCompare(b.namespace));
     if (inventories.length === 0) {
@@ -8689,30 +8983,38 @@ class McpSquaredServer {
     const grouping = groupNamespacesByCapability(inventories, overrides);
     return buildCapabilityRouters(inventories, grouping, (desc, cap) => this.actionSummary(desc, cap));
   }
+  getCapabilityRouter(capability) {
+    return this.buildCapabilityRouters().find((router) => router.capability === capability) ?? {
+      capability,
+      actions: []
+    };
+  }
   registerCapabilityRouters(server) {
     const routers = this.buildCapabilityRouters();
     for (const router of routers) {
       if (router.actions.length === 0) {
         continue;
       }
-      server.registerTool(router.capability, {
-        title: this.capabilityTitle(router.capability),
-        description: this.capabilitySummary(router.capability),
+      const capability = router.capability;
+      server.registerTool(capability, {
+        title: this.capabilityTitle(capability),
+        description: this.capabilitySummary(capability),
         annotations: {
           readOnlyHint: false,
           destructiveHint: false,
           openWorldHint: true
         },
         inputSchema: {
-          action: z3.string().describe(`Action ID for ${router.capability}. Use "${DESCRIBE_ACTION2}" to inspect available actions and schemas.`),
+          action: z3.string().describe(`Action ID for ${capability}. Use "${DESCRIBE_ACTION2}" to inspect available actions and schemas.`),
           arguments: z3.record(z3.string(), z3.unknown()).default({}).describe("Arguments for the selected capability action"),
           confirmation_token: z3.string().optional().describe("Optional confirmation token for actions that require explicit confirmation")
         }
-      }, async (rawArgs) => this.runTaskSpan(router.capability, async () => {
+      }, async (rawArgs) => this.runTaskSpan(capability, async () => {
         const requestId = this.statsCollector.startRequest();
         const startTime = Date.now();
         let success = false;
         try {
+          const liveRouter = this.getCapabilityRouter(capability);
           const parsedArgs = isRecord3(rawArgs) ? { ...rawArgs } : {};
           const action = typeof parsedArgs["action"] === "string" ? parsedArgs["action"] : "";
           const confirmationToken = typeof parsedArgs["confirmation_token"] === "string" ? parsedArgs["confirmation_token"] : undefined;
@@ -8724,25 +9026,37 @@ class McpSquaredServer {
                   type: "text",
                   text: JSON.stringify({
                     error: "Missing required action",
-                    capability: router.capability
+                    capability
                   })
                 }
               ],
               isError: true
             };
           }
-          const visibleActions = router.actions.map((route2) => {
-            const visibility = getToolVisibilityCompiled(router.capability, route2.action, this.compiledPolicy);
+          const visibleRoutes = liveRouter.actions.map((route) => {
+            const visibility = getToolVisibilityCompiled(capability, route.action, this.compiledPolicy);
             if (!visibility.visible) {
               return null;
             }
             return {
-              action: route2.action,
-              summary: route2.summary,
-              inputSchema: route2.inputSchema,
+              route,
               requiresConfirmation: visibility.requiresConfirmation
             };
-          }).filter((entry) => entry !== null).sort((a, b) => a.action.localeCompare(b.action));
+          }).filter((entry) => entry !== null);
+          const visibleActions = visibleRoutes.map(({ route, requiresConfirmation }) => {
+            const actionInfo = {
+              action: route.action,
+              summary: route.summary,
+              inputSchema: route.inputSchema,
+              requiresConfirmation
+            };
+            if ((route.collisionGroupSize ?? 1) > 1) {
+              actionInfo.baseAction = route.baseAction;
+              actionInfo.instance = route.instanceKey ?? route.serverKey;
+              actionInfo.instanceTitle = route.instanceTitle ?? route.instanceKey ?? route.serverKey;
+            }
+            return actionInfo;
+          }).sort((a, b) => a.action.localeCompare(b.action));
           if (action === DESCRIBE_ACTION2) {
             success = true;
             return {
@@ -8750,7 +9064,7 @@ class McpSquaredServer {
                 {
                   type: "text",
                   text: JSON.stringify({
-                    capability: router.capability,
+                    capability,
                     actions: visibleActions,
                     totalActions: visibleActions.length
                   })
@@ -8758,7 +9072,8 @@ class McpSquaredServer {
               ]
             };
           }
-          const ambiguousCandidates = router.actions.filter((route2) => route2.baseAction === action).map((route2) => route2.action).sort((a, b) => a.localeCompare(b));
+          const exactRoute = liveRouter.actions.find((entry) => entry.action === action || (entry.legacyActions ?? []).includes(action));
+          const ambiguousCandidates = visibleRoutes.filter(({ route }) => route.baseAction === action).map(({ route }) => route.action).sort((a, b) => a.localeCompare(b));
           if (ambiguousCandidates.length > 1) {
             return {
               content: [
@@ -8766,7 +9081,7 @@ class McpSquaredServer {
                   type: "text",
                   text: JSON.stringify({
                     requires_disambiguation: true,
-                    capability: router.capability,
+                    capability,
                     action,
                     candidates: ambiguousCandidates
                   })
@@ -8775,15 +9090,15 @@ class McpSquaredServer {
               isError: true
             };
           }
-          const route = router.actions.find((entry) => entry.action === action);
-          if (!route) {
+          const selectedRoute = exactRoute ?? (ambiguousCandidates.length === 1 ? visibleRoutes.find(({ route }) => route.baseAction === action)?.route : undefined);
+          if (selectedRoute == null) {
             return {
               content: [
                 {
                   type: "text",
                   text: JSON.stringify({
                     error: "Unknown action",
-                    capability: router.capability,
+                    capability,
                     action,
                     availableActions: visibleActions.map((a) => a.action)
                   })
@@ -8793,10 +9108,12 @@ class McpSquaredServer {
             };
           }
           const callResult = await this.executeRoutedTool({
-            capability: router.capability,
-            action: route.action,
-            qualifiedToolName: route.qualifiedName,
-            toolNameForCall: route.qualifiedName,
+            capability,
+            action: selectedRoute.action,
+            policyAction: exactRoute != null ? action : selectedRoute.action,
+            routeId: selectedRoute.canonicalRouteId ?? `${capability}:${selectedRoute.action}`,
+            qualifiedToolName: selectedRoute.qualifiedName,
+            toolNameForCall: selectedRoute.qualifiedName,
             args: actionArgs,
             ...confirmationToken != null ? { confirmationToken } : {}
           });
@@ -8816,7 +9133,7 @@ class McpSquaredServer {
           };
         } finally {
           const responseTime = Date.now() - startTime;
-          this.statsCollector.endRequest(requestId, success, responseTime, router.capability, "capability");
+          this.statsCollector.endRequest(requestId, success, responseTime, capability, "capability");
         }
       }));
     }
@@ -8835,7 +9152,7 @@ class McpSquaredServer {
   async executeRoutedTool(args) {
     const policyResult = evaluatePolicy({
       capability: args.capability,
-      action: args.action,
+      action: args.policyAction ?? args.action,
       confirmationToken: args.confirmationToken
     }, this.config);
     if (policyResult.decision === "block") {
@@ -8869,27 +9186,40 @@ class McpSquaredServer {
     }
     this.guard.enforce({
       agent: this.safetyAgent,
-      tool: `${args.capability}:${args.action}`,
+      tool: args.routeId ?? `${args.capability}:${args.action}`,
       action: "call",
       params: args.args
     });
     const result = await tool_span(this.obsSink, {
       agent: this.safetyAgent,
-      tool: `${args.capability}:${args.action}`,
+      tool: args.routeId ?? `${args.capability}:${args.action}`,
       action: "call",
       playbook: this.guard.playbook,
       env: this.guard.agentEnv
     }, () => this.cataloger.callTool(args.toolNameForCall, args.args));
     if (!result.isError && this.config.operations.selectionCache.enabled) {
-      const toolKey = `${args.capability}:${args.action}`;
+      const toolKey = args.routeId ?? `${args.capability}:${args.action}`;
       this.selectionTracker.trackToolUsage(toolKey);
       if (this.selectionTracker.getSessionToolCount() >= 2) {
         this.selectionTracker.flushToStore(this.retriever.getIndexStore());
       }
     }
+    const normalizedContent = this.normalizeToolResultContent(result.content);
+    const structuredContent = result.structuredContent;
+    if (!result.isError && this.responseResourceManager.isEnabled() && this.responseResourceManager.shouldOffload(normalizedContent)) {
+      try {
+        const offloaded = this.responseResourceManager.offload(normalizedContent, { capability: args.capability, action: args.action });
+        return {
+          content: offloaded.inlineContent,
+          isError: false,
+          ...structuredContent != null ? { structuredContent } : {}
+        };
+      } catch {}
+    }
     return {
-      content: this.normalizeToolResultContent(result.content),
-      isError: result.isError ?? false
+      content: normalizedContent,
+      isError: result.isError ?? false,
+      ...structuredContent != null ? { structuredContent } : {}
     };
   }
   syncIndex() {
@@ -9117,6 +9447,7 @@ async function collectStatus(config) {
     }
     const inventories = [...status.entries()].filter(([, info]) => info.status === "connected").map(([namespace]) => ({
       namespace,
+      title: config.upstreams[namespace]?.label ?? namespace,
       tools: cataloger.getToolsForServer(namespace)
     })).sort((a, b) => a.namespace.localeCompare(b.namespace));
     let routers = [];

package/dist/tui/config.js

@@ -736,6 +736,14 @@ var LoggingSchema = z.object({
 var EmbeddingsSchema = z.object({
   enabled: z.boolean().default(false)
 });
+var ResponseResourceSchema = z.object({
+  enabled: z.boolean().default(false),
+  thresholdBytes: z.number().int().min(1024).default(51200),
+  maxInlineLines: z.number().int().min(1).default(20),
+  maxResources: z.number().int().min(1).default(100),
+  ttlMs: z.number().int().min(0).default(600000)
+});
+var DEFAULT_RESPONSE_RESOURCE_CONFIG = ResponseResourceSchema.parse({});
 var SelectionCacheSchema = z.object({
   enabled: z.boolean().default(true),
   minCooccurrenceThreshold: z.number().int().min(1).default(2),
@@ -752,6 +760,7 @@ var OperationsSchema = z.object({
   index: IndexSchema.default({ refreshIntervalMs: 30000 }),
   logging: LoggingSchema.default({ level: "info" }),
   embeddings: EmbeddingsSchema.default({ enabled: false }),
+  responseResource: ResponseResourceSchema.default(DEFAULT_RESPONSE_RESOURCE_CONFIG),
   selectionCache: SelectionCacheSchema.default({
     enabled: true,
     minCooccurrenceThreshold: 2,
@@ -774,6 +783,7 @@ var OperationsSchema = z.object({
   index: { refreshIntervalMs: 30000 },
   logging: { level: "info" },
   embeddings: { enabled: false },
+  responseResource: DEFAULT_RESPONSE_RESOURCE_CONFIG,
   selectionCache: {
     enabled: true,
     minCooccurrenceThreshold: 2,
@@ -2275,10 +2285,15 @@ class Cataloger {
       name: bareToolName,
       arguments: args
     });
-    return {
+    const response = {
       content: callResult.content,
       isError: callResult.isError
     };
+    const sc = callResult["structuredContent"];
+    if (sc != null && typeof sc === "object" && !Array.isArray(sc)) {
+      response.structuredContent = sc;
+    }
+    return response;
   }
   async refreshTools(key) {
     const connection = this.connections.get(key);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-squared",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "MCP² (Mercury Control Plane) - A local-first meta-server and proxy for the Model Context Protocol",
   "author": "aditzel",
   "license": "Apache-2.0",
@@ -28,7 +28,7 @@
     "test": "bun test",
     "test:fast": "SKIP_SLOW_TESTS=true bun test",
     "test:watch": "bun test --watch",
-    "coverage:check": "bun run scripts/check-line-coverage.ts coverage/coverage-summary.txt 80",
+    "coverage:check": "bun run scripts/check-line-coverage.ts coverage/coverage-summary.txt coverage/lcov.info 80",
     "typecheck": "tsc --noEmit",
     "lint": "biome check src tests scripts AGENTS.md CLAUDE.md WARP.md README.md CHANGELOG.md package.json biome.json tsconfig.json",
     "release:check": "bun run audit && bun test && bun run build && bun run build:verify && bun run lint && bun run typecheck && bun pm pack --dry-run",
@@ -78,6 +78,7 @@
     "@hono/node-server": "^1.19.11",
     "ajv": "^8.18.0",
     "diff": "8.0.3",
+    "express-rate-limit": "8.2.2",
     "hono": "^4.12.5",
     "qs": "6.15.0",
     "tar": "^7.5.10"