@frontmcp/sdk 0.7.2 → 0.8.1

package/common/types/options/redis.options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"redis.options.d.ts","sourceRoot":"","sources":["../../../../src/common/types/options/redis.options.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;EAAiC,CAAC;AACpE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAyDpE;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;iBASH,CAAC;AAE9B,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAMvE;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;iBAmBN,CAAC;AAE9B,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAmB7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA4E,CAAC;AAE5G;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAMnE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAoD,CAAC;AAErF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAMrE;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,IAAI,oBAAoB,CAEtF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,IAAI,uBAAuB,CAE5F;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,IAAI,oBAAoB,CAE1F"}

package/common/types/options/server-info.options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server-info.options.d.ts","sourceRoot":"","sources":["../../../../src/common/types/options/server-info.options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAc,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,MAAM,iBAAiB,GAAG;IAE9B,IAAI,EAAE,MAAM,CAAC;IAEb,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,OAAO,EAAE,MAAM,CAAC;IAEhB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;CAChB,CAAA;AAGD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;iBAMO,CAAC"}

package/common/types/options/session.options.d.ts

@@ -1,148 +0,0 @@
-import { z } from 'zod';
-import { AIPlatformType } from '../auth/session.types';
-export type SessionMode = 'stateful' | 'stateless';
-export type TransportIdMode = 'uuid' | 'jwt';
-/**
- * A single platform mapping entry for custom client-to-platform detection.
- */
-export interface PlatformMappingEntry {
-    /** Pattern to match against clientInfo.name (string for exact match, RegExp for pattern) */
-    pattern: string | RegExp;
-    /** The platform type to assign when pattern matches */
-    platform: AIPlatformType;
-}
-/**
- * Configuration for platform detection from MCP client info.
- */
-export interface PlatformDetectionConfig {
-    /**
-     * Custom mappings to check before default detection.
-     * Mappings are evaluated in order; first match wins.
-     */
-    mappings?: PlatformMappingEntry[];
-    /**
-     * If true, skip default detection when no custom mapping matches.
-     * The platform will be 'unknown' instead of attempting keyword-based detection.
-     * @default false
-     */
-    customOnly?: boolean;
-}
-export type SessionOptions = {
-    /**
-     * Defines how the session lifecycle and nested tokens are managed.
-     *
-     * Modes:
-     * - `'stateful'`: Session and nested tokens are stored in a server-side store (e.g., Redis).
-     * - `'stateless'`: All session data (including nested tokens) is embedded within a signed/encrypted JWT.
-     *
-     * **Behavior:**
-     * - When using `'stateful'`:
-     *   - Nested OAuth tokens are **never exposed** in the JWT.
-     *   - Tokens are encrypted and persisted in Redis under a session key.
-     *   - The client receives only a lightweight reference (session key) instead of full credentials.
-     *   - Results in smaller JWT payloads and reduces token leakage risk.
-     *   - Allows seamless refresh of nested provider tokens without requiring user re-authorization.
-     *   - Recommended for multi-application environments or setups using short-lived OAuth tokens.
-     *
-     * - When using `'stateless'`:
-     *   - Stores all nested tokens directly within the JWT, enabling fully client-managed sessions.
-     *   - Does **not support token refresh** — once a nested provider token expires, re-authorization is required.
-     *   - Simplifies implementation but may degrade UX when tokens are short-lived.
-     *   - Best suited for lightweight or single-application environments where token rotation is less critical.
-     *
-     * @default 'stateful'
-     */
-    sessionMode?: SessionMode | ((issuer: string) => Promise<SessionMode> | SessionMode);
-    /**
-     * Defines how the Transport ID is generated, verified, and used across sessions.
-     *
-     * Modes:
-     * - `'uuid'`: Generates a random UUID per session.
-     * - `'jwt'`: Uses a signed JWT for stateless sessions, signed with a generated session key.
-     *
-     * **Behavior: **
-     * - When using `'jwt'`:
-     *   - Requires an active Redis connection to support distributed, stateless transport sessions.
-     *   - Each token is verified using a generated public key associated with the existing session.
-     *   - Enables access to a streamable HTTP transport session ID.
-     *   - For distributed systems, verification is optimized by checking if the session is already
-     *     verified by an existing live transport ID. This allows fast validation when multiple
-     *     transports are connected to a shared queue (high-availability setup).
-     *   - If the JWT's transport ID is not found on the current worker node, the system attempts
-     *     to connect to the corresponding remote transport in the distributed infrastructure.
-     *
-     * - When using `'uuid'`:
-     *   - Provides a strict, node-bound session transport (single-node mode).
-     *   - Each request verifies the `Authorization` header and searches for a matching transport ID
-     *     derived from the hashed authorization header and the generated transport UUID.
-     *   - If no matching transport ID is found, an error (`TransportNotInitialized`) is thrown.
-     *
-     * @default 'uuid'
-     */
-    transportIdMode?: TransportIdMode | ((issuer: string) => Promise<TransportIdMode> | TransportIdMode);
-    /**
-     * Configuration for detecting the AI platform from MCP client info.
-     * Allows custom mappings to override or supplement the default keyword-based detection.
-     */
-    platformDetection?: PlatformDetectionConfig;
-};
-/**
- * Zod schema for platform mapping entry.
- * Note: RegExp cannot be validated by zod, so we use passthrough for pattern.
- */
-export declare const platformMappingEntrySchema: z.ZodObject<{
-    pattern: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>]>;
-    platform: z.ZodEnum<{
-        unknown: "unknown";
-        continue: "continue";
-        openai: "openai";
-        claude: "claude";
-        gemini: "gemini";
-        cursor: "cursor";
-        cody: "cody";
-        "generic-mcp": "generic-mcp";
-        "ext-apps": "ext-apps";
-    }>;
-}, z.core.$strip>;
-/**
- * Zod schema for platform detection configuration.
- */
-export declare const platformDetectionConfigSchema: z.ZodObject<{
-    mappings: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        pattern: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>]>;
-        platform: z.ZodEnum<{
-            unknown: "unknown";
-            continue: "continue";
-            openai: "openai";
-            claude: "claude";
-            gemini: "gemini";
-            cursor: "cursor";
-            cody: "cody";
-            "generic-mcp": "generic-mcp";
-            "ext-apps": "ext-apps";
-        }>;
-    }, z.core.$strip>>>;
-    customOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, z.core.$strip>;
-export declare const sessionOptionsSchema: z.ZodObject<{
-    sessionMode: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"stateful">, z.ZodLiteral<"stateless">, z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>]>>>;
-    transportIdMode: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"uuid">, z.ZodLiteral<"jwt">, z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>]>>>;
-    platformDetection: z.ZodOptional<z.ZodObject<{
-        mappings: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            pattern: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>]>;
-            platform: z.ZodEnum<{
-                unknown: "unknown";
-                continue: "continue";
-                openai: "openai";
-                claude: "claude";
-                gemini: "gemini";
-                cursor: "cursor";
-                cody: "cody";
-                "generic-mcp": "generic-mcp";
-                "ext-apps": "ext-apps";
-            }>;
-        }, z.core.$strip>>>;
-        customOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-//# sourceMappingURL=session.options.d.ts.map

package/common/types/options/session.options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session.options.d.ts","sourceRoot":"","sources":["../../../../src/common/types/options/session.options.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,cAAc,EAAwB,MAAM,uBAAuB,CAAC;AAE7E,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,WAAW,CAAC;AACnD,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,KAAK,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,4FAA4F;IAC5F,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,uDAAuD;IACvD,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,oBAAoB,EAAE,CAAC;IAClC;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,WAAW,CAAC,EAAE,WAAW,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC,CAAC;IACrF;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,eAAe,CAAC,EAAE,eAAe,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,CAAC,CAAC;IAErG;;;OAGG;IACH,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;CAC7C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;iBAGrC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;iBAGxC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;iBAUO,CAAC"}

package/common/types/options/transport.options.d.ts

@@ -1,178 +0,0 @@
-import { z } from 'zod';
-import { SessionMode, TransportIdMode, PlatformMappingEntry, PlatformDetectionConfig, platformDetectionConfigSchema } from './session.options';
-export type { SessionMode, TransportIdMode, PlatformMappingEntry, PlatformDetectionConfig };
-/**
- * Transport persistence configuration
- * Enables session persistence to Redis/Vercel KV and automatic transport recreation after server restart.
- *
- * **Auto-enable behavior**: When top-level `redis` is configured at the `@FrontMcp` level,
- * transport persistence is automatically enabled using that configuration.
- * - To disable: explicitly set `enabled: false`
- * - To use different redis config: explicitly set `redis: {...}`
- */
-export declare const transportPersistenceConfigSchema: z.ZodObject<{
-    enabled: z.ZodDefault<z.ZodBoolean>;
-    redis: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-        provider: z.ZodLiteral<"redis">;
-        host: z.ZodString;
-        port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        password: z.ZodOptional<z.ZodString>;
-        db: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        tls: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        keyPrefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-        defaultTtlMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    }, z.core.$strip>, z.ZodObject<{
-        provider: z.ZodLiteral<"vercel-kv">;
-        url: z.ZodOptional<z.ZodString>;
-        token: z.ZodOptional<z.ZodString>;
-        keyPrefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-        defaultTtlMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
-        host: z.ZodString;
-        port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        password: z.ZodOptional<z.ZodString>;
-        db: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        tls: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-        keyPrefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-        defaultTtlMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    }, z.core.$strip>, z.ZodTransform<{
-        provider: "redis";
-        host: string;
-        port: number;
-        db: number;
-        tls: boolean;
-        keyPrefix: string;
-        defaultTtlMs: number;
-        password?: string | undefined;
-    }, {
-        host: string;
-        port: number;
-        db: number;
-        tls: boolean;
-        keyPrefix: string;
-        defaultTtlMs: number;
-        password?: string | undefined;
-    }>>]>>;
-    defaultTtlMs: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
-/**
- * Transport options schema
- * Consolidates transport protocol config + session lifecycle config
- */
-export declare const transportOptionsSchema: z.ZodObject<{
-    sessionMode: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"stateful">, z.ZodLiteral<"stateless">, z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>]>>>;
-    transportIdMode: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"uuid">, z.ZodLiteral<"jwt">, z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>]>>>;
-    platformDetection: z.ZodOptional<z.ZodObject<{
-        mappings: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            pattern: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>]>;
-            platform: z.ZodEnum<{
-                unknown: "unknown";
-                continue: "continue";
-                openai: "openai";
-                claude: "claude";
-                gemini: "gemini";
-                cursor: "cursor";
-                cody: "cody";
-                "generic-mcp": "generic-mcp";
-                "ext-apps": "ext-apps";
-            }>;
-        }, z.core.$strip>>>;
-        customOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    }, z.core.$strip>>;
-    enableLegacySSE: z.ZodDefault<z.ZodBoolean>;
-    enableSseListener: z.ZodDefault<z.ZodBoolean>;
-    enableStreamableHttp: z.ZodDefault<z.ZodBoolean>;
-    enableStatelessHttp: z.ZodDefault<z.ZodBoolean>;
-    enableStatefulHttp: z.ZodDefault<z.ZodBoolean>;
-    requireSessionForStreamable: z.ZodDefault<z.ZodBoolean>;
-    persistence: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodDefault<z.ZodBoolean>;
-        redis: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-            provider: z.ZodLiteral<"redis">;
-            host: z.ZodString;
-            port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-            password: z.ZodOptional<z.ZodString>;
-            db: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-            tls: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-            keyPrefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-            defaultTtlMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        }, z.core.$strip>, z.ZodObject<{
-            provider: z.ZodLiteral<"vercel-kv">;
-            url: z.ZodOptional<z.ZodString>;
-            token: z.ZodOptional<z.ZodString>;
-            keyPrefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-            defaultTtlMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        }, z.core.$strip>, z.ZodPipe<z.ZodObject<{
-            host: z.ZodString;
-            port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-            password: z.ZodOptional<z.ZodString>;
-            db: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-            tls: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-            keyPrefix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-            defaultTtlMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        }, z.core.$strip>, z.ZodTransform<{
-            provider: "redis";
-            host: string;
-            port: number;
-            db: number;
-            tls: boolean;
-            keyPrefix: string;
-            defaultTtlMs: number;
-            password?: string | undefined;
-        }, {
-            host: string;
-            port: number;
-            db: number;
-            tls: boolean;
-            keyPrefix: string;
-            defaultTtlMs: number;
-            password?: string | undefined;
-        }>>]>>;
-        defaultTtlMs: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>>;
-    distributed: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
-        providerCaching: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-/**
- * Transport options type (with defaults applied)
- */
-export type TransportOptions = z.infer<typeof transportOptionsSchema>;
-/**
- * Transport options input type (for user configuration)
- */
-export type TransportOptionsInput = z.input<typeof transportOptionsSchema>;
-/**
- * Transport persistence configuration type
- */
-export type TransportPersistenceConfig = z.infer<typeof transportPersistenceConfigSchema>;
-/**
- * Transport persistence configuration input type
- */
-export type TransportPersistenceConfigInput = z.input<typeof transportPersistenceConfigSchema>;
-/**
- * Platform detection configuration type
- */
-export type PlatformDetectionConfigType = z.infer<typeof platformDetectionConfigSchema>;
-/**
- * Distributed mode configuration type (with defaults applied)
- */
-export type DistributedConfig = NonNullable<TransportOptions['distributed']>;
-/**
- * Distributed mode configuration input type (for user configuration)
- */
-export type DistributedConfigInput = {
-    enabled?: boolean | 'auto';
-    providerCaching?: boolean;
-};
-/**
- * Check if distributed mode is enabled based on configuration.
- * Handles 'auto' detection for serverless environments.
- */
-export declare function isDistributedMode(config?: DistributedConfigInput): boolean;
-/**
- * Get effective provider caching setting based on distributed config.
- */
-export declare function shouldCacheProviders(config?: DistributedConfigInput): boolean;
-//# sourceMappingURL=transport.options.d.ts.map

package/common/types/options/transport.options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transport.options.d.ts","sourceRoot":"","sources":["../../../../src/common/types/options/transport.options.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,WAAW,EACX,eAAe,EACf,oBAAoB,EACpB,uBAAuB,EAEvB,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAG3B,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,CAAC;AAM5F;;;;;;;;GAQG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyB3C,CAAC;AAMH;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiJjC,CAAC;AAMH;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE/F;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAExF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAyB1E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAU7E"}

package/context/request-context-storage.d.ts

@@ -1,90 +0,0 @@
-/**
- * RequestContextStorage - AsyncLocalStorage wrapper for request-scoped context
- *
- * Provides concurrent-safe request context propagation using Node.js AsyncLocalStorage.
- * Access through DI only - never use static imports to access the storage directly.
- *
- * @example
- * ```typescript
- * // In a flow or middleware
- * const storage = this.get(RequestContextStorage);
- * await storage.runFromHeaders(request.headers, {
- *   sessionId: sessionId,
- *   authInfo: authInfo,
- *   scopeId: scope.id,
- * }, async () => {
- *   // All code here can access the context via DI
- *   const ctx = this.get(REQUEST_CONTEXT);
- * });
- * ```
- */
-import { RequestContext, RequestContextArgs } from './request-context';
-/**
- * RequestContextStorage provides request-scoped context via AsyncLocalStorage.
- *
- * This is a GLOBAL-scoped provider because it manages the storage itself,
- * not the per-request data. The actual RequestContext is accessed via
- * the REQUEST_CONTEXT token which is REQUEST-scoped.
- */
-export declare class RequestContextStorage {
-    /**
-     * Run a callback with a new RequestContext.
-     *
-     * @param args - Arguments to create the context
-     * @param fn - Async function to run with the context
-     * @returns Result of the callback
-     */
-    run<T>(args: RequestContextArgs, fn: () => T | Promise<T>): T | Promise<T>;
-    /**
-     * Run with context extracted from HTTP headers.
-     *
-     * Automatically parses trace context from headers using W3C Trace Context
-     * specification with fallback to x-frontmcp-trace-id.
-     *
-     * @param headers - HTTP headers
-     * @param args - Additional context args (sessionId, authInfo, scopeId)
-     * @param fn - Async function to run
-     * @returns Result of the callback
-     */
-    runFromHeaders<T>(headers: Record<string, unknown>, args: Omit<RequestContextArgs, 'traceContext' | 'metadata'>, fn: () => T | Promise<T>): T | Promise<T>;
-    /**
-     * Run with an existing RequestContext.
-     *
-     * Useful when you need to propagate an existing context to a new async scope.
-     *
-     * @param context - Existing RequestContext
-     * @param fn - Async function to run
-     * @returns Result of the callback
-     */
-    runWithContext<T>(context: RequestContext, fn: () => T | Promise<T>): T | Promise<T>;
-    /**
-     * Get the current RequestContext.
-     *
-     * @returns Current context or undefined if not in a request scope
-     */
-    getStore(): RequestContext | undefined;
-    /**
-     * Get the current RequestContext, throwing if not available.
-     *
-     * @throws Error if not in a request scope
-     */
-    getStoreOrThrow(): RequestContext;
-    /**
-     * Check if currently running within a request context.
-     *
-     * @returns True if a RequestContext is available
-     */
-    hasContext(): boolean;
-    /**
-     * Update the authInfo in the current context.
-     *
-     * This mutates the existing context in place to preserve internal state
-     * (marks, store, sessionMetadata) while updating auth info.
-     *
-     * @param authInfo - Auth info fields to set/update (merged with existing)
-     * @param fn - Function to run after update
-     * @returns Result of the callback
-     */
-    updateAuthInfo<T>(authInfo: RequestContextArgs['authInfo'], fn: () => T | Promise<T>): T | Promise<T>;
-}
-//# sourceMappingURL=request-context-storage.d.ts.map

package/context/request-context-storage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"request-context-storage.d.ts","sourceRoot":"","sources":["../../src/context/request-context-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAKH,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAmB,MAAM,mBAAmB,CAAC;AAWxF;;;;;;GAMG;AACH,qBAKa,qBAAqB;IAChC;;;;;;OAMG;IACH,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAK1E;;;;;;;;;;OAUG;IACH,cAAc,CAAC,CAAC,EACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,IAAI,EAAE,IAAI,CAAC,kBAAkB,EAAE,cAAc,GAAG,UAAU,CAAC,EAC3D,EAAE,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GACvB,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAWjB;;;;;;;;OAQG;IACH,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAIpF;;;;OAIG;IACH,QAAQ,IAAI,cAAc,GAAG,SAAS;IAItC;;;;OAIG;IACH,eAAe,IAAI,cAAc;IAQjC;;;;OAIG;IACH,UAAU,IAAI,OAAO;IAIrB;;;;;;;;;OASG;IACH,cAAc,CAAC,CAAC,EAAE,QAAQ,EAAE,kBAAkB,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAMtG"}

package/context/request-context.d.ts

@@ -1,185 +0,0 @@
-/**
- * RequestContext - Production-ready request context for FrontMCP
- *
- * Provides request-scoped state that flows through the entire async execution
- * chain via AsyncLocalStorage. Access via DI only using the REQUEST_CONTEXT token.
- */
-import { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
-import { FrontMcpLogger } from '../common/interfaces/logger.interface';
-import { TraceContext } from './trace-context';
-import type { SessionIdPayload } from '../common/types';
-/**
- * Request metadata extracted from HTTP headers.
- */
-export interface RequestMetadata {
-    /** User-Agent header */
-    userAgent?: string;
-    /** Content-Type header */
-    contentType?: string;
-    /** Accept header */
-    accept?: string;
-    /** Client IP address (from x-forwarded-for or socket) */
-    clientIp?: string;
-    /** Custom headers matching x-frontmcp-* pattern */
-    customHeaders: Record<string, string>;
-}
-/**
- * Arguments for creating a RequestContext.
- */
-export interface RequestContextArgs {
-    /** Optional request ID (generated if not provided) */
-    requestId?: string;
-    /** Optional trace context (generated if not provided) */
-    traceContext?: TraceContext;
-    /** Session identifier (required) */
-    sessionId: string;
-    /** Authentication information (can be partial, progressively populated) */
-    authInfo: Partial<AuthInfo>;
-    /** Scope identifier (required) */
-    scopeId: string;
-    /** Optional timestamp (defaults to Date.now()) */
-    timestamp?: number;
-    /** Optional request metadata */
-    metadata?: RequestMetadata;
-}
-/**
- * RequestContext provides per-request state that flows through
- * the entire async execution chain via AsyncLocalStorage.
- *
- * Access via DI only using the REQUEST_CONTEXT token:
- * ```typescript
- * const ctx = this.get(REQUEST_CONTEXT);
- * console.log(ctx.requestId, ctx.traceContext.traceId);
- * ```
- */
-export declare class RequestContext {
-    /** Unique request identifier (UUID v4) */
-    readonly requestId: string;
-    /** W3C Trace Context or generated trace ID */
-    readonly traceContext: TraceContext;
-    /** Session identifier (from mcp-session-id header or authorization) */
-    readonly sessionId: string;
-    /**
-     * Authentication information.
-     * Note: This is mutable to allow updating after authorization is verified.
-     * It's Partial<AuthInfo> because auth info is progressively populated
-     * throughout the request lifecycle (some fields like transport are only
-     * available after the transport is established).
-     */
-    private _authInfo;
-    /** Scope identifier */
-    readonly scopeId: string;
-    /** Request start timestamp */
-    readonly timestamp: number;
-    /** Request metadata (headers, user-agent, etc.) */
-    readonly metadata: RequestMetadata;
-    /** Timing marks for performance tracking */
-    private readonly marks;
-    /** Request-scoped data store */
-    private readonly store;
-    constructor(args: RequestContextArgs);
-    /**
-     * Get authentication information.
-     * Returns Partial<AuthInfo> because auth info is progressively populated.
-     */
-    get authInfo(): Partial<AuthInfo>;
-    /**
-     * Update auth info after authorization is verified.
-     * Called by checkAuthorization stage after session verification.
-     * Can be called multiple times to progressively add fields.
-     *
-     * @param authInfo - The auth info fields to set/update
-     * @internal
-     */
-    updateAuthInfo(authInfo: Partial<AuthInfo>): void;
-    /**
-     * Session metadata including protocol, platform type, and node info.
-     * Only available after session verification in authenticated flows.
-     */
-    private _sessionMetadata?;
-    /**
-     * Get session metadata.
-     *
-     * Contains protocol type, platform type, nodeId, and authSignature.
-     * Only available after session verification completes.
-     *
-     * @returns Session metadata or undefined if not yet verified
-     */
-    get sessionMetadata(): SessionIdPayload | undefined;
-    /**
-     * Update session metadata after session verification.
-     * Called by checkAuthorization stage after session verification.
-     *
-     * @param metadata - Session metadata from verified session
-     * @internal
-     */
-    updateSessionMetadata(metadata: SessionIdPayload): void;
-    /**
-     * Get a child logger with request context attached.
-     *
-     * Creates a child logger with a prefix containing the request ID and trace ID
-     * for easy request tracing in logs.
-     *
-     * @param parentLogger - The parent logger to create a child from
-     * @returns A logger with requestId and traceId in the prefix
-     */
-    getLogger(parentLogger: FrontMcpLogger): FrontMcpLogger;
-    /**
-     * Mark a timing point for performance tracking.
-     *
-     * @param name - Name of the timing mark
-     */
-    mark(name: string): void;
-    /**
-     * Get elapsed time in milliseconds between two marks.
-     *
-     * @param from - Start mark name (defaults to 'init')
-     * @param to - End mark name (defaults to current time)
-     * @returns Elapsed time in milliseconds
-     */
-    elapsed(from?: string, to?: string): number;
-    /**
-     * Get all timing marks.
-     *
-     * @returns Read-only map of mark names to timestamps
-     */
-    getMarks(): ReadonlyMap<string, number>;
-    /**
-     * Store request-scoped data.
-     *
-     * @param key - Storage key
-     * @param value - Value to store
-     */
-    set<T>(key: string | symbol, value: T): void;
-    /**
-     * Retrieve request-scoped data.
-     *
-     * @param key - Storage key
-     * @returns Stored value or undefined
-     */
-    get<T>(key: string | symbol): T | undefined;
-    /**
-     * Check if a key exists in the request-scoped store.
-     *
-     * @param key - Storage key
-     * @returns True if key exists
-     */
-    has(key: string | symbol): boolean;
-    /**
-     * Delete a key from the request-scoped store.
-     *
-     * @param key - Storage key
-     * @returns True if key was deleted
-     */
-    delete(key: string | symbol): boolean;
-    /**
-     * Get a summary of the context for logging.
-     *
-     * Note: sessionId is hashed to prevent accidental exposure of user-identifying
-     * session identifiers in logs while still allowing correlation.
-     *
-     * @returns Object with key context fields
-     */
-    toLogContext(): Record<string, unknown>;
-}
-//# sourceMappingURL=request-context.d.ts.map

package/context/request-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../../src/context/request-context.ts"],"names":[],"mappings":"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"}

package/context/request-context.provider.d.ts

@@ -1,38 +0,0 @@
-/**
- * REQUEST_CONTEXT Provider
- *
- * Defines the DI token and factory provider for accessing RequestContext.
- * The context is retrieved from AsyncLocalStorage via RequestContextStorage.
- */
-import { ProviderFactoryType } from '../common/interfaces/provider.interface';
-import { RequestContext } from './request-context';
-import { RequestContextStorage } from './request-context-storage';
-/**
- * DI token for accessing the current RequestContext.
- *
- * Use this token to inject the current request context in any provider or context:
- *
- * @example
- * ```typescript
- * // In a tool/resource/prompt
- * const ctx = this.get(REQUEST_CONTEXT);
- * console.log(ctx.requestId, ctx.traceContext.traceId);
- *
- * // In a provider with constructor injection
- * constructor(
- *   @Inject(REQUEST_CONTEXT) private ctx: RequestContext
- * ) {}
- * ```
- */
-export declare const REQUEST_CONTEXT: unique symbol;
-/**
- * Factory provider for RequestContext.
- *
- * This provider is marked as REQUEST scope and retrieves the current
- * RequestContext from AsyncLocalStorage via RequestContextStorage.
- *
- * Note: This provider will throw if called outside of a request scope
- * (i.e., without first calling RequestContextStorage.run or runFromHeaders).
- */
-export declare const RequestContextProvider: ProviderFactoryType<RequestContext, readonly [typeof RequestContextStorage]>;
-//# sourceMappingURL=request-context.provider.d.ts.map