@lenso/mcp 0.3.0 → 0.4.0

package/README.md

@@ -37,6 +37,16 @@ service still enforces its tenant/object/owner rules. Manage/`createAgentTools`
 are the canonical schema/metadata source; all selected schemas must convert to
 SDK-compatible object schemas before readiness, including currently hidden tools.
 
+The borrowed adapter prepares one immutable Manage selection for its lifetime.
+Discovery, invocation policies and bindings receive the same frozen declaration
+snapshots, retaining exact plugin/schema/function identities. Do not key policies
+by the original declaration object's identity; use the exact plugin and declared
+method. Original declaration edits do not change admission or dispatch. Replace
+the adapter when changing its selection. Existing `operation_N` tool names remain
+entry-local, translated internally to Manage's selection-scoped opaque keys.
+Close revokes admission, waits for actual work to drain, then releases the
+selection's runtime references; policy closures retain any resources they capture.
+
 For a **dedicated local process**, replace the adapter creation above with:
 
 ```ts

package/dist/index.js

@@ -37,7 +37,7 @@ import {
 import { environmentSecrets, redact } from "@lenso/engine/diagnostics";
 
 // src/adapter.ts
-import { createAgentTools, createManageAdapter } from "@lenso/manage";
+import { createAgentTools, createManageSelection } from "@lenso/manage";
 import {
   boundedJson
 } from "@lenso/engine/operations";
@@ -100,19 +100,24 @@ function failure(code) {
   };
 }
 async function createMcpAdapter(options) {
+  const { running, plugins, operations, ...policies } = options;
+  const selection = createManageSelection({ running, plugins, operations });
+  try {
+    return await adapterForSelection(selection, policies);
+  } catch (error) {
+    selection.close();
+    throw error;
+  }
+}
+async function adapterForSelection(selection, options) {
   const maxInput = positive(options.maxInputBytes, 256 * 1024);
   const maxOutput = positive(options.maxOutputBytes, 1024 * 1024, 256);
   const maxCatalog = positive(options.maxCatalogBytes, 256 * 1024);
   const maxConcurrent = positive(options.maxConcurrentCalls, 4);
   const timeout = positive(options.requestTimeoutMs, 30000);
-  const operations = Object.freeze([...options.operations]);
-  const plugins = Object.freeze([...options.plugins]);
   if ([options.binding, options.canList, options.authorize].some((fn) => typeof fn !== "function"))
     throw new TypeError("MCP requires trusted binding, catalog and invocation policies.");
-  const canonical = createManageAdapter({
-    running: options.running,
-    plugins,
-    operations,
+  const canonical = selection.createAdapter({
     canList: () => true,
     binding: () => {
       throw new Error("Metadata adapter cannot invoke.");
@@ -126,7 +131,7 @@ async function createMcpAdapter(options) {
   const tools = agentTools.map((item, index) => {
     const operation = catalog[index];
     const tool = {
-      name: item.name,
+      name: `operation_${index}`,
       title: `${operation.pluginId}.${operation.method}`,
       description: [
         item.description,
@@ -149,6 +154,7 @@ async function createMcpAdapter(options) {
     return tool;
   });
   boundedJson({ tools }, maxCatalog);
+  const toolByKey = new Map(catalog.map((operation, index) => [operation.key, tools[index]]));
   let closed = false;
   let closePromise;
   const pending = new Set;
@@ -196,12 +202,18 @@ async function createMcpAdapter(options) {
         throw new McpError(ErrorCode.InternalError, "Adapter is busy.");
       try {
         return await tracked(request, async (context) => {
-          const visible = [];
-          for (const [index, operation] of operations.entries()) {
-            if (await options.canList(operation, context) === true)
-              visible.push(tools[index]);
-            context.signal.throwIfAborted();
-          }
+          const scoped = selection.createAdapter({
+            maxOutputBytes: maxCatalog,
+            binding: () => {
+              throw new Error("Metadata adapter cannot invoke.");
+            },
+            canList: async (operation) => {
+              const visible = await options.canList(operation, context);
+              context.signal.throwIfAborted();
+              return visible;
+            }
+          });
+          const visible = (await scoped.catalog()).map((operation) => toolByKey.get(operation.key));
           return JSON.parse(boundedJson({ tools: visible }, maxCatalog));
         });
       } catch {
@@ -210,7 +222,7 @@ async function createMcpAdapter(options) {
     },
     async callTool(name, input, request) {
       const match = /^operation_(0|[1-9][0-9]*)$/.exec(name);
-      if (!match || !operations[Number(match[1])])
+      if (!match || !catalog[Number(match[1])])
         throw new McpError(ErrorCode.InvalidParams, "Unknown tool.");
       if (closed)
         return failure("adapter-closed");
@@ -225,10 +237,7 @@ async function createMcpAdapter(options) {
       }
       try {
         const value = await tracked(request, async (context) => {
-          const scoped = createManageAdapter({
-            running: options.running,
-            plugins,
-            operations,
+          const scoped = selection.createAdapter({
             maxOutputBytes: maxOutput,
             canList: async (operation) => {
               const visible = await options.canList(operation, context);
@@ -245,13 +254,13 @@ async function createMcpAdapter(options) {
               };
             }
           });
-          const result = await scoped.invokeEntry(name, input);
+          const result = await scoped.invokeEntry(catalog[Number(match[1])].key, input);
           context.signal.throwIfAborted();
           return result;
         });
         return { content: [{ type: "text", text: boundedJson(value, maxOutput) }] };
       } catch (error) {
-        return failure(error instanceof EngineError ? error.diagnostic.code : request.signal.aborted ? "request-cancelled" : "invocation-failed");
+        return failure(error instanceof EngineError ? error.diagnostic.code : "invocation-failed");
       }
     },
     close() {
@@ -260,7 +269,9 @@ async function createMcpAdapter(options) {
       closed = true;
       for (const controller of controllers)
         controller.abort();
-      closePromise = Promise.allSettled(pending).then(() => {});
+      closePromise = Promise.allSettled(pending).then(() => {
+        selection.close();
+      });
       return closePromise;
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenso/mcp",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -24,10 +24,10 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@lenso/cli": "^0.19.2",
-    "@lenso/core": "^0.3.0",
-    "@lenso/engine": "^0.4.0",
-    "@lenso/manage": "^0.4.0",
+    "@lenso/cli": "^0.20.1",
+    "@lenso/core": "^0.3.1",
+    "@lenso/engine": "^0.6.0",
+    "@lenso/manage": "^0.5.0",
     "@modelcontextprotocol/sdk": "1.32.1",
     "zod": "4.6.5"
   }