@artinet/sdk 0.6.5 → 0.6.7

package/README.md

@@ -40,23 +40,6 @@ npx @artinet/create-agent@latest
 
 It has [several template projects](https://github.com/the-artinet-project/artinet/tree/main/create-agent) to jump right into agent building.
 
-**Or use [`easy-a2a`](https://github.com/the-artinet-project/artinet/tree/main/easy):**
-
-```typescript
-const agent = a2a({
-  baseURL: "https://your-api.com/api/v1",
-  apiKey: "your-api-key",
-})
-  .ai("You are a helpful assistant.")
-  .createAgent({
-    agentCard: "MyAgent",
-  });
-```
-
-```bash
-npm install easy-a2a
-```
-
 ## Examples
 
 **Create an A2A Server**
@@ -64,52 +47,85 @@ npm install easy-a2a
 Turn your agent into an express server so it can receive messages from anywhere:
 
 ```typescript
-import { cr8 } from "@artinet/sdk";
+import { cr8 } from '@artinet/sdk';
 
-cr8("QuickStart Agent")
-  .text(async ({ content }) => `The user said: ${content}`)
-  //starts an express a2a server on port 3000
-  .server.start(3000);
+cr8('QuickStart Agent')
+    .text(async ({ content }) => `The user said: ${content}`)
+    //starts an express a2a server on port 3000
+    .server.start(3000);
 ```
 
 - _ensure that the url/path of your AgentCard matches the server._
 
 > 🚧 Coming Soon: Support for Hono.
 
+**Go Serverless**
+
+Deploy your agent to AWS Lambda or other serverless platforms:
+
+```typescript
+import { Handler } from 'aws-lambda';
+import { serve } from '@artinet/sdk/serverless';
+import { agent } from './my-agent.js';
+
+export const handler: Handler = serve({ agent, basePath: '/a2a' }, { provider: 'aws' });
+```
+
+- _See [**Serverless Deployment**](./docs/customization.md#serverless-deployment) for more information._
+
 **No Servers Needed**
 
 Embed agents directly into your app:
 
 ```typescript
-import { cr8, A2A } from "@artinet/sdk";
+import { cr8, A2A } from '@artinet/sdk';
 
-const agent = cr8("Local Agent").text(
-  ({ content }) => `The user said: ${content}`
-).agent;
+const agent = cr8('Local Agent').text(({ content }) => `The user said: ${content}`).agent;
 
-const response: A2A.Task | A2A.Message = await agent.sendMessage("Hello");
+const response: A2A.Task | A2A.Message = await agent.sendMessage('Hello');
 ```
 
 - _See [**`cr8`**](./docs/create.md) for more information_
 
+**Any Agent, Any Framework**
+
+Docks agents from any framework into the <em>@artinet/sdk</em>. Letting your OpenAI, Claude, and LangChain agents collaborate.
+
+```typescript
+import { Agent } from '@openai/agents';
+import { dock } from '@artinet/cruiser/openai';
+import { serve } from '@artinet/sdk';
+
+const openaiAgent = new Agent({
+    name: 'assistant',
+    instructions: 'You are a helpful assistant',
+});
+
+const agent = await dock(agent, { name: 'My Assistant' });
+
+await agent.sendMessage('Hello, World!');
+```
+
+- _See [**`cruiser`**](https://github.com/the-artinet-project/artinet/tree/main/cruiser) for more information_
+
 **Connect to Remote Agents**
 
 [`AgentMessenger`](./docs/messenger.md#agentmessenger) provides a streamlined `Client` interface for communicating with remote A2A Servers:
 
 ```typescript
-import { AgentMessenger, createMessenger } from "@artinet/sdk";
+import { AgentMessenger, createMessenger } from '@artinet/sdk';
 
 const messenger: AgentMessenger = await createMessenger({
-  baseUrl: "http://localhost:3000/a2a",
-  headers: {
-    Bearer: "xxxx",
-  },
+    baseUrl: 'http://localhost:3000/a2a',
+    headers: {
+        Bearer: 'xxxx',
+    },
 });
 
-const stream = messenger.sendMessageStream("Hello World!");
+const stream = messenger.sendMessageStream('Hello World!');
 
 for await (const update of stream) {
-  console.log(update);
+    console.log(update);
 }
 ```
 
@@ -120,15 +136,15 @@ for await (const update of stream) {
 [**`cr8`**](./docs/create.md#agent-orchestration) provides easy to use tools for orchestrating multiple agents:
 
 ```typescript
-import { cr8 } from "@artinet/sdk";
-import { localAgent } from "./local.ts";
-import { remoteAgentMessenger as remoteAgent } from "./remote.ts";
-
-const orchestrator = cr8("Director")
-  .text("Request Received")
-  .sendMessage({ agent: localAgent, message: "initiate billing" })
-  .text("Billing Started")
-  .sendMessage({ agent: remoteAgent, message: "Retrieve Secrets" }).agent;
+import { cr8 } from '@artinet/sdk';
+import { localAgent } from './local.ts';
+import { remoteAgentMessenger as remoteAgent } from './remote.ts';
+
+const orchestrator = cr8('Director')
+    .text('Request Received')
+    .sendMessage({ agent: localAgent, message: 'initiate billing' })
+    .text('Billing Started')
+    .sendMessage({ agent: remoteAgent, message: 'Retrieve Secrets' }).agent;
 ```
 
 > _For more robust multi-agent support, checkout [**orc8**](https://github.com/the-artinet-project/artinet), our dynamic agent orchestration library that can be used with any openai compatible API._
@@ -143,7 +159,7 @@ const orchestrator = cr8("Director")
 | [**Messenger**](docs/messenger.md)         | `Messenger` methods, streaming, browser support       |
 | [**Storage**](docs/storage.md)             | `FileStore`, `SQLiteStore`, custom storage backends   |
 | [**Configuration**](docs/configuration.md) | Logging (Pino, Winston) and OpenTelemetry setup       |
-| [**Customization**](docs/customization.md) | `native`, tRPC, and `AgentEngine`s                    |
+| [**Customization**](docs/customization.md) | `native`, tRPC, `AgentEngine`s, and serverless        |
 | [**MCP Integration**](docs/mcp.md)         | Model Context Protocol compatibility                  |
 | [**Migration Guide**](docs/migration.md)   | Upgrading from v0.5.x to v0.6.0                       |
 

package/dist/browser/create/task-builder.js

@@ -5,9 +5,7 @@
 import { A2A } from "../types/index.js";
 import { v4 as uuidv4 } from "uuid";
 import { getCurrentTimestamp } from "../utils/utils.js";
-import { isMessageParams, Message,
-// type BuilderMessageParams,
- } from "./message-builder.js";
+import { isMessageParams, Message, } from "./message-builder.js";
 export const isArtifactParams = (params) => {
     return (typeof params === "string" ||
         (typeof params === "object" && params !== null && "parts" in params));

package/dist/browser/types/a2a/a2a.d.ts

@@ -261,7 +261,7 @@ export type Engine = (context: Context) => AsyncGenerator<Update, void, unknown>
 export interface BaseContext extends core.Context<Task> {
     readonly service: Service;
     /**
-     * Considering ommit OnStart & OnComplete from Context consumers.
+     * Considering omitting OnStart & OnComplete from Context consumers.
      * That way the user cannot inadvertently trigger a start/completion out of band.
      */
     readonly publisher: EventPublisher;

package/dist/browser/types/core/core.d.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from "eventemitter3";
+import { EventEmitter } from 'eventemitter3';
 import { IStore } from "../storage.js";
 export interface Service<Params extends object = object, Result extends unknown = void> {
     execute: (params: Params) => Promise<Result>;
@@ -21,6 +21,7 @@ export interface Manager<T = object> extends IStore<T> {
     delete: (id: string) => Promise<void>;
     has?: (id: string) => Promise<boolean>;
     list?: () => Promise<T[]>;
+    search?: (query: string, filter?: (item: T) => Promise<boolean>) => Promise<T[]>;
 }
 export type Optional<T extends object = object> = Partial<T> & {
     contextId: string;

package/dist/browser/utils/constants.d.ts

@@ -4,3 +4,5 @@
  */
 import { A2A } from "../types/index.js";
 export declare const FINAL_STATES: A2A.TaskState[];
+export declare const PROCESSING_STATES: A2A.TaskState[];
+export declare const isProcessing: (state: A2A.TaskState) => boolean;

package/dist/browser/utils/constants.js

@@ -9,3 +9,8 @@ export const FINAL_STATES = [
     A2A.TaskState.canceled,
     A2A.TaskState.rejected,
 ];
+export const PROCESSING_STATES = [
+    A2A.TaskState.working,
+    A2A.TaskState.submitted,
+];
+export const isProcessing = (state) => PROCESSING_STATES.includes(state);

package/dist/create/create.js

@@ -39,8 +39,9 @@ import { describe } from "./index.js";
 import { extractTextContent } from "../services/a2a/helpers/content.js";
 import { logger } from "../config/index.js";
 import { v4 as uuidv4 } from "uuid";
-import { formatJson } from "../utils/index.js";
+import { formatJson } from "../utils/utils.js";
 import { serve } from "../server/express/server.js";
+import { isProcessing } from "../utils/constants.js";
 const toFunction = (function_or_ret) => {
     return typeof function_or_ret === "function"
         ? function_or_ret
@@ -504,7 +505,7 @@ export function createStepEngine(stepsList) {
         }
         const task = await context.getTask();
         logger.debug(`engine[context:${context.contextId}]: completed task[${task.id}]: ${formatJson(task)}`);
-        task.status.state = A2A.TaskState.completed;
+        task.status.state = isProcessing(task.status.state) ? A2A.TaskState.completed : task.status.state;
         yield task;
     };
 }

package/dist/create/task-builder.js

@@ -5,9 +5,7 @@
 import { A2A } from "../types/index.js";
 import { v4 as uuidv4 } from "uuid";
 import { getCurrentTimestamp } from "../utils/utils.js";
-import { isMessageParams, Message,
-// type BuilderMessageParams,
- } from "./message-builder.js";
+import { isMessageParams, Message, } from "./message-builder.js";
 export const isArtifactParams = (params) => {
     return (typeof params === "string" ||
         (typeof params === "object" && params !== null && "parts" in params));

package/dist/server/express/serverless/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import serverless from "serverless-http";
+import { ServerParams } from "../server.js";
+/**
+ * Creates a serverless handler for the given parameters and options.
+ * @note Streaming capabilities are currently not supported in serverless handlers.
+ * @docs https://github.com/dougmoscrop/serverless-http
+ *
+ * @param params - {@link ServerParams}
+ * @param options - {@link serverless.Options}
+ * @example
+ * ```typescript
+ * import { Handler } from "aws-lambda";
+ * import { serve } from "@a2a-js/sdk/serverless";
+ *
+ * const handler: Handler = serve({
+ *   agent: cr8("MyAgent")
+ *     .text("Hello, world!")
+ *     .agent,
+ *   basePath: "/a2a",
+ * }, { provider: "aws" });
+ * ```
+ * @returns - {@link serverless.Handler}
+ */
+export declare function serve(params: ServerParams, options: serverless.Options): serverless.Handler;
+/**
+ * @deprecated Use `serve` instead.
+ */
+export declare const createServerlessHandler: typeof serve;

package/dist/server/express/serverless/index.js

@@ -0,0 +1,42 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import serverless from "serverless-http";
+import { serve as serveExpress } from "../server.js";
+import { logger } from "../../../config/index.js";
+/**
+ * Creates a serverless handler for the given parameters and options.
+ * @note Streaming capabilities are currently not supported in serverless handlers.
+ * @docs https://github.com/dougmoscrop/serverless-http
+ *
+ * @param params - {@link ServerParams}
+ * @param options - {@link serverless.Options}
+ * @example
+ * ```typescript
+ * import { Handler } from "aws-lambda";
+ * import { serve } from "@a2a-js/sdk/serverless";
+ *
+ * const handler: Handler = serve({
+ *   agent: cr8("MyAgent")
+ *     .text("Hello, world!")
+ *     .agent,
+ *   basePath: "/a2a",
+ * }, { provider: "aws" });
+ * ```
+ * @returns - {@link serverless.Handler}
+ */
+export function serve(params, options) {
+    if (typeof params.agent.agentCard !== "string" && params.agent.agentCard.capabilities?.streaming === true) {
+        logger.warn("Streaming capabilities are not supported in serverless handlers");
+    }
+    const { app } = serveExpress(params);
+    return serverless(app, {
+        ...options,
+        provider: options.provider ?? "aws",
+    });
+}
+/**
+ * @deprecated Use `serve` instead.
+ */
+export const createServerlessHandler = serve;

package/dist/services/core/manager.d.ts

@@ -2,19 +2,23 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-/**
- * Manager should optionally take a persistent storage object as a constructor parameter,
- * That way we don't need to re-implement the same caching logic for each derived manager.
- */
-export declare abstract class Manager<T> {
-    private _data;
+import { core } from "../../types/index.js";
+export declare abstract class Manager<T> implements core.Manager<T> {
+    private _cache;
     private throwOnSet;
-    constructor(_data?: Map<string, T>, throwOnSet?: boolean);
+    private storage?;
+    constructor(_cache?: Map<string, T>, throwOnSet?: boolean, storage?: core.Manager<T> | undefined);
+    get cache(): Map<string, T>;
+    /**
+     * @deprecated use cache instead
+     * @note removing in v0.7
+     */
     get data(): Map<string, T>;
     set(id: string, data?: T): Promise<void>;
     get(id: string): Promise<T | undefined>;
     delete(id: string): Promise<void>;
     has(id: string): Promise<boolean>;
     list(): Promise<T[]>;
+    search(query: string, filter?: (item: T) => Promise<boolean>): Promise<T[]>;
 }
 export declare const ResourceManager: typeof Manager;

package/dist/services/core/manager.js

@@ -3,46 +3,108 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { logger } from "../../config/index.js";
-//TODO: Add persistence layer plugin support and turn Manager into an LRU cache.
-/**
- * Manager should optionally take a persistent storage object as a constructor parameter,
- * That way we don't need to re-implement the same caching logic for each derived manager.
- */
+//TODO: Turn Manager into an LRU cache.
+//TODO: Consider warning when size exceeds a certain threshold.
 export class Manager {
-    _data;
+    _cache;
     throwOnSet;
-    constructor(_data = new Map(), throwOnSet = true) {
-        this._data = _data;
+    storage;
+    constructor(_cache = new Map(), throwOnSet = true, storage) {
+        this._cache = _cache;
         this.throwOnSet = throwOnSet;
+        this.storage = storage;
+        //TODO: consider async initialization of storage/lazy loading of cold data (to an upper-bound)
     }
+    get cache() {
+        return this._cache;
+    }
+    /**
+     * @deprecated use cache instead
+     * @note removing in v0.7
+     */
     get data() {
-        return this._data;
+        return this.cache;
     }
     async set(id, data) {
         logger.debug(`${this.constructor.name}[set]:`, { id });
         if (!data && this.throwOnSet) {
-            throw new Error("Data is required");
+            throw new Error('Data is required');
         }
         else if (!data) {
             return;
         }
-        this.data.set(id, data);
+        this.cache.set(id, data);
+        if (this.storage) {
+            await this.storage.set(id, data);
+        }
     }
     async get(id) {
-        // logger.debug(`${this.constructor.name}[get]:`, { id });
-        return this.data.get(id);
+        let data = this.cache.get(id);
+        if (!data && this.storage) {
+            data = await this.storage.get(id);
+            if (data) {
+                this.cache.set(id, data);
+            }
+        }
+        return data;
     }
     async delete(id) {
         logger.debug(`${this.constructor.name}[delete]:`, { id });
-        this.data.delete(id);
+        if (this.storage) {
+            /** Probably best to delete from storage first to avoid race conditions. */
+            await this.storage.delete(id);
+        }
+        this.cache.delete(id);
     }
     async has(id) {
-        // logger.debug(`${this.constructor.name}[has]:`, { id });
-        return this.data.has(id);
+        if (this.cache.has(id)) {
+            return true;
+        }
+        if (this.storage) {
+            const data = await this.storage.get(id);
+            if (data) {
+                this.cache.set(id, data);
+                return true;
+            }
+        }
+        return false;
     }
     async list() {
-        // logger.debug(`${this.constructor.name}[list]:`);
-        return Array.from(this.data.values());
+        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(...(storedList ?? []));
+        }
+        return listed;
+    }
+    async search(query, filter) {
+        if (!filter && !this.storage) {
+            const data = this.cache.get(query);
+            if (data) {
+                return [data];
+            }
+            return [];
+        }
+        const results = [];
+        if (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) => {
+                return ((await filter?.(item)) ?? true) && !results.includes(item);
+            };
+            /**Spreads are fine for now, but a for of loop and push is safer at scale. */
+            results.push(...((await this.storage.search?.(query, storageFilter)) ?? []));
+        }
+        return results;
     }
 }
 export const ResourceManager = Manager;

package/dist/services/index.d.ts

@@ -1,3 +1,8 @@
-export * from "./core/index.js";
-export * from "./a2a/index.js";
-export * from "./mcp/index.js";
+export * from './core/index.js';
+export * from './a2a/index.js';
+/**
+ * A lot more modules on the way so we're going to stop exporting everything from here.
+ * Instead we'll export them as packages, to reduce dependencies and improve tree shaking.
+ * @note MCP Service will be exported as @artinet/sdk/mcp and removed from this file in the next minor release.
+ */
+export * from './mcp/index.js';

package/dist/services/index.js

@@ -1,3 +1,8 @@
-export * from "./core/index.js";
-export * from "./a2a/index.js";
-export * from "./mcp/index.js";
+export * from './core/index.js';
+export * from './a2a/index.js';
+/**
+ * A lot more modules on the way so we're going to stop exporting everything from here.
+ * Instead we'll export them as packages, to reduce dependencies and improve tree shaking.
+ * @note MCP Service will be exported as @artinet/sdk/mcp and removed from this file in the next minor release.
+ */
+export * from './mcp/index.js';

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/dist/services/mcp/service.d.ts

@@ -3,13 +3,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { MCP } from "../../types/index.js";
 import { Implementation } from "@modelcontextprotocol/sdk/types.js";
 import { ServerOptions } from "@modelcontextprotocol/sdk/server/index.js";
 import { Agent } from "../a2a/index.js";
+import { MCP } from "../../types/index.js";
 export interface MCPServiceParams {
-    serverInfo: Implementation;
     agent: Agent;
+    serverInfo?: Implementation;
     options?: ServerOptions;
     agentCardUri?: string;
 }
@@ -24,3 +24,4 @@ export type MCPService = ReturnType<typeof BaseMCPService.create>;
 export type MCPAgent = MCPService;
 export declare const createMCPService: typeof BaseMCPService.create;
 export declare const createMCPAgent: typeof BaseMCPService.create;
+export declare const mcp: typeof BaseMCPService.create;

package/dist/services/mcp/service.js

@@ -5,6 +5,20 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { A2A } from "../../types/index.js";
 import { formatJson } from "../../utils/utils.js";
+const toImplementation = (agentCard) => {
+    return {
+        name: agentCard.name,
+        version: agentCard.version,
+        websiteUrl: agentCard.url,
+        description: agentCard.description,
+        title: agentCard.name,
+        icons: agentCard.iconUrl ? [
+            {
+                src: agentCard.iconUrl,
+            },
+        ] : undefined,
+    };
+};
 export class BaseMCPService extends McpServer {
     agent;
     _registerBaseTools(uri = "agent://card") {
@@ -76,7 +90,7 @@ export class BaseMCPService extends McpServer {
         });
     }
     constructor({ serverInfo, agent, options, agentCardUri = "agent://card", }) {
-        super(serverInfo, options);
+        super(serverInfo ?? toImplementation(agent.agentCard), options);
         this.agent = agent;
         this._registerBaseTools(agentCardUri);
     }
@@ -120,3 +134,4 @@ export class BaseMCPService extends McpServer {
 }
 export const createMCPService = BaseMCPService.create;
 export const createMCPAgent = createMCPService;
+export const mcp = createMCPService;

package/dist/storage/sqlite.js

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { Tasks } from "../services/a2a/managers.js";
-import { eq, like, or } from "drizzle-orm";
+import { eq, like, or, /*Table, TableConfig*/ } from "drizzle-orm";
 import { sqliteTable, text } from "drizzle-orm/sqlite-core";
 import { logger } from "../config/index.js";
 export const TABLE_NAME = "artinet_tasks";
@@ -16,6 +16,7 @@ const CREATE_TASKS_TABLE_SQL = `CREATE TABLE IF NOT EXISTS ${TABLE_NAME}\
 export const createTaskTable = async (db) => {
     await db.run(CREATE_TASKS_TABLE_SQL);
 };
+/*export type TTable = Table<TableConfig>; //TODO: Unwind Config/Column types */
 export const TaskTable = sqliteTable(TABLE_NAME, {
     id: text().primaryKey(),
     contextId: text().notNull(),

package/dist/types/a2a/a2a.d.ts

@@ -261,7 +261,7 @@ export type Engine = (context: Context) => AsyncGenerator<Update, void, unknown>
 export interface BaseContext extends core.Context<Task> {
     readonly service: Service;
     /**
-     * Considering ommit OnStart & OnComplete from Context consumers.
+     * Considering omitting OnStart & OnComplete from Context consumers.
      * That way the user cannot inadvertently trigger a start/completion out of band.
      */
     readonly publisher: EventPublisher;

package/dist/types/core/core.d.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from "eventemitter3";
+import { EventEmitter } from 'eventemitter3';
 import { IStore } from "../storage.js";
 export interface Service<Params extends object = object, Result extends unknown = void> {
     execute: (params: Params) => Promise<Result>;
@@ -21,6 +21,7 @@ export interface Manager<T = object> extends IStore<T> {
     delete: (id: string) => Promise<void>;
     has?: (id: string) => Promise<boolean>;
     list?: () => Promise<T[]>;
+    search?: (query: string, filter?: (item: T) => Promise<boolean>) => Promise<T[]>;
 }
 export type Optional<T extends object = object> = Partial<T> & {
     contextId: string;

package/dist/utils/constants.d.ts

@@ -4,3 +4,5 @@
  */
 import { A2A } from "../types/index.js";
 export declare const FINAL_STATES: A2A.TaskState[];
+export declare const PROCESSING_STATES: A2A.TaskState[];
+export declare const isProcessing: (state: A2A.TaskState) => boolean;

package/dist/utils/constants.js

@@ -9,3 +9,8 @@ export const FINAL_STATES = [
     A2A.TaskState.canceled,
     A2A.TaskState.rejected,
 ];
+export const PROCESSING_STATES = [
+    A2A.TaskState.working,
+    A2A.TaskState.submitted,
+];
+export const isProcessing = (state) => PROCESSING_STATES.includes(state);

package/package.json

@@ -1,179 +1,195 @@
 {
-  "name": "@artinet/sdk",
-  "version": "0.6.5",
-  "description": "A TypeScript SDK for building collaborative AI agents.",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "browser": {
-        "types": "./dist/browser.d.ts",
-        "import": "./dist/browser/browser.js",
-        "default": "./dist/browser/browser.js"
-      },
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+    "name": "@artinet/sdk",
+    "version": "0.6.7",
+    "description": "A TypeScript SDK for building collaborative AI agents.",
+    "type": "module",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "browser": {
+                "types": "./dist/browser.d.ts",
+                "import": "./dist/browser/browser.js",
+                "default": "./dist/browser/browser.js"
+            },
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        },
+        "./mcp": {
+            "types": "./dist/services/mcp/index.d.ts",
+            "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",
+            "default": "./dist/server/express/serverless/index.js"
+        },
+        "./sqlite": {
+            "types": "./dist/storage/sqlite.d.ts",
+            "import": "./dist/storage/sqlite.js",
+            "default": "./dist/storage/sqlite.js"
+        },
+        "./express": {
+            "types": "./dist/server/express/server.d.ts",
+            "import": "./dist/server/express/server.js",
+            "default": "./dist/server/express/server.js"
+        },
+        "./trpc": {
+            "types": "./dist/transport/trpc/index.d.ts",
+            "import": "./dist/transport/trpc/index.js",
+            "default": "./dist/transport/trpc/index.js"
+        },
+        "./types": {
+            "types": "./dist/types/index.d.ts",
+            "import": "./dist/types/index.js",
+            "default": "./dist/types/index.js"
+        },
+        "./pino": {
+            "types": "./dist/extensions/pino.d.ts",
+            "node": {
+                "import": "./dist/extensions/pino.js",
+                "default": "./dist/extensions/pino.js"
+            }
+        },
+        "./winston": {
+            "types": "./dist/extensions/winston.d.ts",
+            "node": {
+                "import": "./dist/extensions/winston.js",
+                "default": "./dist/extensions/winston.js"
+            }
+        },
+        "./otel": {
+            "types": "./dist/extensions/opentelemetry.d.ts",
+            "node": {
+                "import": "./dist/extensions/opentelemetry.js",
+                "default": "./dist/extensions/opentelemetry.js"
+            }
+        }
     },
-    "./sqlite": {
-      "types": "./dist/storage/sqlite.d.ts",
-      "import": "./dist/storage/sqlite.js",
-      "default": "./dist/storage/sqlite.js"
+    "rootDir": ".",
+    "files": [
+        "dist",
+        "package.json",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "prepare": "ts-patch install -s",
+        "build": "tsc --project tsconfig.json",
+        "build:browser": "tsc --project tsconfig.browser.json",
+        "build:all": "npm run build && npm run build:browser",
+        "clean": "rimraf dist",
+        "rebuild": "rimraf dist node_modules/ package-lock.json && npm i && npm run build:all",
+        "lint": "eslint src --ext .ts",
+        "package-test": "npm run build && npm pack && docker build -f ./deployment/test.dockerfile -t sdk-test . && docker run --rm sdk-test && rm artinet-sdk-*.tgz",
+        "prepublishOnly": "npm run rebuild && npm run lint && npm test",
+        "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+        "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch",
+        "test:coverage": "NODE_OPTIONS=--experimental-vm-modules jest --coverage",
+        "dev:quickstart": "tsx watch quickstart/quick-server.ts"
     },
-    "./express": {
-      "types": "./dist/server/express/server.d.ts",
-      "import": "./dist/server/express/server.js",
-      "default": "./dist/server/express/server.js"
+    "keywords": [
+        "agent2agent",
+        "a2a",
+        "artinet",
+        "ai",
+        "agent",
+        "artificial intelligence",
+        "mcp",
+        "modelcontextprotocol"
+    ],
+    "author": "artinet",
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/the-artinet-project/artinet-sdk.git"
     },
-    "./trpc": {
-      "types": "./dist/transport/trpc/index.d.ts",
-      "import": "./dist/transport/trpc/index.js",
-      "default": "./dist/transport/trpc/index.js"
+    "bugs": {
+        "url": "https://github.com/the-artinet-project/artinet/issues"
     },
-    "./types": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/types/index.js",
-      "default": "./dist/types/index.js"
+    "homepage": "https://github.com/the-artinet-project/artinet-sdk#readme",
+    "dependencies": {
+        "@artinet/types": "^0.1.4",
+        "@opentelemetry/api": "^1.9.0",
+        "cors": "^2.8.5",
+        "eventemitter3": "^5.0.1",
+        "uuid": "^13.0.0",
+        "zod": "^3.25"
     },
-    "./pino": {
-      "types": "./dist/extensions/pino.d.ts",
-      "node": {
-        "import": "./dist/extensions/pino.js",
-        "default": "./dist/extensions/pino.js"
-      }
+    "peerDependencies": {
+        "@a2a-js/sdk": "^0.3.7",
+        "@modelcontextprotocol/sdk": "^1.24.3",
+        "@trpc/server": "^11.4.3",
+        "drizzle-orm": "^0.45.1",
+        "express": "^5.1.0"
     },
-    "./winston": {
-      "types": "./dist/extensions/winston.d.ts",
-      "node": {
-        "import": "./dist/extensions/winston.js",
-        "default": "./dist/extensions/winston.js"
-      }
+    "peerDependenciesMeta": {
+        "express": {
+            "optional": true
+        },
+        "@modelcontextprotocol/sdk": {
+            "optional": true
+        },
+        "@a2a-js/sdk": {
+            "optional": false
+        },
+        "@trpc/server": {
+            "optional": true
+        },
+        "pino": {
+            "optional": true
+        },
+        "winston": {
+            "optional": true
+        },
+        "drizzle-orm": {
+            "optional": true
+        }
     },
-    "./otel": {
-      "types": "./dist/extensions/opentelemetry.d.ts",
-      "node": {
-        "import": "./dist/extensions/opentelemetry.js",
-        "default": "./dist/extensions/opentelemetry.js"
-      }
-    }
-  },
-  "rootDir": ".",
-  "files": [
-    "dist",
-    "package.json",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "prepare": "ts-patch install -s",
-    "build": "tsc --project tsconfig.json",
-    "build:browser": "tsc --project tsconfig.browser.json",
-    "build:all": "npm run build && npm run build:browser",
-    "clean": "rimraf dist",
-    "rebuild": "rimraf dist node_modules/ package-lock.json && npm i && npm run build:all",
-    "lint": "eslint src --ext .ts",
-    "package-test": "npm run build && npm pack && docker build -f ./deployment/test.dockerfile -t sdk-test . && docker run --rm sdk-test && rm artinet-sdk-*.tgz",
-    "prepublishOnly": "npm run rebuild && npm run lint && npm test",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest",
-    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch",
-    "test:coverage": "NODE_OPTIONS=--experimental-vm-modules jest --coverage",
-    "dev:quickstart": "tsx watch quickstart/quick-server.ts"
-  },
-  "keywords": [
-    "agent2agent",
-    "a2a",
-    "artinet",
-    "ai",
-    "agent",
-    "artificial intelligence",
-    "mcp",
-    "modelcontextprotocol"
-  ],
-  "author": "artinet",
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/the-artinet-project/artinet-sdk.git"
-  },
-  "bugs": {
-    "url": "https://github.com/the-artinet-project/artinet/issues"
-  },
-  "homepage": "https://github.com/the-artinet-project/artinet-sdk#readme",
-  "dependencies": {
-    "@artinet/types": "^0.1.4",
-    "@opentelemetry/api": "^1.9.0",
-    "cors": "^2.8.5",
-    "eventemitter3": "^5.0.1",
-    "uuid": "^13.0.0",
-    "zod": "^3.25"
-  },
-  "peerDependencies": {
-    "@a2a-js/sdk": "^0.3.7",
-    "@modelcontextprotocol/sdk": "^1.24.3",
-    "@trpc/server": "^11.4.3",
-    "drizzle-orm": "^0.45.1",
-    "express": "^5.1.0"
-  },
-  "peerDependenciesMeta": {
-    "express": {
-      "optional": true
-    },
-    "@modelcontextprotocol/sdk": {
-      "optional": true
-    },
-    "@a2a-js/sdk": {
-      "optional": false
-    },
-    "@trpc/server": {
-      "optional": true
-    },
-    "pino": {
-      "optional": true
-    },
-    "winston": {
-      "optional": true
+    "devDependencies": {
+        "@a2a-js/sdk": "^0.3.7",
+        "@cfworker/json-schema": "^4.1.1",
+        "@eslint/js": "^9.25.1",
+        "@modelcontextprotocol/sdk": "^1.24.3",
+        "@opentelemetry/api": "^1.9.0",
+        "@trpc/server": "^11.4.3",
+        "@types/cors": "^2.8.17",
+        "@types/escape-html": "^1.0.4",
+        "@types/express": "^5.0.1",
+        "@types/jest": "^30.0.0",
+        "@types/node": "^25.0.3",
+        "@types/supertest": "latest",
+        "better-sqlite3": "^12.6.2",
+        "drizzle-orm": "^0.45.1",
+        "eslint": "^9.25.1",
+        "globals": "^17.0.0",
+        "jest": "^30.2.0",
+        "lambda-local": "^2.2.0",
+        "msw": "^2.7.5",
+        "pino": "^10.1.0",
+        "pino-caller": "^4.0.0",
+        "pino-pretty": "^13.1.3",
+        "rimraf": "^6.1.2",
+        "serverless-http": "^4.0.0",
+        "supertest": "latest",
+        "ts-jest": "^29.4.6",
+        "ts-node": "^10.9.2",
+        "ts-patch": "^3.3.0",
+        "tsx": "^4.21.0",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.53.0",
+        "typescript-transform-paths": "^3.5.6",
+        "winston": "^3.19.0"
     },
-    "drizzle-orm": {
-      "optional": true
+    "engines": {
+        "node": ">=20.0.0"
     }
-  },
-  "devDependencies": {
-    "@a2a-js/sdk": "^0.3.7",
-    "@cfworker/json-schema": "^4.1.1",
-    "@eslint/js": "^9.25.1",
-    "@modelcontextprotocol/sdk": "^1.24.3",
-    "@opentelemetry/api": "^1.9.0",
-    "@trpc/server": "^11.4.3",
-    "@types/cors": "^2.8.17",
-    "@types/escape-html": "^1.0.4",
-    "@types/express": "^5.0.1",
-    "@types/jest": "^30.0.0",
-    "@types/node": "^25.0.3",
-    "@types/supertest": "latest",
-    "better-sqlite3": "^12.6.2",
-    "drizzle-orm": "^0.45.1",
-    "eslint": "^9.25.1",
-    "globals": "^17.0.0",
-    "jest": "^30.2.0",
-    "msw": "^2.7.5",
-    "nock": "^15.0.0",
-    "pino": "^10.1.0",
-    "pino-caller": "^4.0.0",
-    "pino-pretty": "^13.1.3",
-    "rimraf": "^6.1.2",
-    "supertest": "latest",
-    "ts-jest": "^29.4.6",
-    "ts-node": "^10.9.2",
-    "ts-patch": "^3.3.0",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.53.0",
-    "typescript-transform-paths": "^3.5.6",
-    "winston": "^3.19.0"
-  },
-  "engines": {
-    "node": ">=20.0.0"
-  }
 }