@artinet/sdk 0.6.6 → 0.6.7

package/dist/services/core/manager.js

@@ -72,9 +72,9 @@ export class Manager {
     async list() {
         const listed = Array.from(this.cache.values());
         if (this.storage) {
+            const storedList = (await this.storage.list?.())?.filter((item) => item !== undefined && !listed.includes(item));
             /** Could be an expensive operation */
-            listed.push(...((await this.storage.list?.())?.filter((item) => item !== undefined && !listed.includes(item)) ??
-                []));
+            listed.push(...(storedList ?? []));
         }
         return listed;
     }
@@ -88,7 +88,14 @@ export class Manager {
         }
         const results = [];
         if (filter) {
-            results.push(...Array.from(this.cache.values()).filter(filter));
+            const items = Array.from(this.cache.values());
+            const filterResults = await Promise.all(items.map(async (item) => {
+                if (await filter(item)) {
+                    return item;
+                }
+                return undefined;
+            }));
+            results.push(...filterResults.filter((item) => item !== undefined));
         }
         if (this.storage) {
             const storageFilter = async (item) => {

package/dist/services/mcp/modules/mem.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Copyright 2026 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod/v4';
+/**
+ * Configuration for mounting an in-memory MCP server.
+ */
+declare const InMemoryParamsSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        factory: "factory";
+        constructor: "constructor";
+    }>;
+    target: z.ZodString;
+    module: z.ZodString;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type InMemoryParams = z.infer<typeof InMemoryParamsSchema>;
+/**
+ * Mounts an MCP server in-memory for direct integration.
+ * Creates a linked transport pair for client-server communication without network overhead.
+ * @docs https://modelcontextprotocol.io/docs/concepts/transports#in-memory
+ *
+ * @param params - {@link InMemoryParams} Configuration for the server module
+ * @param extract - Optional function to extract the McpServer from the imported module.
+ *                  Use when the module's export structure doesn't match standard factory/constructor patterns.
+ * @example
+ * ```typescript
+ * import { mountMemServer } from "@artinet/sdk/mcp/mem";
+ * import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+ *
+ * // Mount a server using a factory function with custom extraction
+ * const { server, clientTransport } = await mountMemServer(
+ *   {
+ *     type: "factory",
+ *     target: "createServer",
+ *     module: "@modelcontextprotocol/server-everything/dist/everything.js",
+ *   },
+ *   (module) => module.createServer().server
+ * );
+ *
+ * // Connect a client to the in-memory server
+ * const client = new Client({ name: "my-client", version: "1.0.0" });
+ * await client.connect(clientTransport);
+ *
+ * // Use the client
+ * const tools = await client.listTools();
+ * ```
+ * @returns Promise containing the {@link McpServer} instance and linked transport pair
+ */
+export declare function mountMemServer(params: InMemoryParams, extract?: (module: any) => McpServer): Promise<{
+    serverTransport: InMemoryTransport;
+    clientTransport: InMemoryTransport;
+    server: McpServer;
+}>;
+export {};

package/dist/services/mcp/modules/mem.js

@@ -0,0 +1,107 @@
+/**
+ * Copyright 2026 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { logger } from "../../../config/index.js";
+import { z } from 'zod/v4';
+/**
+ * Configuration for mounting an in-memory MCP server.
+ */
+const InMemoryParamsSchema = z.object({
+    /** Whether to invoke the target as a factory function or constructor */
+    type: z.enum(['factory', 'constructor']),
+    /** The name of the exported factory function or constructor class */
+    target: z.string(),
+    /** The module path to dynamically import (e.g., '@modelcontextprotocol/server-everything/dist/everything.js') */
+    module: z.string(),
+    /** Optional arguments to pass to the factory function or constructor */
+    args: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * Mounts an MCP server in-memory for direct integration.
+ * Creates a linked transport pair for client-server communication without network overhead.
+ * @docs https://modelcontextprotocol.io/docs/concepts/transports#in-memory
+ *
+ * @param params - {@link InMemoryParams} Configuration for the server module
+ * @param extract - Optional function to extract the McpServer from the imported module.
+ *                  Use when the module's export structure doesn't match standard factory/constructor patterns.
+ * @example
+ * ```typescript
+ * import { mountMemServer } from "@artinet/sdk/mcp/mem";
+ * import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+ *
+ * // Mount a server using a factory function with custom extraction
+ * const { server, clientTransport } = await mountMemServer(
+ *   {
+ *     type: "factory",
+ *     target: "createServer",
+ *     module: "@modelcontextprotocol/server-everything/dist/everything.js",
+ *   },
+ *   (module) => module.createServer().server
+ * );
+ *
+ * // Connect a client to the in-memory server
+ * const client = new Client({ name: "my-client", version: "1.0.0" });
+ * await client.connect(clientTransport);
+ *
+ * // Use the client
+ * const tools = await client.listTools();
+ * ```
+ * @returns Promise containing the {@link McpServer} instance and linked transport pair
+ */
+export async function mountMemServer(params, extract) {
+    const [serverTransport, clientTransport] = InMemoryTransport.createLinkedPair();
+    //IFFE
+    const modules = (() => {
+        const modules = new Map();
+        return async (moduleName) => {
+            if (modules.has(moduleName)) {
+                return modules.get(moduleName);
+            }
+            const module = await import(moduleName).catch((error) => {
+                logger.error(`Failed to import module ${moduleName}`, error);
+                throw error;
+            });
+            if (module) {
+                modules.set(moduleName, module);
+            }
+            return module;
+        };
+    })();
+    const module = await modules(params.module).catch((error) => {
+        logger.error(`Failed to import module ${params.module}`, error);
+        throw error;
+    });
+    if (!module) {
+        logger.warn(`Failed to import module ${params.module}`);
+        throw new Error(`Failed to import module ${params.module}`);
+    }
+    let server;
+    if (extract) {
+        server = extract(module);
+    }
+    else if (params.type === 'factory') {
+        const factory = module[params.target];
+        if (!factory) {
+            const error = new Error(`Failed to find factory ${params.target} in module ${params.module}`);
+            logger.error(error.message, error);
+            throw error;
+        }
+        server = factory(params.args);
+    }
+    else {
+        const constructor = module[params.target];
+        if (!constructor) {
+            const error = new Error(`Failed to find constructor ${params.target} in module ${params.module}`);
+            logger.error(error.message, error);
+            throw error;
+        }
+        server = new constructor(params.args);
+    }
+    await server.connect(serverTransport).catch((error) => {
+        logger.error(`Failed to connect to server ${params.target}`, error);
+        throw error;
+    });
+    return { serverTransport, clientTransport, server };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@artinet/sdk",
-    "version": "0.6.6",
+    "version": "0.6.7",
     "description": "A TypeScript SDK for building collaborative AI agents.",
     "type": "module",
     "main": "./dist/index.js",
@@ -22,6 +22,11 @@
             "import": "./dist/services/mcp/index.js",
             "default": "./dist/services/mcp/index.js"
         },
+        "./mcp/mem": {
+            "types": "./dist/services/mcp/modules/mem.d.ts",
+            "import": "./dist/services/mcp/modules/mem.js",
+            "default": "./dist/services/mcp/modules/mem.js"
+        },
         "./serverless": {
             "types": "./dist/server/express/serverless/index.d.ts",
             "import": "./dist/server/express/serverless/index.js",