@frontmcp/sdk 0.7.2 → 0.8.0

package/transport/event-stores/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * EventStore Module
+ *
+ * Provides EventStore implementations for SSE resumability support.
+ * When enabled, clients can reconnect and resume missed SSE messages
+ * using the Last-Event-ID header per the MCP protocol.
+ *
+ * @module transport/event-stores
+ *
+ * @example Disabled (default - no resumability)
+ * ```typescript
+ * // In @FrontMcp config, eventStore is undefined by default
+ * // This disables SSE resumability
+ * ```
+ *
+ * @example Memory EventStore (single-node)
+ * ```typescript
+ * import { createEventStore } from '@frontmcp/sdk/transport/event-stores';
+ *
+ * const { eventStore, type } = createEventStore({
+ *   enabled: true,
+ *   provider: 'memory',
+ *   maxEvents: 10000,
+ *   ttlMs: 300000,
+ * });
+ * ```
+ *
+ * @example Redis EventStore (distributed)
+ * ```typescript
+ * import { createEventStore } from '@frontmcp/sdk/transport/event-stores';
+ *
+ * const { eventStore, type } = createEventStore({
+ *   enabled: true,
+ *   provider: 'redis',
+ *   redis: { host: 'localhost', port: 6379 },
+ *   maxEvents: 10000,
+ *   ttlMs: 300000,
+ * });
+ * ```
+ */
+export { createEventStore } from './event-store.factory';
+export type { EventStoreConfig, EventStoreResult } from './event-store.factory';
+export { MemoryEventStore } from './memory.event-store';
+export type { MemoryEventStoreOptions } from './memory.event-store';
+export { RedisEventStore } from './redis.event-store';
+export type { RedisEventStoreOptions } from './redis.event-store';
+//# sourceMappingURL=index.d.ts.map

package/transport/event-stores/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transport/event-stores/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAGhF,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,YAAY,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAGpE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,YAAY,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC"}

package/transport/event-stores/memory.event-store.d.ts

@@ -0,0 +1,51 @@
+import type { EventId, EventStore, StreamId } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+export interface MemoryEventStoreOptions {
+    /** Maximum number of events to store before eviction. Default: 10000 */
+    maxEvents?: number;
+    /** TTL in milliseconds for stored events. Default: 300000 (5 minutes) */
+    ttlMs?: number;
+}
+/**
+ * Bounded in-memory EventStore for SSE resumability support.
+ *
+ * Features:
+ * - TTL-based expiration of old events
+ * - Max events limit with LRU eviction
+ * - Per-stream storage with global index
+ *
+ * Use this for single-node deployments or development.
+ * For distributed deployments, use RedisEventStore instead.
+ */
+export declare class MemoryEventStore implements EventStore {
+    private streams;
+    private index;
+    private readonly maxEvents;
+    private readonly ttlMs;
+    constructor(options?: MemoryEventStoreOptions);
+    storeEvent(streamId: StreamId, message: JSONRPCMessage): Promise<EventId>;
+    replayEventsAfter(lastEventId: EventId, { send }: {
+        send: (eventId: EventId, message: JSONRPCMessage) => Promise<void>;
+    }): Promise<StreamId>;
+    /**
+     * Evict all expired events across all streams
+     */
+    private evictExpired;
+    /**
+     * Evict the oldest event across all streams
+     */
+    private evictOldest;
+    /**
+     * Rebuild the index for a specific stream after modification
+     */
+    private rebuildIndex;
+    /**
+     * Clear all stored events (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Get the current number of stored events
+     */
+    get size(): number;
+}
+//# sourceMappingURL=memory.event-store.d.ts.map

package/transport/event-stores/memory.event-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.event-store.d.ts","sourceRoot":"","sources":["../../../src/transport/event-stores/memory.event-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,oDAAoD,CAAC;AACxG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAQzE,MAAM,WAAW,uBAAuB;IACtC,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,gBAAiB,YAAW,UAAU;IACjD,OAAO,CAAC,OAAO,CAAsC;IACrD,OAAO,CAAC,KAAK,CAA2D;IACxE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;gBAEnB,OAAO,GAAE,uBAA4B;IAK3C,UAAU,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;IAmBzE,iBAAiB,CACrB,WAAW,EAAE,OAAO,EACpB,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,GAC/E,OAAO,CAAC,QAAQ,CAAC;IAuBpB;;OAEG;IACH,OAAO,CAAC,YAAY;IAYpB;;OAEG;IACH,OAAO,CAAC,WAAW;IAsBnB;;OAEG;IACH,OAAO,CAAC,YAAY;IAWpB;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/transport/event-stores/redis.event-store.d.ts

@@ -0,0 +1,79 @@
+import type { EventId, EventStore, StreamId } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import type { RedisOptionsInput } from '../../common';
+export interface RedisEventStoreOptions {
+    /**
+     * Redis configuration.
+     * Supports both Redis (ioredis) and Vercel KV providers.
+     */
+    redis: RedisOptionsInput;
+    /**
+     * Key prefix for all event keys.
+     * @default 'mcp:events:'
+     */
+    keyPrefix?: string;
+    /**
+     * Maximum number of events per stream.
+     * @default 10000
+     */
+    maxEvents?: number;
+    /**
+     * TTL in milliseconds for stored events.
+     * @default 300000 (5 minutes)
+     */
+    ttlMs?: number;
+}
+/**
+ * Redis-based EventStore for SSE resumability support.
+ *
+ * Uses Redis Streams (XADD) for efficient event storage and retrieval.
+ * Suitable for distributed deployments where multiple server instances
+ * need to share event state for SSE resumability.
+ *
+ * Features:
+ * - Uses Redis Streams for efficient event storage
+ * - TTL-based expiration via key TTL
+ * - Max events limit via MAXLEN trimming
+ * - Automatic Redis client lazy initialization
+ *
+ * @example
+ * ```typescript
+ * const eventStore = new RedisEventStore({
+ *   redis: { provider: 'redis', host: 'localhost', port: 6379 },
+ *   maxEvents: 10000,
+ *   ttlMs: 300000,
+ * });
+ * ```
+ */
+export declare class RedisEventStore implements EventStore {
+    private client;
+    private readonly keyPrefix;
+    private readonly maxEvents;
+    private readonly ttlSeconds;
+    private readonly redisOptions;
+    constructor(options: RedisEventStoreOptions);
+    /**
+     * Get or create the Redis client.
+     * Uses lazy initialization to avoid connection issues at startup.
+     */
+    private getClient;
+    storeEvent(streamId: StreamId, message: JSONRPCMessage): Promise<EventId>;
+    replayEventsAfter(lastEventId: EventId, { send }: {
+        send: (eventId: EventId, message: JSONRPCMessage) => Promise<void>;
+    }): Promise<StreamId>;
+    /**
+     * Parse an event ID into stream ID and Redis stream entry ID.
+     *
+     * Event IDs have format: `{streamId}:{redisStreamEntryId}`
+     * Redis stream entry IDs have format: `{timestamp}-{sequence}`
+     *
+     * @example
+     * 'my-stream:1234567890123-0' -> ['my-stream', '1234567890123-0']
+     */
+    private parseEventId;
+    /**
+     * Close the Redis client connection.
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=redis.event-store.d.ts.map

package/transport/event-stores/redis.event-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.event-store.d.ts","sourceRoot":"","sources":["../../../src/transport/event-stores/redis.event-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,oDAAoD,CAAC;AACxG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,KAAK,EAAE,iBAAiB,CAAC;IAEzB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,eAAgB,YAAW,UAAU;IAChD,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;gBAErC,OAAO,EAAE,sBAAsB;IAO3C;;;OAGG;YACW,SAAS;IAmDjB,UAAU,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBzE,iBAAiB,CACrB,WAAW,EAAE,OAAO,EACpB,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,GAC/E,OAAO,CAAC,QAAQ,CAAC;IAqBpB;;;;;;;;OAQG;IACH,OAAO,CAAC,YAAY;IAYpB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAM7B"}

package/transport/flows/handle.sse.flow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handle.sse.flow.d.ts","sourceRoot":"","sources":["../../../src/transport/flows/handle.sse.flow.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,eAAe,EACf,cAAc,EACd,gBAAgB,EAEhB,QAAQ,EAST,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,IAAI;;;;;CAKoB,CAAC;AAoBtC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAItB,CAAC;AAEH,QAAA,MAAM,IAAI,EAAG,mBAA4B,CAAC;AAG1C,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,mBAAmB,EAAE,cAAc,CACjC,aAAa,EACb,OAAO,IAAI,EACX,OAAO,eAAe,EACtB,OAAO,gBAAgB,EACvB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAoBD,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAExD,UAAU;IAiEV,MAAM;IAkBN,YAAY;IAaZ,cAAc;IAad,SAAS;CAqChB"}
+{"version":3,"file":"handle.sse.flow.d.ts","sourceRoot":"","sources":["../../../src/transport/flows/handle.sse.flow.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,eAAe,EACf,cAAc,EACd,gBAAgB,EAEhB,QAAQ,EAQT,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,IAAI;;;;;CAKoB,CAAC;AAoBtC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAItB,CAAC;AAEH,QAAA,MAAM,IAAI,EAAG,mBAA4B,CAAC;AAG1C,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,mBAAmB,EAAE,cAAc,CACjC,aAAa,EACb,OAAO,IAAI,EACX,OAAO,eAAe,EACtB,OAAO,gBAAgB,EACvB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAoBD,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAExD,UAAU;IAsEV,MAAM;IAkBN,YAAY;IAaZ,cAAc;IAad,SAAS;CAqChB"}

package/transport/flows/handle.streamable-http.flow.d.ts

@@ -2,7 +2,7 @@ import { httpInputSchema, FlowRunOptions, httpOutputSchema, FlowBase } from '../
 import { z } from 'zod';
 export declare const plan: {
     readonly pre: ["parseInput", "router"];
-    readonly execute: ["onInitialize", "onMessage", "onElicitResult", "onSseListener"];
+    readonly execute: ["onInitialize", "onMessage", "onElicitResult", "onSseListener", "onExtApps"];
     readonly post: [];
     readonly finalize: ["cleanup"];
 };
@@ -39,6 +39,7 @@ export declare const stateSchema: z.ZodObject<{
     requestType: z.ZodOptional<z.ZodEnum<{
         message: "message";
         initialize: "initialize";
+        extApps: "extApps";
         elicitResult: "elicitResult";
         sseListener: "sseListener";
     }>>;
@@ -57,6 +58,7 @@ export default class HandleStreamableHttpFlow extends FlowBase<typeof name> {
     onElicitResult(): Promise<void>;
     onMessage(): Promise<void>;
     onSseListener(): Promise<void>;
+    onExtApps(): Promise<void>;
 }
 export {};
 //# sourceMappingURL=handle.streamable-http.flow.d.ts.map

package/transport/flows/handle.streamable-http.flow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handle.streamable-http.flow.d.ts","sourceRoot":"","sources":["../../../src/transport/flows/handle.streamable-http.flow.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,eAAe,EACf,cAAc,EACd,gBAAgB,EAEhB,QAAQ,EAQT,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,IAAI;;;;;CAKoB,CAAC;AAoBtC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAItB,CAAC;AAEH,QAAA,MAAM,IAAI,EAAG,wBAAiC,CAAC;AAG/C,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,wBAAwB,EAAE,cAAc,CACtC,wBAAwB,EACxB,OAAO,IAAI,EACX,OAAO,eAAe,EACtB,OAAO,gBAAgB,EACvB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AASD,MAAM,CAAC,OAAO,OAAO,wBAAyB,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IACzE,IAAI,2BAAQ;IAGN,UAAU;IA4DV,MAAM;IA8BN,YAAY;IAmCZ,cAAc;IAOd,SAAS;IAsGT,aAAa;CA6CpB"}
+{"version":3,"file":"handle.streamable-http.flow.d.ts","sourceRoot":"","sources":["../../../src/transport/flows/handle.streamable-http.flow.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,eAAe,EACf,cAAc,EACd,gBAAgB,EAEhB,QAAQ,EAOT,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,IAAI;;;;;CAKoB,CAAC;AAoBtC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAItB,CAAC;AAEH,QAAA,MAAM,IAAI,EAAG,wBAAiC,CAAC;AAG/C,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,wBAAwB,EAAE,cAAc,CACtC,wBAAwB,EACxB,OAAO,IAAI,EACX,OAAO,eAAe,EACtB,OAAO,gBAAgB,EACvB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AASD,MAAM,CAAC,OAAO,OAAO,wBAAyB,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IACzE,IAAI,2BAAQ;IAGN,UAAU;IAsDV,MAAM;IAiCN,YAAY;IAmCZ,cAAc;IAqEd,SAAS;IAsGT,aAAa;IAiDb,SAAS;CAwGhB"}

package/transport/in-memory-server.d.ts

@@ -0,0 +1,85 @@
+/**
+ * In-Memory MCP Server Factory
+ *
+ * Creates an in-memory FrontMCP server that can be consumed by MCP SDK Client.
+ * Useful for testing, embedding in applications, and LangChain integration.
+ */
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { Scope } from '../scope/scope.instance';
+/**
+ * Options for creating an in-memory MCP server.
+ */
+export interface CreateInMemoryServerOptions {
+    /** Auth info to inject on all client requests */
+    authInfo?: Partial<AuthInfo>;
+    /** Custom session ID (auto-generated if not provided) */
+    sessionId?: string;
+}
+/**
+ * Result from creating an in-memory server.
+ */
+export interface InMemoryServerResult {
+    /** Transport to pass to MCP Client.connect() */
+    clientTransport: Transport;
+    /** Set auth info for subsequent requests */
+    setAuthInfo: (authInfo: Partial<AuthInfo>) => void;
+    /** Disconnect the in-memory server */
+    close: () => Promise<void>;
+}
+/**
+ * Create an in-memory FrontMCP server that can be consumed by MCP SDK Client.
+ *
+ * This is useful for:
+ * - Testing MCP tools, resources, and prompts
+ * - Embedding FrontMCP in other applications
+ * - Integration with LangChain MCP adapters
+ * - Avoiding HTTP overhead in single-process scenarios
+ *
+ * @example
+ * ```typescript
+ * import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+ * import { FrontMcpInstance, createInMemoryServer } from '@frontmcp/sdk';
+ *
+ * // Create a FrontMCP instance
+ * const frontMcp = await FrontMcpInstance.createForGraph(config);
+ * const scope = frontMcp.getScopes()[0];
+ *
+ * // Create in-memory server
+ * const { clientTransport, setAuthInfo, close } = await createInMemoryServer(scope, {
+ *   authInfo: { token: 'test-token', user: { sub: 'user-123' } }
+ * });
+ *
+ * // Connect MCP client
+ * const client = new Client({ name: 'test-client', version: '1.0.0' });
+ * await client.connect(clientTransport);
+ *
+ * // Use the client
+ * const tools = await client.listTools();
+ * const result = await client.callTool({ name: 'my-tool', arguments: { foo: 'bar' } });
+ *
+ * // Change auth context
+ * setAuthInfo({ token: 'new-token', user: { sub: 'other-user' } });
+ *
+ * // Cleanup
+ * await close();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With LangChain MCP adapters
+ * import { createInMemoryServer } from '@frontmcp/sdk';
+ *
+ * const { clientTransport, setAuthInfo } = await createInMemoryServer(scope);
+ *
+ * // LangChain's MCP adapter can use the transport directly
+ * const client = new MultiServerMCPClient({
+ *   servers: [{
+ *     name: 'frontmcp',
+ *     transport: clientTransport,
+ *   }]
+ * });
+ * ```
+ */
+export declare function createInMemoryServer(scope: Scope, options?: CreateInMemoryServerOptions): Promise<InMemoryServerResult>;
+//# sourceMappingURL=in-memory-server.d.ts.map

package/transport/in-memory-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-server.d.ts","sourceRoot":"","sources":["../../src/transport/in-memory-server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gDAAgD,CAAC;AAC/E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGrD;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,iDAAiD;IACjD,QAAQ,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC7B,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,gDAAgD;IAChD,eAAe,EAAE,SAAS,CAAC;IAC3B,4CAA4C;IAC5C,WAAW,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC;IACnD,sCAAsC;IACtC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,oBAAoB,CAAC,CAqF/B"}

package/transport/index.d.ts

@@ -19,4 +19,51 @@ export { RecreateableStreamableHTTPServerTransport, StreamableHTTPServerTranspor
 export { RecreateableSSEServerTransport, RecreateableSSEServerTransportOptions } from './adapters/sse-transport';
 export { SSEServerTransport, SSEServerTransportOptions } from './legacy/legacy.sse.tranporter';
 export { SupportedTransport } from './adapters/transport.local.adapter';
+export type { TransportType, TransportKey } from './transport.types';
+export { createEventStore, MemoryEventStore, RedisEventStore } from './event-stores';
+export type { EventStoreConfig, EventStoreResult, MemoryEventStoreOptions, RedisEventStoreOptions, } from './event-stores';
+/**
+ * Creates an in-memory MCP server for programmatic access without HTTP transport.
+ *
+ * Use this for:
+ * - MCP SDK Client integration
+ * - LangChain MCP adapter integration
+ * - Unit/integration testing
+ * - Agent backends with custom invocation
+ *
+ * @example
+ * ```typescript
+ * import { createInMemoryServer } from '@frontmcp/sdk';
+ * import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+ *
+ * const { clientTransport, setAuthInfo, close } = await createInMemoryServer(scope, {
+ *   authInfo: { token: 'jwt-token' }
+ * });
+ *
+ * const client = new Client({ name: 'my-client', version: '1.0.0' });
+ * await client.connect(clientTransport);
+ *
+ * // Use MCP SDK Client methods
+ * const tools = await client.listTools();
+ *
+ * // Update auth context per-request
+ * setAuthInfo({ token: 'new-token' });
+ *
+ * // Cleanup when done
+ * await client.close();
+ * await close();
+ * ```
+ */
+export { createInMemoryServer } from './in-memory-server';
+/**
+ * Options for creating an in-memory MCP server.
+ * @see createInMemoryServer
+ */
+export type { CreateInMemoryServerOptions } from './in-memory-server';
+/**
+ * Result returned by createInMemoryServer.
+ * Contains the client transport, auth setter, and close function.
+ * @see createInMemoryServer
+ */
+export type { InMemoryServerResult } from './in-memory-server';
 //# sourceMappingURL=index.d.ts.map

package/transport/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transport/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EACL,yCAAyC,EACzC,oCAAoC,GACrC,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAAE,8BAA8B,EAAE,qCAAqC,EAAE,MAAM,0BAA0B,CAAC;AAGjH,OAAO,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAG/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transport/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EACL,yCAAyC,EACzC,oCAAoC,GACrC,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAAE,8BAA8B,EAAE,qCAAqC,EAAE,MAAM,0BAA0B,CAAC;AAGjH,OAAO,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAG/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAExE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGrE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACrF,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;;GAGG;AACH,YAAY,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE;;;;GAIG;AACH,YAAY,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC"}

package/transport/mcp-handlers/complete-request.handler.d.ts

@@ -1,85 +1,4 @@
-import { CompleteRequest } from '@modelcontextprotocol/sdk/types.js';
-import { McpHandlerOptions } from './mcp-handlers.types';
-export default function CompleteRequestHandler({ scope }: McpHandlerOptions): {
-    requestSchema: import("zod").ZodObject<{
-        method: import("zod").ZodLiteral<"completion/complete">;
-        params: import("zod").ZodObject<{
-            _meta: import("zod").ZodOptional<import("zod").ZodObject<{
-                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
-                "io.modelcontextprotocol/related-task": import("zod").ZodOptional<import("zod").ZodObject<{
-                    taskId: import("zod").ZodString;
-                }, import("zod/v4/core").$strip>>;
-            }, import("zod/v4/core").$loose>>;
-            ref: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"ref/prompt">;
-                name: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-                type: import("zod").ZodLiteral<"ref/resource">;
-                uri: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>]>;
-            argument: import("zod").ZodObject<{
-                name: import("zod").ZodString;
-                value: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>;
-            context: import("zod").ZodOptional<import("zod").ZodObject<{
-                arguments: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
-            }, import("zod/v4/core").$strip>>;
-        }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip>;
-    handler: (request: CompleteRequest, ctx: import("./mcp-handlers.types").McpRequestHandler<{
-        method: "completion/complete";
-        params: {
-            ref: {
-                type: "ref/prompt";
-                name: string;
-            } | {
-                type: "ref/resource";
-                uri: string;
-            };
-            argument: {
-                name: string;
-                value: string;
-            };
-            _meta?: {
-                [x: string]: unknown;
-                progressToken?: string | number | undefined;
-                "io.modelcontextprotocol/related-task"?: {
-                    taskId: string;
-                } | undefined;
-            } | undefined;
-            context?: {
-                arguments?: {
-                    [x: string]: string;
-                } | undefined;
-            } | undefined;
-        };
-    }, {
-        method: string;
-        params?: {
-            [x: string]: unknown;
-            _meta?: {
-                [x: string]: unknown;
-                progressToken?: string | number | undefined;
-                "io.modelcontextprotocol/related-task"?: {
-                    taskId: string;
-                } | undefined;
-            } | undefined;
-        } | undefined;
-    }>) => Promise<{
-        [x: string]: unknown;
-        completion: {
-            [x: string]: unknown;
-            values: string[];
-            total?: number | undefined;
-            hasMore?: boolean | undefined;
-        };
-        _meta?: {
-            [x: string]: unknown;
-            progressToken?: string | number | undefined;
-            "io.modelcontextprotocol/related-task"?: {
-                taskId: string;
-            } | undefined;
-        } | undefined;
-    }>;
-};
+import { CompleteRequest, CompleteResult } from '@modelcontextprotocol/sdk/types.js';
+import { McpHandler, McpHandlerOptions } from './mcp-handlers.types';
+export default function completeRequestHandler({ scope, }: McpHandlerOptions): McpHandler<CompleteRequest, CompleteResult>;
 //# sourceMappingURL=complete-request.handler.d.ts.map

package/transport/mcp-handlers/complete-request.handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complete-request.handler.d.ts","sourceRoot":"","sources":["../../../src/transport/mcp-handlers/complete-request.handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,eAAe,EAAkB,MAAM,oCAAoC,CAAC;AAC5G,OAAO,EAAc,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAErE,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAAC,EAAE,KAAK,EAAE,EAAE,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;uBAGpD,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAErC"}
+{"version":3,"file":"complete-request.handler.d.ts","sourceRoot":"","sources":["../../../src/transport/mcp-handlers/complete-request.handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,eAAe,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAC5G,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAErE,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAAC,EAC7C,KAAK,GACN,EAAE,iBAAiB,GAAG,UAAU,CAAC,eAAe,EAAE,cAAc,CAAC,CAiBjE"}

package/transport/mcp-handlers/get-prompt-request.handler.d.ts

@@ -1,129 +1,4 @@
-import { GetPromptRequest } from '@modelcontextprotocol/sdk/types.js';
-import { McpHandlerOptions } from './mcp-handlers.types';
-export default function GetPromptRequestHandler({ scope }: McpHandlerOptions): {
-    requestSchema: import("zod").ZodObject<{
-        method: import("zod").ZodLiteral<"prompts/get">;
-        params: import("zod").ZodObject<{
-            _meta: import("zod").ZodOptional<import("zod").ZodObject<{
-                progressToken: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
-                "io.modelcontextprotocol/related-task": import("zod").ZodOptional<import("zod").ZodObject<{
-                    taskId: import("zod").ZodString;
-                }, import("zod/v4/core").$strip>>;
-            }, import("zod/v4/core").$loose>>;
-            name: import("zod").ZodString;
-            arguments: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
-        }, import("zod/v4/core").$strip>;
-    }, import("zod/v4/core").$strip>;
-    handler: (request: GetPromptRequest, ctx: import("./mcp-handlers.types").McpRequestHandler<{
-        method: "prompts/get";
-        params: {
-            name: string;
-            _meta?: {
-                [x: string]: unknown;
-                progressToken?: string | number | undefined;
-                "io.modelcontextprotocol/related-task"?: {
-                    taskId: string;
-                } | undefined;
-            } | undefined;
-            arguments?: {
-                [x: string]: string;
-            } | undefined;
-        };
-    }, {
-        method: string;
-        params?: {
-            [x: string]: unknown;
-            _meta?: {
-                [x: string]: unknown;
-                progressToken?: string | number | undefined;
-                "io.modelcontextprotocol/related-task"?: {
-                    taskId: string;
-                } | undefined;
-            } | undefined;
-        } | undefined;
-    }>) => Promise<{
-        [x: string]: unknown;
-        messages: {
-            role: "user" | "assistant";
-            content: {
-                type: "text";
-                text: string;
-                annotations?: {
-                    audience?: ("user" | "assistant")[] | undefined;
-                    priority?: number | undefined;
-                    lastModified?: string | undefined;
-                } | undefined;
-                _meta?: Record<string, unknown> | undefined;
-            } | {
-                type: "image";
-                data: string;
-                mimeType: string;
-                annotations?: {
-                    audience?: ("user" | "assistant")[] | undefined;
-                    priority?: number | undefined;
-                    lastModified?: string | undefined;
-                } | undefined;
-                _meta?: Record<string, unknown> | undefined;
-            } | {
-                type: "audio";
-                data: string;
-                mimeType: string;
-                annotations?: {
-                    audience?: ("user" | "assistant")[] | undefined;
-                    priority?: number | undefined;
-                    lastModified?: string | undefined;
-                } | undefined;
-                _meta?: Record<string, unknown> | undefined;
-            } | {
-                uri: string;
-                name: string;
-                type: "resource_link";
-                description?: string | undefined;
-                mimeType?: string | undefined;
-                annotations?: {
-                    audience?: ("user" | "assistant")[] | undefined;
-                    priority?: number | undefined;
-                    lastModified?: string | undefined;
-                } | undefined;
-                _meta?: {
-                    [x: string]: unknown;
-                } | undefined;
-                icons?: {
-                    src: string;
-                    mimeType?: string | undefined;
-                    sizes?: string[] | undefined;
-                    theme?: "light" | "dark" | undefined;
-                }[] | undefined;
-                title?: string | undefined;
-            } | {
-                type: "resource";
-                resource: {
-                    uri: string;
-                    text: string;
-                    mimeType?: string | undefined;
-                    _meta?: Record<string, unknown> | undefined;
-                } | {
-                    uri: string;
-                    blob: string;
-                    mimeType?: string | undefined;
-                    _meta?: Record<string, unknown> | undefined;
-                };
-                annotations?: {
-                    audience?: ("user" | "assistant")[] | undefined;
-                    priority?: number | undefined;
-                    lastModified?: string | undefined;
-                } | undefined;
-                _meta?: Record<string, unknown> | undefined;
-            };
-        }[];
-        _meta?: {
-            [x: string]: unknown;
-            progressToken?: string | number | undefined;
-            "io.modelcontextprotocol/related-task"?: {
-                taskId: string;
-            } | undefined;
-        } | undefined;
-        description?: string | undefined;
-    }>;
-};
+import { GetPromptRequest, GetPromptResult } from '@modelcontextprotocol/sdk/types.js';
+import { McpHandler, McpHandlerOptions } from './mcp-handlers.types';
+export default function getPromptRequestHandler({ scope, }: McpHandlerOptions): McpHandler<GetPromptRequest, GetPromptResult>;
 //# sourceMappingURL=get-prompt-request.handler.d.ts.map

package/transport/mcp-handlers/get-prompt-request.handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-prompt-request.handler.d.ts","sourceRoot":"","sources":["../../../src/transport/mcp-handlers/get-prompt-request.handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,gBAAgB,EAAmB,MAAM,oCAAoC,CAAC;AAC/G,OAAO,EAAc,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAErE,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,EAAE,KAAK,EAAE,EAAE,iBAAiB;;;;;;;;;;;;;;uBAGrD,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEtC"}
+{"version":3,"file":"get-prompt-request.handler.d.ts","sourceRoot":"","sources":["../../../src/transport/mcp-handlers/get-prompt-request.handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,gBAAgB,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC/G,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAErE,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,EAC9C,KAAK,GACN,EAAE,iBAAiB,GAAG,UAAU,CAAC,gBAAgB,EAAE,eAAe,CAAC,CAmBnE"}