@kya-os/mcp-i 0.1.0 → 1.2.1

package/dist/cache/redis-nonce-cache.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisNonceCache = void 0;
+/**
+ * Redis-based nonce cache implementation
+ * Suitable for multi-instance deployments
+ */
+class RedisNonceCache {
+    redis; // Redis client - type depends on redis library used
+    keyPrefix;
+    constructor(redis, keyPrefix = "mcpi:nonce:") {
+        this.redis = redis;
+        this.keyPrefix = keyPrefix;
+    }
+    getKey(nonce) {
+        return `${this.keyPrefix}${nonce}`;
+    }
+    async has(nonce) {
+        try {
+            const key = this.getKey(nonce);
+            const exists = await this.redis.exists(key);
+            return exists === 1;
+        }
+        catch (error) {
+            console.error("Redis has() operation failed:", error);
+            throw new Error(`Failed to check nonce existence: ${error}`);
+        }
+    }
+    async add(nonce, ttl) {
+        try {
+            const key = this.getKey(nonce);
+            // Use SET with NX (not exists) and EX (expiry) for atomic add-if-absent
+            // This is truly atomic in Redis
+            const result = await this.redis.set(key, "1", "EX", ttl, "NX");
+            if (result !== "OK") {
+                throw new Error(`Nonce ${nonce} already exists - potential replay attack`);
+            }
+        }
+        catch (error) {
+            // Re-throw our own errors
+            if (error.message?.includes("already exists")) {
+                throw error;
+            }
+            console.error("Redis add() operation failed:", error);
+            throw new Error(`Failed to add nonce to cache: ${error}`);
+        }
+    }
+    async cleanup() {
+        // Redis handles expiry automatically, so this is a no-op
+        // This method exists to satisfy the interface
+    }
+}
+exports.RedisNonceCache = RedisNonceCache;

package/dist/compiler/compiler-context.d.ts

@@ -0,0 +1,23 @@
+import { CompilerMode } from ".";
+import { XmcpConfigOuputSchema } from "./config";
+interface CompilerContext {
+    /** The mode of the compiler. */
+    mode: CompilerMode;
+    /** Whether the adapter is enabled. */
+    adapter?: boolean;
+    /** The platforms to build for. */
+    platforms: {
+        /** Generates a .vercel folder to deploy on Vercel */
+        vercel?: boolean;
+    };
+    /** The paths to the tools. */
+    toolPaths: Set<string>;
+    /** Whether the middleware is enabled. */
+    hasMiddleware: boolean;
+    /** The parsed config. */
+    xmcpConfig?: XmcpConfigOuputSchema;
+}
+export declare const compilerContext: import("../utils/context").Context<CompilerContext>;
+export declare const compilerContextProvider: (initialValue: Omit<CompilerContext, "toolPaths" | "hasMiddleware">, callback: () => void) => void;
+export declare const getXmcpConfig: () => XmcpConfigOuputSchema;
+export {};

package/dist/compiler/compiler-context.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getXmcpConfig = exports.compilerContextProvider = exports.compilerContext = void 0;
+const context_1 = require("../utils/context");
+exports.compilerContext = (0, context_1.createContext)({
+    name: "xmcp-compiler",
+});
+// Preset some defaults for the compiler context
+const compilerContextProvider = (initialValue, callback) => {
+    return exports.compilerContext.provider({
+        ...initialValue,
+        toolPaths: new Set(),
+        hasMiddleware: false,
+    }, callback);
+};
+exports.compilerContextProvider = compilerContextProvider;
+const getXmcpConfig = () => {
+    const { xmcpConfig } = exports.compilerContext.getContext();
+    if (!xmcpConfig) {
+        throw new Error("xmcp config not found");
+    }
+    return xmcpConfig;
+};
+exports.getXmcpConfig = getXmcpConfig;

package/dist/compiler/config/constants.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Default values for CORS config
+ */
+export declare const DEFAULT_CORS_CONFIG: {
+    origin: string;
+    methods: string[];
+    allowedHeaders: string[];
+    exposedHeaders: string[];
+    credentials: boolean;
+    maxAge: number;
+};
+/**
+ * Default values for the HTTP transport
+ */
+export declare const DEFAULT_HTTP_CONFIG: {
+    port: number;
+    host: string;
+    bodySizeLimit: number;
+    debug: boolean;
+    endpoint: string;
+    cors: {
+        origin: string;
+        methods: string[];
+        allowedHeaders: string[];
+        exposedHeaders: string[];
+        credentials: boolean;
+        maxAge: number;
+    };
+};
+/**
+ * Default values for the STDIO transport
+ */
+export declare const DEFAULT_STDIO_CONFIG: {
+    debug: boolean;
+};
+/**
+ * Default values for the tools directory
+ */
+export declare const DEFAULT_PATHS_CONFIG: {
+    tools: string;
+};

package/dist/compiler/config/constants.js

@@ -0,0 +1,45 @@
+"use strict";
+// ------------------------------------------------------------
+// Constants
+// ------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PATHS_CONFIG = exports.DEFAULT_STDIO_CONFIG = exports.DEFAULT_HTTP_CONFIG = exports.DEFAULT_CORS_CONFIG = void 0;
+/**
+ * Default values for CORS config
+ */
+exports.DEFAULT_CORS_CONFIG = {
+    origin: "*",
+    methods: ["GET", "POST"],
+    allowedHeaders: [
+        "Content-Type",
+        "Authorization",
+        "mcp-session-id",
+        "mcp-protocol-version",
+    ],
+    exposedHeaders: ["Content-Type", "Authorization", "mcp-session-id"],
+    credentials: false,
+    maxAge: 86400,
+};
+/**
+ * Default values for the HTTP transport
+ */
+exports.DEFAULT_HTTP_CONFIG = {
+    port: 3000,
+    host: "127.0.0.1",
+    bodySizeLimit: 1024 * 1024 * 10, // 10MB
+    debug: false,
+    endpoint: "/mcp",
+    cors: exports.DEFAULT_CORS_CONFIG,
+};
+/**
+ * Default values for the STDIO transport
+ */
+exports.DEFAULT_STDIO_CONFIG = {
+    debug: false,
+};
+/**
+ * Default values for the tools directory
+ */
+exports.DEFAULT_PATHS_CONFIG = {
+    tools: "src/tools",
+};

package/dist/compiler/config/index.d.ts

@@ -0,0 +1,252 @@
+import { z } from "zod";
+import { Configuration } from "webpack";
+/**
+ * xmcp Config schema
+ */
+export declare const configSchema: z.ZodObject<{
+    stdio: z.ZodOptional<z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+        debug: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        debug: boolean;
+    }, {
+        debug?: boolean | undefined;
+    }>]>>>;
+    http: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        port: z.ZodOptional<z.ZodNumber>;
+        host: z.ZodOptional<z.ZodString>;
+        bodySizeLimit: z.ZodOptional<z.ZodNumber>;
+        debug: z.ZodOptional<z.ZodBoolean>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        cors: z.ZodOptional<z.ZodObject<{
+            origin: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodBoolean]>>;
+            methods: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+            allowedHeaders: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+            exposedHeaders: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+            credentials: z.ZodOptional<z.ZodBoolean>;
+            maxAge: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            origin?: string | boolean | string[] | undefined;
+            methods?: string | string[] | undefined;
+            allowedHeaders?: string | string[] | undefined;
+            exposedHeaders?: string | string[] | undefined;
+            credentials?: boolean | undefined;
+            maxAge?: number | undefined;
+        }, {
+            origin?: string | boolean | string[] | undefined;
+            methods?: string | string[] | undefined;
+            allowedHeaders?: string | string[] | undefined;
+            exposedHeaders?: string | string[] | undefined;
+            credentials?: boolean | undefined;
+            maxAge?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        port?: number | undefined;
+        host?: string | undefined;
+        bodySizeLimit?: number | undefined;
+        debug?: boolean | undefined;
+        endpoint?: string | undefined;
+        cors?: {
+            origin?: string | boolean | string[] | undefined;
+            methods?: string | string[] | undefined;
+            allowedHeaders?: string | string[] | undefined;
+            exposedHeaders?: string | string[] | undefined;
+            credentials?: boolean | undefined;
+            maxAge?: number | undefined;
+        } | undefined;
+    }, {
+        port?: number | undefined;
+        host?: string | undefined;
+        bodySizeLimit?: number | undefined;
+        debug?: boolean | undefined;
+        endpoint?: string | undefined;
+        cors?: {
+            origin?: string | boolean | string[] | undefined;
+            methods?: string | string[] | undefined;
+            allowedHeaders?: string | string[] | undefined;
+            exposedHeaders?: string | string[] | undefined;
+            credentials?: boolean | undefined;
+            maxAge?: number | undefined;
+        } | undefined;
+    }>>>]>>;
+    experimental: z.ZodOptional<z.ZodObject<{
+        oauth: z.ZodOptional<z.ZodObject<{
+            endpoints: z.ZodObject<{
+                authorizationUrl: z.ZodString;
+                tokenUrl: z.ZodString;
+                revocationUrl: z.ZodOptional<z.ZodString>;
+                userInfoUrl: z.ZodOptional<z.ZodString>;
+                registerUrl: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                authorizationUrl: string;
+                tokenUrl: string;
+                registerUrl: string;
+                revocationUrl?: string | undefined;
+                userInfoUrl?: string | undefined;
+            }, {
+                authorizationUrl: string;
+                tokenUrl: string;
+                registerUrl: string;
+                revocationUrl?: string | undefined;
+                userInfoUrl?: string | undefined;
+            }>;
+            issuerUrl: z.ZodString;
+            baseUrl: z.ZodString;
+            serviceDocumentationUrl: z.ZodOptional<z.ZodString>;
+            pathPrefix: z.ZodDefault<z.ZodString>;
+            defaultScopes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            endpoints: {
+                authorizationUrl: string;
+                tokenUrl: string;
+                registerUrl: string;
+                revocationUrl?: string | undefined;
+                userInfoUrl?: string | undefined;
+            };
+            issuerUrl: string;
+            baseUrl: string;
+            pathPrefix: string;
+            defaultScopes: string[];
+            serviceDocumentationUrl?: string | undefined;
+        }, {
+            endpoints: {
+                authorizationUrl: string;
+                tokenUrl: string;
+                registerUrl: string;
+                revocationUrl?: string | undefined;
+                userInfoUrl?: string | undefined;
+            };
+            issuerUrl: string;
+            baseUrl: string;
+            serviceDocumentationUrl?: string | undefined;
+            pathPrefix?: string | undefined;
+            defaultScopes?: string[] | undefined;
+        }>>;
+        adapter: z.ZodOptional<z.ZodEnum<["express", "nextjs"]>>;
+    }, "strip", z.ZodTypeAny, {
+        oauth?: {
+            endpoints: {
+                authorizationUrl: string;
+                tokenUrl: string;
+                registerUrl: string;
+                revocationUrl?: string | undefined;
+                userInfoUrl?: string | undefined;
+            };
+            issuerUrl: string;
+            baseUrl: string;
+            pathPrefix: string;
+            defaultScopes: string[];
+            serviceDocumentationUrl?: string | undefined;
+        } | undefined;
+        adapter?: "express" | "nextjs" | undefined;
+    }, {
+        oauth?: {
+            endpoints: {
+                authorizationUrl: string;
+                tokenUrl: string;
+                registerUrl: string;
+                revocationUrl?: string | undefined;
+                userInfoUrl?: string | undefined;
+            };
+            issuerUrl: string;
+            baseUrl: string;
+            serviceDocumentationUrl?: string | undefined;
+            pathPrefix?: string | undefined;
+            defaultScopes?: string[] | undefined;
+        } | undefined;
+        adapter?: "express" | "nextjs" | undefined;
+    }>>;
+    paths: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        tools: string;
+    }, {
+        tools?: string | undefined;
+    }>>;
+    webpack: z.ZodOptional<z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodAny>>>;
+}, "strip", z.ZodTypeAny, {
+    stdio?: boolean | {
+        debug: boolean;
+    } | undefined;
+    http?: boolean | {
+        port?: number | undefined;
+        host?: string | undefined;
+        bodySizeLimit?: number | undefined;
+        debug?: boolean | undefined;
+        endpoint?: string | undefined;
+        cors?: {
+            origin?: string | boolean | string[] | undefined;
+            methods?: string | string[] | undefined;
+            allowedHeaders?: string | string[] | undefined;
+            exposedHeaders?: string | string[] | undefined;
+            credentials?: boolean | undefined;
+            maxAge?: number | undefined;
+        } | undefined;
+    } | undefined;
+    experimental?: {
+        oauth?: {
+            endpoints: {
+                authorizationUrl: string;
+                tokenUrl: string;
+                registerUrl: string;
+                revocationUrl?: string | undefined;
+                userInfoUrl?: string | undefined;
+            };
+            issuerUrl: string;
+            baseUrl: string;
+            pathPrefix: string;
+            defaultScopes: string[];
+            serviceDocumentationUrl?: string | undefined;
+        } | undefined;
+        adapter?: "express" | "nextjs" | undefined;
+    } | undefined;
+    paths?: {
+        tools: string;
+    } | undefined;
+    webpack?: ((args_0: any, ...args: unknown[]) => any) | undefined;
+}, {
+    stdio?: boolean | {
+        debug?: boolean | undefined;
+    } | undefined;
+    http?: boolean | {
+        port?: number | undefined;
+        host?: string | undefined;
+        bodySizeLimit?: number | undefined;
+        debug?: boolean | undefined;
+        endpoint?: string | undefined;
+        cors?: {
+            origin?: string | boolean | string[] | undefined;
+            methods?: string | string[] | undefined;
+            allowedHeaders?: string | string[] | undefined;
+            exposedHeaders?: string | string[] | undefined;
+            credentials?: boolean | undefined;
+            maxAge?: number | undefined;
+        } | undefined;
+    } | undefined;
+    experimental?: {
+        oauth?: {
+            endpoints: {
+                authorizationUrl: string;
+                tokenUrl: string;
+                registerUrl: string;
+                revocationUrl?: string | undefined;
+                userInfoUrl?: string | undefined;
+            };
+            issuerUrl: string;
+            baseUrl: string;
+            serviceDocumentationUrl?: string | undefined;
+            pathPrefix?: string | undefined;
+            defaultScopes?: string[] | undefined;
+        } | undefined;
+        adapter?: "express" | "nextjs" | undefined;
+    } | undefined;
+    paths?: {
+        tools?: string | undefined;
+    } | undefined;
+    webpack?: ((args_0: any, ...args: unknown[]) => any) | undefined;
+}>;
+type WebpackConfig = {
+    webpack?: (config: Configuration) => Configuration;
+};
+export type XmcpConfigInputSchema = Omit<z.input<typeof configSchema>, "webpack"> & WebpackConfig;
+export type XmcpConfigOuputSchema = Omit<z.output<typeof configSchema>, "webpack"> & WebpackConfig;
+export {};

package/dist/compiler/config/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configSchema = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("./schemas");
+/**
+ * xmcp Config schema
+ */
+exports.configSchema = zod_1.z.object({
+    stdio: schemas_1.stdioTransportConfigSchema.optional(),
+    http: schemas_1.httpTransportConfigSchema.optional(),
+    experimental: schemas_1.experimentalConfigSchema.optional(),
+    paths: schemas_1.pathsConfigSchema.optional(),
+    webpack: schemas_1.webpackConfigSchema.optional(),
+});

package/dist/compiler/config/injection.d.ts

@@ -0,0 +1,26 @@
+import { HttpTransportConfig } from "./schemas/transport/http";
+export declare function injectHttpVariables(httpConfig: HttpTransportConfig | boolean, mode: string): {
+    HTTP_CONFIG?: undefined;
+} | {
+    HTTP_CONFIG: string;
+};
+export type HttpVariables = ReturnType<typeof injectHttpVariables>;
+export declare function injectCorsVariables(httpConfig: HttpTransportConfig | null): {
+    HTTP_CORS_CONFIG: string;
+};
+export type CorsVariables = ReturnType<typeof injectCorsVariables>;
+export declare function injectOAuthVariables(userConfig: any): {
+    OAUTH_CONFIG: string;
+};
+export type OAuthVariables = ReturnType<typeof injectOAuthVariables>;
+export declare function injectPathsVariables(userConfig: any): {
+    TOOLS_PATH: string;
+};
+export type PathsVariables = ReturnType<typeof injectPathsVariables>;
+export declare function injectStdioVariables(stdioConfig: any): {
+    STDIO_CONFIG?: undefined;
+} | {
+    STDIO_CONFIG: string;
+};
+export type StdioVariables = ReturnType<typeof injectStdioVariables>;
+export type InjectedVariables = HttpVariables | CorsVariables | OAuthVariables | PathsVariables | StdioVariables;

package/dist/compiler/config/injection.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectHttpVariables = injectHttpVariables;
+exports.injectCorsVariables = injectCorsVariables;
+exports.injectOAuthVariables = injectOAuthVariables;
+exports.injectPathsVariables = injectPathsVariables;
+exports.injectStdioVariables = injectStdioVariables;
+const utils_1 = require("./utils");
+function injectHttpVariables(httpConfig, mode) {
+    const resolvedConfig = (0, utils_1.getResolvedHttpConfig)(httpConfig);
+    if (!resolvedConfig)
+        return {};
+    return {
+        HTTP_CONFIG: JSON.stringify({
+            port: resolvedConfig.port,
+            host: resolvedConfig.host,
+            bodySizeLimit: resolvedConfig.bodySizeLimit,
+            endpoint: resolvedConfig.endpoint,
+            stateless: true,
+            debug: mode === "development",
+        }),
+    };
+}
+function injectCorsVariables(httpConfig) {
+    const corsConfig = (0, utils_1.getResolvedCorsConfig)(httpConfig);
+    return {
+        HTTP_CORS_CONFIG: JSON.stringify({
+            origin: corsConfig.origin ?? "",
+            methods: corsConfig.methods ?? "",
+            allowedHeaders: corsConfig.allowedHeaders ?? "",
+            exposedHeaders: corsConfig.exposedHeaders ?? "",
+            credentials: corsConfig.credentials ?? false,
+            maxAge: corsConfig.maxAge ?? 0,
+        }),
+    };
+}
+function injectOAuthVariables(userConfig) {
+    const oauthConfig = (0, utils_1.getResolvedOAuthConfig)(userConfig);
+    return {
+        OAUTH_CONFIG: JSON.stringify(oauthConfig),
+    };
+}
+function injectPathsVariables(userConfig) {
+    const pathsConfig = (0, utils_1.getResolvedPathsConfig)(userConfig);
+    return {
+        TOOLS_PATH: JSON.stringify(pathsConfig.tools),
+    };
+}
+function injectStdioVariables(stdioConfig) {
+    if (!stdioConfig)
+        return {};
+    const debug = typeof stdioConfig === "object" ? stdioConfig.debug : false;
+    return {
+        STDIO_CONFIG: JSON.stringify({
+            debug,
+        }),
+    };
+}

package/dist/compiler/config/schemas/experimental/index.d.ts

@@ -0,0 +1,91 @@
+import { z } from "zod";
+export declare const adapterConfigSchema: z.ZodEnum<["express", "nextjs"]>;
+export type AdapterConfig = z.infer<typeof adapterConfigSchema>;
+export declare const experimentalConfigSchema: z.ZodObject<{
+    oauth: z.ZodOptional<z.ZodObject<{
+        endpoints: z.ZodObject<{
+            authorizationUrl: z.ZodString;
+            tokenUrl: z.ZodString;
+            revocationUrl: z.ZodOptional<z.ZodString>;
+            userInfoUrl: z.ZodOptional<z.ZodString>;
+            registerUrl: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            authorizationUrl: string;
+            tokenUrl: string;
+            registerUrl: string;
+            revocationUrl?: string | undefined;
+            userInfoUrl?: string | undefined;
+        }, {
+            authorizationUrl: string;
+            tokenUrl: string;
+            registerUrl: string;
+            revocationUrl?: string | undefined;
+            userInfoUrl?: string | undefined;
+        }>;
+        issuerUrl: z.ZodString;
+        baseUrl: z.ZodString;
+        serviceDocumentationUrl: z.ZodOptional<z.ZodString>;
+        pathPrefix: z.ZodDefault<z.ZodString>;
+        defaultScopes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        endpoints: {
+            authorizationUrl: string;
+            tokenUrl: string;
+            registerUrl: string;
+            revocationUrl?: string | undefined;
+            userInfoUrl?: string | undefined;
+        };
+        issuerUrl: string;
+        baseUrl: string;
+        pathPrefix: string;
+        defaultScopes: string[];
+        serviceDocumentationUrl?: string | undefined;
+    }, {
+        endpoints: {
+            authorizationUrl: string;
+            tokenUrl: string;
+            registerUrl: string;
+            revocationUrl?: string | undefined;
+            userInfoUrl?: string | undefined;
+        };
+        issuerUrl: string;
+        baseUrl: string;
+        serviceDocumentationUrl?: string | undefined;
+        pathPrefix?: string | undefined;
+        defaultScopes?: string[] | undefined;
+    }>>;
+    adapter: z.ZodOptional<z.ZodEnum<["express", "nextjs"]>>;
+}, "strip", z.ZodTypeAny, {
+    oauth?: {
+        endpoints: {
+            authorizationUrl: string;
+            tokenUrl: string;
+            registerUrl: string;
+            revocationUrl?: string | undefined;
+            userInfoUrl?: string | undefined;
+        };
+        issuerUrl: string;
+        baseUrl: string;
+        pathPrefix: string;
+        defaultScopes: string[];
+        serviceDocumentationUrl?: string | undefined;
+    } | undefined;
+    adapter?: "express" | "nextjs" | undefined;
+}, {
+    oauth?: {
+        endpoints: {
+            authorizationUrl: string;
+            tokenUrl: string;
+            registerUrl: string;
+            revocationUrl?: string | undefined;
+            userInfoUrl?: string | undefined;
+        };
+        issuerUrl: string;
+        baseUrl: string;
+        serviceDocumentationUrl?: string | undefined;
+        pathPrefix?: string | undefined;
+        defaultScopes?: string[] | undefined;
+    } | undefined;
+    adapter?: "express" | "nextjs" | undefined;
+}>;
+export type ExperimentalConfig = z.infer<typeof experimentalConfigSchema>;

package/dist/compiler/config/schemas/experimental/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.experimentalConfigSchema = exports.adapterConfigSchema = void 0;
+const zod_1 = require("zod");
+const oauth_1 = require("./oauth");
+// ------------------------------------------------------------
+// Adapter config schema (perhaps a separate file but it's small yet)
+// ------------------------------------------------------------
+exports.adapterConfigSchema = zod_1.z.enum(["express", "nextjs"]);
+// ------------------------------------------------------------
+// Experimental features schema
+// ------------------------------------------------------------
+exports.experimentalConfigSchema = zod_1.z.object({
+    oauth: oauth_1.oauthConfigSchema.optional(),
+    adapter: exports.adapterConfigSchema.optional(),
+});