@frontmcp/sdk 0.7.2 → 0.8.0

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

@@ -0,0 +1,354 @@
+import type { RedisOptionsInput } from '../redis';
+import type { SessionMode, PlatformMappingEntry, PlatformDetectionConfig } from '../session';
+export type { SessionMode, PlatformMappingEntry, PlatformDetectionConfig };
+/**
+ * Session mode option - can be a literal or a function for dynamic selection.
+ *
+ * When a function is provided, it receives the issuer string and can return
+ * the mode synchronously or asynchronously.
+ *
+ * @example Static mode
+ * ```typescript
+ * sessionMode: 'stateful'
+ * ```
+ *
+ * @example Dynamic mode based on issuer
+ * ```typescript
+ * sessionMode: (issuer) => issuer.includes('google') ? 'stateless' : 'stateful'
+ * ```
+ */
+export type SessionModeOption = SessionMode | ((issuer: string) => Promise<SessionMode> | SessionMode);
+/**
+ * Protocol preset names for simplified configuration.
+ *
+ * Presets provide sensible defaults for common deployment scenarios:
+ *
+ * - `'legacy'` (default): Modern + legacy SSE support.
+ *   Best for backwards compatibility with older clients.
+ *
+ * - `'modern'`: SSE + streamable HTTP with strict sessions.
+ *   Best for production deployments with session management.
+ *
+ * - `'stateless-api'`: No sessions, pure request/response.
+ *   Best for public APIs and serverless functions.
+ *
+ * - `'full'`: All protocols enabled, maximum compatibility.
+ *   Best when supporting diverse client types.
+ */
+export type ProtocolPreset = 'modern' | 'legacy' | 'stateless-api' | 'full';
+/**
+ * Granular protocol configuration.
+ *
+ * Use this instead of presets when you need fine-grained control
+ * over which transport protocols are enabled.
+ *
+ * @example Enable JSON responses for testing
+ * ```typescript
+ * protocol: {
+ *   sse: true,
+ *   streamable: true,
+ *   json: true,  // Enable JSON-only responses
+ *   strictSession: true,
+ * }
+ * ```
+ */
+export interface ProtocolConfig {
+    /**
+     * Enable SSE listener for server-initiated messages.
+     * Handles GET requests with `Accept: text/event-stream` header.
+     * @default true
+     */
+    sse?: boolean;
+    /**
+     * Enable streamable HTTP transport (POST with SSE response).
+     * This is the recommended transport for production use.
+     * @default true
+     */
+    streamable?: boolean;
+    /**
+     * Enable JSON-only responses (stateful HTTP).
+     * Useful for development and debugging.
+     * @default false
+     */
+    json?: boolean;
+    /**
+     * Enable stateless HTTP mode (requests without session ID).
+     * When enabled, allows requests without prior initialize.
+     * @default false
+     */
+    stateless?: boolean;
+    /**
+     * Enable legacy SSE transport (old HTTP+SSE protocol).
+     * Enable for backwards compatibility with older clients.
+     * @default false
+     */
+    legacy?: boolean;
+    /**
+     * Require session ID for streamable HTTP (non-stateless mode).
+     * When false, streamable HTTP requests don't require prior initialize.
+     * @default true
+     */
+    strictSession?: boolean;
+}
+/**
+ * Transport persistence configuration.
+ *
+ * Enables session persistence to Redis/Vercel KV for transport recreation
+ * after server restart. This is essential for serverless deployments.
+ *
+ * **Auto-enable behavior**: When top-level `redis` is configured at the
+ * `@FrontMcp` level, transport persistence is automatically enabled.
+ * Set `persistence: false` to explicitly disable.
+ *
+ * @example Use global redis (auto-configured)
+ * ```typescript
+ * // At @FrontMcp level:
+ * redis: { host: 'localhost' },
+ * // persistence auto-enabled using global redis
+ * ```
+ *
+ * @example Override with custom config
+ * ```typescript
+ * transport: {
+ *   persistence: {
+ *     redis: { host: 'different-host' },
+ *     defaultTtlMs: 7200000,  // 2 hours
+ *   },
+ * }
+ * ```
+ *
+ * @example Explicitly disable
+ * ```typescript
+ * transport: {
+ *   persistence: false,
+ * }
+ * ```
+ */
+export interface PersistenceConfig {
+    /**
+     * Redis/Vercel KV configuration for session storage.
+     *
+     * If omitted, uses the top-level `redis` configuration from `@FrontMcp`.
+     */
+    redis?: RedisOptionsInput;
+    /**
+     * Default TTL for stored session metadata (milliseconds).
+     * @default 3600000 (1 hour)
+     */
+    defaultTtlMs?: number;
+}
+/**
+ * Distributed mode enabled setting.
+ *
+ * - `true`: Always enable distributed optimizations
+ * - `false`: Disable (default for traditional deployments)
+ * - `'auto'`: Auto-detect serverless environment
+ *
+ * Auto-detection checks for environment variables:
+ * - `VERCEL`
+ * - `NETLIFY`
+ * - `CF_PAGES` (Cloudflare Pages)
+ * - `AWS_LAMBDA_FUNCTION_NAME`
+ * - `AZURE_FUNCTIONS_ENVIRONMENT`
+ * - `K_SERVICE` (Google Cloud Run)
+ * - `RAILWAY_ENVIRONMENT`
+ * - `RENDER`
+ * - `FLY_APP_NAME`
+ */
+export type DistributedEnabled = boolean | 'auto';
+/**
+ * EventStore configuration for SSE resumability support.
+ *
+ * When enabled, clients can reconnect and resume missed SSE messages
+ * using the Last-Event-ID header per the MCP protocol.
+ *
+ * Note: By default, EventStore is disabled because Claude.ai's client
+ * doesn't handle the priming events correctly. Only enable if your
+ * clients support SSE resumability.
+ *
+ * @example Memory (single-node)
+ * ```typescript
+ * eventStore: {
+ *   enabled: true,
+ *   provider: 'memory',
+ *   maxEvents: 10000,
+ *   ttlMs: 300000,
+ * }
+ * ```
+ *
+ * @example Redis (distributed)
+ * ```typescript
+ * eventStore: {
+ *   enabled: true,
+ *   provider: 'redis',
+ *   redis: { host: 'localhost', port: 6379 },
+ * }
+ * ```
+ */
+export interface EventStoreConfig {
+    /**
+     * Whether EventStore is enabled.
+     * When true, clients can reconnect and resume missed SSE messages.
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * Storage provider type.
+     * - 'memory': In-memory storage (single-node only)
+     * - 'redis': Redis-backed storage (distributed)
+     * @default 'memory'
+     */
+    provider?: 'memory' | 'redis';
+    /**
+     * Maximum number of events to store before eviction.
+     * @default 10000
+     */
+    maxEvents?: number;
+    /**
+     * TTL in milliseconds for stored events.
+     * @default 300000 (5 minutes)
+     */
+    ttlMs?: number;
+    /**
+     * Redis configuration (required if provider is 'redis').
+     */
+    redis?: RedisOptionsInput;
+}
+/**
+ * Transport and session lifecycle configuration for FrontMCP.
+ *
+ * This interface provides the canonical configuration surface for all
+ * transport-related settings, consolidating protocol config, session
+ * lifecycle, persistence, and distributed mode.
+ *
+ * @example Basic configuration (uses defaults)
+ * ```typescript
+ * transport: {}  // Uses 'modern' preset
+ * ```
+ *
+ * @example Legacy setup (backwards compatible)
+ * ```typescript
+ * transport: {
+ *   protocol: 'legacy',
+ * }
+ * ```
+ *
+ * @example Production with persistence
+ * ```typescript
+ * redis: { host: 'redis.example.com' },
+ * transport: {
+ *   protocol: 'modern',
+ *   // persistence auto-enabled
+ * }
+ * ```
+ *
+ * @example Serverless deployment
+ * ```typescript
+ * redis: { provider: 'vercel-kv' },
+ * transport: {
+ *   protocol: 'stateless-api',
+ *   distributedMode: 'auto',
+ * }
+ * ```
+ *
+ * @example Custom protocol configuration
+ * ```typescript
+ * transport: {
+ *   protocol: {
+ *     sse: true,
+ *     streamable: true,
+ *     json: true,
+ *     stateless: false,
+ *     legacy: false,
+ *     strictSession: true,
+ *   },
+ * }
+ * ```
+ */
+export interface TransportOptionsInterface {
+    /**
+     * Defines how the session lifecycle and nested tokens are managed.
+     *
+     * Modes:
+     * - `'stateful'`: Session and nested tokens are stored server-side (e.g., Redis).
+     *   Results in smaller JWTs and supports token refresh.
+     * - `'stateless'`: All session data is embedded in the JWT.
+     *   Simpler but doesn't support token refresh.
+     *
+     * Can be a function for dynamic selection based on issuer.
+     *
+     * @default 'stateful'
+     */
+    sessionMode?: SessionModeOption;
+    /**
+     * Configuration for detecting the AI platform from MCP client info.
+     */
+    platformDetection?: PlatformDetectionConfig;
+    /**
+     * Protocol configuration - use a preset or customize individual settings.
+     *
+     * **Presets:**
+     * - `'legacy'` (default): Modern + legacy SSE support
+     * - `'modern'`: SSE + streamable HTTP, strict sessions
+     * - `'stateless-api'`: No sessions, pure request/response
+     * - `'full'`: All protocols enabled
+     *
+     * @default 'legacy'
+     */
+    protocol?: ProtocolPreset | ProtocolConfig;
+    /**
+     * Transport persistence configuration.
+     *
+     * When enabled, sessions are persisted to Redis/Vercel KV and transports
+     * can be recreated after server restart.
+     *
+     * **Auto-enable behavior**: Automatically enabled when top-level `redis`
+     * is configured, unless explicitly disabled.
+     *
+     * - `false`: Explicitly disable persistence
+     * - `object`: Enable with custom config (redis override, TTL)
+     * - `undefined`: Auto-enable when global redis exists
+     */
+    persistence?: false | PersistenceConfig;
+    /**
+     * Enable distributed mode for serverless/multi-instance deployments.
+     *
+     * When enabled, the SDK optimizes for environments where requests may
+     * land on different server instances.
+     *
+     * - `true`: Always enable distributed optimizations
+     * - `false`: Disable (default)
+     * - `'auto'`: Auto-detect serverless environment
+     *
+     * @default false
+     */
+    distributedMode?: DistributedEnabled;
+    /**
+     * Enable provider session caching.
+     *
+     * When false, CONTEXT-scoped providers are rebuilt on each request.
+     * Automatically disabled when `distributedMode` is enabled.
+     *
+     * @default true (false when distributedMode is enabled)
+     */
+    providerCaching?: boolean;
+    /**
+     * EventStore configuration for SSE resumability support.
+     *
+     * When enabled, clients can reconnect and resume missed SSE messages
+     * using the Last-Event-ID header per the MCP protocol.
+     *
+     * Note: By default, EventStore is disabled because Claude.ai's client
+     * doesn't handle the priming events correctly. Only enable if your
+     * clients support SSE resumability.
+     *
+     * @default undefined (disabled)
+     */
+    eventStore?: EventStoreConfig;
+}
+/**
+ * Transport options input type - uses this explicit interface for IDE autocomplete.
+ * This is the type users should use when configuring transport options.
+ */
+export type TransportOptionsInput = TransportOptionsInterface;
+//# sourceMappingURL=interfaces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../../../src/common/types/options/transport/interfaces.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAGlD,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAG7F,YAAY,EAAE,WAAW,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,CAAC;AAM3E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC,CAAC;AAMvG;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,QAAQ,GAAG,eAAe,GAAG,MAAM,CAAC;AAE5E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;IAEd;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAE1B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,MAAM,CAAC;AAMlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;IAE9B;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,KAAK,CAAC,EAAE,iBAAiB,CAAC;CAC3B;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,MAAM,WAAW,yBAAyB;IAKxC;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAEhC;;OAEG;IACH,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;IAM5C;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,cAAc,GAAG,cAAc,CAAC;IAM3C;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,EAAE,KAAK,GAAG,iBAAiB,CAAC;IAMxC;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,EAAE,kBAAkB,CAAC;IAErC;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAM1B;;;;;;;;;;;OAWG;IACH,UAAU,CAAC,EAAE,gBAAgB,CAAC;CAC/B;AAMD;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,yBAAyB,CAAC"}

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

@@ -0,0 +1,309 @@
+import { z } from 'zod';
+import type { TransportOptionsInterface, PersistenceConfig, ProtocolConfig, ProtocolPreset, SessionModeOption, DistributedEnabled, EventStoreConfig } from './interfaces';
+export type { TransportOptionsInterface, PersistenceConfig, ProtocolConfig, ProtocolPreset, SessionModeOption, DistributedEnabled, EventStoreConfig, };
+/**
+ * Protocol preset definitions.
+ *
+ * Maps preset names to their expanded protocol configurations.
+ */
+export declare const PROTOCOL_PRESETS: Record<ProtocolPreset, Required<ProtocolConfig>>;
+/**
+ * Expand a protocol preset or config to a full ProtocolConfig with all fields.
+ *
+ * @param protocol - Protocol preset name or custom config
+ * @returns Fully expanded protocol configuration
+ *
+ * @example Preset expansion
+ * ```typescript
+ * expandProtocolConfig('modern')
+ * // { sse: true, streamable: true, json: false, stateless: false, legacy: false, strictSession: true }
+ * ```
+ *
+ * @example Custom config with defaults
+ * ```typescript
+ * expandProtocolConfig({ json: true })
+ * // { sse: true, streamable: true, json: true, stateless: false, legacy: false, strictSession: true }
+ * ```
+ */
+export declare function expandProtocolConfig(protocol: ProtocolPreset | ProtocolConfig | undefined): Required<ProtocolConfig>;
+import { platformDetectionConfigSchema } from '../session';
+/**
+ * Simplified persistence config - no explicit 'enabled' flag.
+ * - `false`: Explicitly disable persistence
+ * - `object`: Enable with custom config
+ * - `undefined`: Auto-enable when global redis exists
+ */
+export declare const persistenceConfigSchema: z.ZodObject<{
+    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>;
+/**
+ * EventStore configuration schema for SSE resumability support.
+ *
+ * When enabled, clients can reconnect and resume missed SSE messages.
+ * By default, EventStore is disabled because Claude.ai's client
+ * doesn't handle priming events correctly.
+ */
+export declare const eventStoreConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    provider: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        memory: "memory";
+        redis: "redis";
+    }>>>;
+    maxEvents: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    ttlMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    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;
+    }>>]>>;
+}, z.core.$strip>;
+/**
+ * Transport options schema - the canonical Zod schema for transport configuration.
+ *
+ * Uses the TransportOptionsInterface for type sync validation.
+ */
+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>]>>>;
+    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>>;
+    protocol: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        modern: "modern";
+        legacy: "legacy";
+        "stateless-api": "stateless-api";
+        full: "full";
+    }>, z.ZodObject<{
+        sse: z.ZodOptional<z.ZodBoolean>;
+        streamable: z.ZodOptional<z.ZodBoolean>;
+        json: z.ZodOptional<z.ZodBoolean>;
+        stateless: z.ZodOptional<z.ZodBoolean>;
+        legacy: z.ZodOptional<z.ZodBoolean>;
+        strictSession: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>]>>>;
+    persistence: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodObject<{
+        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>]>>;
+    distributedMode: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>>;
+    providerCaching: z.ZodOptional<z.ZodBoolean>;
+    eventStore: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        provider: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            memory: "memory";
+            redis: "redis";
+        }>>>;
+        maxEvents: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        ttlMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        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;
+        }>>]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Transport options type (with defaults applied).
+ * This is the output type after Zod parsing.
+ */
+export type TransportOptions = z.infer<typeof transportOptionsSchema>;
+/**
+ * Transport options input type (for user configuration).
+ * Uses the explicit interface for better IDE autocomplete.
+ */
+export type TransportOptionsInput = TransportOptionsInterface;
+/**
+ * Persistence configuration type (with defaults applied)
+ */
+export type TransportPersistenceConfig = z.infer<typeof persistenceConfigSchema>;
+/**
+ * Persistence configuration input type
+ */
+export type TransportPersistenceConfigInput = z.input<typeof persistenceConfigSchema>;
+/**
+ * Platform detection configuration type
+ */
+export type PlatformDetectionConfigType = z.infer<typeof platformDetectionConfigSchema>;
+/**
+ * Distributed mode configuration input type (for user configuration)
+ */
+export type DistributedConfigInput = {
+    enabled?: DistributedEnabled;
+    providerCaching?: boolean;
+};
+/**
+ * Check if distributed mode is enabled based on configuration.
+ * Handles 'auto' detection for serverless environments.
+ */
+export declare function isDistributedMode(distributedMode?: DistributedEnabled): boolean;
+/**
+ * Get effective provider caching setting based on distributed config.
+ */
+export declare function shouldCacheProviders(distributedMode?: DistributedEnabled, providerCaching?: boolean): boolean;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../src/common/types/options/transport/schema.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,OAAO,KAAK,EACV,yBAAyB,EACzB,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AAMtB,YAAY,EACV,yBAAyB,EACzB,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,GACjB,CAAC;AAMF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,cAAc,EAAE,QAAQ,CAAC,cAAc,CAAC,CAoD7E,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,cAAc,GAAG,cAAc,GAAG,SAAS,GAAG,QAAQ,CAAC,cAAc,CAAC,CAoBpH;AA0CD,OAAO,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAuB3D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGlC,CAAC;AAMH;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMjC,CAAC;AAMH;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwCgB,CAAC;AAMpD;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,yBAAyB,CAAC;AAE9D;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEjF;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEtF;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAMxF;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,eAAe,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAsB/E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,eAAe,CAAC,EAAE,kBAAkB,EAAE,eAAe,CAAC,EAAE,OAAO,GAAG,OAAO,CAQ7G"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=typecheck.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typecheck.d.ts","sourceRoot":"","sources":["../../../../../src/common/types/options/transport/typecheck.ts"],"names":[],"mappings":"AA6IA,OAAO,EAAE,CAAC"}