@manifest-network/manifest-mcp-core 0.9.0 → 0.10.0

package/dist/__test-utils__/callToolWithElicitation.d.ts

@@ -0,0 +1,43 @@
+import { ToolResult } from "./callTool.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { ElicitRequest, ElicitResult } from "@modelcontextprotocol/sdk/types.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+
+//#region src/__test-utils__/callToolWithElicitation.d.ts
+/**
+ * Scripted responder for incoming `elicitation/create` requests on the
+ * test-side MCP `Client`. The test author owns the mapping from request
+ * shape → result — the helper just wires it up.
+ *
+ * `respond` may be sync or async. It must return a valid `ElicitResult`
+ * (`{ action: 'accept' | 'decline' | 'cancel', content?: ... }`).
+ */
+interface ElicitationScript {
+  respond: (req: ElicitRequest) => ElicitResult | Promise<ElicitResult>;
+}
+/**
+ * Mirror of `callTool` for tools that mid-execution call
+ * `server.elicitInput(...)`. Connects an MCP client (advertising the
+ * `elicitation` capability by default) to the server over an in-memory
+ * transport, registers a request handler that delegates each incoming
+ * elicitation to `script.respond`, then invokes the named tool.
+ *
+ * Cleanup always runs via the `finally` block: client and both transports
+ * are closed, then removed from `activeTransports` to prevent double-close
+ * in the caller's `afterEach`.
+ *
+ * @param server  - The MCP `Server` instance (from `getServer()`)
+ * @param toolName - Name of the tool to invoke
+ * @param toolInput - Tool arguments
+ * @param script - Scripted responder for `elicitation/create` requests
+ * @param activeTransports - Optional mutable array; transports are added
+ *   before the call and removed after cleanup completes.
+ * @param declareElicitationCapability - When `true` (default) the test
+ *   `Client` advertises `capabilities: { elicitation: {} }`. Set to
+ *   `false` to exercise the wrapper's capability-guard path (the tool
+ *   should reject with `INVALID_CONFIG` before any elicitation happens).
+ */
+declare function callToolWithElicitation(server: Server, toolName: string, toolInput: Record<string, unknown>, script: ElicitationScript, activeTransports?: InMemoryTransport[], declareElicitationCapability?: boolean): Promise<ToolResult>;
+//#endregion
+export { ElicitationScript, callToolWithElicitation };
+//# sourceMappingURL=callToolWithElicitation.d.ts.map

package/dist/__test-utils__/callToolWithElicitation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callToolWithElicitation.d.ts","names":[],"sources":["../../src/__test-utils__/callToolWithElicitation.ts"],"mappings":";;;;;;;;AAkBA;;;;;;UAAiB,iBAAA;EACf,OAAA,GAAU,GAAA,EAAK,aAAA,KAAkB,YAAA,GAAe,OAAA,CAAQ,YAAA;AAAA;;;;;;;;;AAyB1D;;;;;;;;;;;;;;iBAAsB,uBAAA,CACpB,MAAA,EAAQ,MAAA,EACR,QAAA,UACA,SAAA,EAAW,MAAA,mBACX,MAAA,EAAQ,iBAAA,EACR,gBAAA,GAAkB,iBAAA,IAClB,4BAAA,aACC,OAAA,CAAQ,UAAA"}

package/dist/__test-utils__/callToolWithElicitation.js

@@ -0,0 +1,57 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+//#region src/__test-utils__/callToolWithElicitation.ts
+/**
+* Mirror of `callTool` for tools that mid-execution call
+* `server.elicitInput(...)`. Connects an MCP client (advertising the
+* `elicitation` capability by default) to the server over an in-memory
+* transport, registers a request handler that delegates each incoming
+* elicitation to `script.respond`, then invokes the named tool.
+*
+* Cleanup always runs via the `finally` block: client and both transports
+* are closed, then removed from `activeTransports` to prevent double-close
+* in the caller's `afterEach`.
+*
+* @param server  - The MCP `Server` instance (from `getServer()`)
+* @param toolName - Name of the tool to invoke
+* @param toolInput - Tool arguments
+* @param script - Scripted responder for `elicitation/create` requests
+* @param activeTransports - Optional mutable array; transports are added
+*   before the call and removed after cleanup completes.
+* @param declareElicitationCapability - When `true` (default) the test
+*   `Client` advertises `capabilities: { elicitation: {} }`. Set to
+*   `false` to exercise the wrapper's capability-guard path (the tool
+*   should reject with `INVALID_CONFIG` before any elicitation happens).
+*/
+async function callToolWithElicitation(server, toolName, toolInput, script, activeTransports = [], declareElicitationCapability = true) {
+	const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+	activeTransports.push(clientTransport, serverTransport);
+	const client = new Client({
+		name: "test-client",
+		version: "1.0.0"
+	}, declareElicitationCapability ? { capabilities: { elicitation: {} } } : { capabilities: {} });
+	if (declareElicitationCapability) client.setRequestHandler(ElicitRequestSchema, async (request) => {
+		return await script.respond(request);
+	});
+	try {
+		await server.connect(serverTransport);
+		await client.connect(clientTransport);
+		return await client.callTool({
+			name: toolName,
+			arguments: toolInput
+		});
+	} finally {
+		await client.close().catch(() => {});
+		await clientTransport.close().catch(() => {});
+		await serverTransport.close().catch(() => {});
+		for (const t of [clientTransport, serverTransport]) {
+			const idx = activeTransports.indexOf(t);
+			if (idx !== -1) activeTransports.splice(idx, 1);
+		}
+	}
+}
+//#endregion
+export { callToolWithElicitation };
+
+//# sourceMappingURL=callToolWithElicitation.js.map

package/dist/__test-utils__/callToolWithElicitation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"callToolWithElicitation.js","names":[],"sources":["../../src/__test-utils__/callToolWithElicitation.ts"],"sourcesContent":["import { Client } from '@modelcontextprotocol/sdk/client/index.js';\nimport { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';\nimport type { Server } from '@modelcontextprotocol/sdk/server/index.js';\nimport {\n  type ElicitRequest,\n  ElicitRequestSchema,\n  type ElicitResult,\n} from '@modelcontextprotocol/sdk/types.js';\nimport type { ToolResult } from './callTool.js';\n\n/**\n * Scripted responder for incoming `elicitation/create` requests on the\n * test-side MCP `Client`. The test author owns the mapping from request\n * shape → result — the helper just wires it up.\n *\n * `respond` may be sync or async. It must return a valid `ElicitResult`\n * (`{ action: 'accept' | 'decline' | 'cancel', content?: ... }`).\n */\nexport interface ElicitationScript {\n  respond: (req: ElicitRequest) => ElicitResult | Promise<ElicitResult>;\n}\n\n/**\n * Mirror of `callTool` for tools that mid-execution call\n * `server.elicitInput(...)`. Connects an MCP client (advertising the\n * `elicitation` capability by default) to the server over an in-memory\n * transport, registers a request handler that delegates each incoming\n * elicitation to `script.respond`, then invokes the named tool.\n *\n * Cleanup always runs via the `finally` block: client and both transports\n * are closed, then removed from `activeTransports` to prevent double-close\n * in the caller's `afterEach`.\n *\n * @param server  - The MCP `Server` instance (from `getServer()`)\n * @param toolName - Name of the tool to invoke\n * @param toolInput - Tool arguments\n * @param script - Scripted responder for `elicitation/create` requests\n * @param activeTransports - Optional mutable array; transports are added\n *   before the call and removed after cleanup completes.\n * @param declareElicitationCapability - When `true` (default) the test\n *   `Client` advertises `capabilities: { elicitation: {} }`. Set to\n *   `false` to exercise the wrapper's capability-guard path (the tool\n *   should reject with `INVALID_CONFIG` before any elicitation happens).\n */\nexport async function callToolWithElicitation(\n  server: Server,\n  toolName: string,\n  toolInput: Record<string, unknown>,\n  script: ElicitationScript,\n  activeTransports: InMemoryTransport[] = [],\n  declareElicitationCapability = true,\n): Promise<ToolResult> {\n  const [clientTransport, serverTransport] =\n    InMemoryTransport.createLinkedPair();\n  activeTransports.push(clientTransport, serverTransport);\n\n  const client = new Client(\n    { name: 'test-client', version: '1.0.0' },\n    declareElicitationCapability\n      ? { capabilities: { elicitation: {} } }\n      : { capabilities: {} },\n  );\n\n  // Register BEFORE connect so the handler is in place by the time the\n  // server issues its first `elicitation/create` request mid-tool.\n  //\n  // Skip registration when the client did NOT advertise the elicitation\n  // capability — the SDK's `setRequestHandler` enforces that the client\n  // must have declared the capability for the request type, and would\n  // throw before the tool call ever ran. The capability-guard test path\n  // (`declareElicitationCapability: false`) exercises the wrapper's\n  // `assertElicitationCapability` throw — no elicitation will arrive,\n  // so no handler is needed.\n  if (declareElicitationCapability) {\n    client.setRequestHandler(ElicitRequestSchema, async (request) => {\n      return await script.respond(request);\n    });\n  }\n\n  try {\n    await server.connect(serverTransport);\n    await client.connect(clientTransport);\n\n    return (await client.callTool({\n      name: toolName,\n      arguments: toolInput,\n    })) as ToolResult;\n  } finally {\n    await client.close().catch(() => {});\n    await clientTransport.close().catch(() => {});\n    await serverTransport.close().catch(() => {});\n\n    // Remove by identity so afterEach won't double-close\n    for (const t of [clientTransport, serverTransport]) {\n      const idx = activeTransports.indexOf(t);\n      if (idx !== -1) activeTransports.splice(idx, 1);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,eAAsB,wBACpB,QACA,UACA,WACA,QACA,mBAAwC,EAAE,EAC1C,+BAA+B,MACV;CACrB,MAAM,CAAC,iBAAiB,mBACtB,kBAAkB,kBAAkB;AACtC,kBAAiB,KAAK,iBAAiB,gBAAgB;CAEvD,MAAM,SAAS,IAAI,OACjB;EAAE,MAAM;EAAe,SAAS;EAAS,EACzC,+BACI,EAAE,cAAc,EAAE,aAAa,EAAE,EAAE,EAAE,GACrC,EAAE,cAAc,EAAE,EAAE,CACzB;AAYD,KAAI,6BACF,QAAO,kBAAkB,qBAAqB,OAAO,YAAY;AAC/D,SAAO,MAAM,OAAO,QAAQ,QAAQ;GACpC;AAGJ,KAAI;AACF,QAAM,OAAO,QAAQ,gBAAgB;AACrC,QAAM,OAAO,QAAQ,gBAAgB;AAErC,SAAQ,MAAM,OAAO,SAAS;GAC5B,MAAM;GACN,WAAW;GACZ,CAAC;WACM;AACR,QAAM,OAAO,OAAO,CAAC,YAAY,GAAG;AACpC,QAAM,gBAAgB,OAAO,CAAC,YAAY,GAAG;AAC7C,QAAM,gBAAgB,OAAO,CAAC,YAAY,GAAG;AAG7C,OAAK,MAAM,KAAK,CAAC,iBAAiB,gBAAgB,EAAE;GAClD,MAAM,MAAM,iBAAiB,QAAQ,EAAE;AACvC,OAAI,QAAQ,GAAI,kBAAiB,OAAO,KAAK,EAAE"}

package/dist/version.d.ts

@@ -1,5 +1,5 @@
 //#region src/version.d.ts
-declare const VERSION = "0.9.0";
+declare const VERSION = "0.10.0";
 //#endregion
 export { VERSION };
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,5 +1,5 @@
 //#region src/version.ts
-const VERSION = "0.9.0";
+const VERSION = "0.10.0";
 //#endregion
 export { VERSION };
 

package/dist/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","names":[],"sources":["../src/version.ts"],"sourcesContent":["export const VERSION = '0.9.0';\n"],"mappings":";AAAA,MAAa,UAAU"}
+{"version":3,"file":"version.js","names":[],"sources":["../src/version.ts"],"sourcesContent":["export const VERSION = '0.10.0';\n"],"mappings":";AAAA,MAAa,UAAU"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manifest-network/manifest-mcp-core",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Shared library for Cosmos SDK blockchain logic, tool functions, and server utilities (Manifest Network)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,6 +17,10 @@
     "./__test-utils__/callTool.js": {
       "import": "./dist/__test-utils__/callTool.js",
       "types": "./dist/__test-utils__/callTool.d.ts"
+    },
+    "./__test-utils__/callToolWithElicitation.js": {
+      "import": "./dist/__test-utils__/callToolWithElicitation.js",
+      "types": "./dist/__test-utils__/callToolWithElicitation.d.ts"
     }
   },
   "scripts": {