@kya-os/mcp-i 0.1.0 → 1.2.0

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

@@ -0,0 +1,74 @@
+import { z } from "zod";
+export declare const oauthEndpointsSchema: 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;
+}>;
+export type OauthEndpoints = z.infer<typeof oauthEndpointsSchema>;
+export declare const oauthConfigSchema: 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;
+}>;
+export type OAuthConfig = z.infer<typeof oauthConfigSchema>;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oauthConfigSchema = exports.oauthEndpointsSchema = void 0;
+const zod_1 = require("zod");
+// ------------------------------------------------------------
+// OAuth endpoints schema
+// ------------------------------------------------------------
+exports.oauthEndpointsSchema = zod_1.z.object({
+    authorizationUrl: zod_1.z.string(),
+    tokenUrl: zod_1.z.string(),
+    revocationUrl: zod_1.z.string().optional(),
+    userInfoUrl: zod_1.z.string().optional(),
+    registerUrl: zod_1.z.string(),
+});
+// ------------------------------------------------------------
+// OAuth config schema
+// ------------------------------------------------------------
+exports.oauthConfigSchema = zod_1.z.object({
+    endpoints: exports.oauthEndpointsSchema,
+    issuerUrl: zod_1.z.string(),
+    baseUrl: zod_1.z.string(),
+    serviceDocumentationUrl: zod_1.z.string().optional(),
+    pathPrefix: zod_1.z.string().default("/oauth2"),
+    defaultScopes: zod_1.z.array(zod_1.z.string()).default(["openid", "profile", "email"]),
+});

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

@@ -0,0 +1,6 @@
+export { httpTransportConfigSchema, corsConfigSchema, type HttpTransportConfig, type CorsConfig, } from "./transport/http";
+export { stdioTransportConfigSchema, type StdioTransportConfig, } from "./transport/stdio";
+export { oauthConfigSchema, type OAuthConfig } from "./experimental/oauth";
+export { experimentalConfigSchema, type ExperimentalConfig, } from "./experimental";
+export { pathsConfigSchema, type PathsConfig } from "./paths";
+export { webpackConfigSchema, type WebpackConfig } from "./webpack";

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webpackConfigSchema = exports.pathsConfigSchema = exports.experimentalConfigSchema = exports.oauthConfigSchema = exports.stdioTransportConfigSchema = exports.corsConfigSchema = exports.httpTransportConfigSchema = void 0;
+// re export
+var http_1 = require("./transport/http");
+Object.defineProperty(exports, "httpTransportConfigSchema", { enumerable: true, get: function () { return http_1.httpTransportConfigSchema; } });
+Object.defineProperty(exports, "corsConfigSchema", { enumerable: true, get: function () { return http_1.corsConfigSchema; } });
+var stdio_1 = require("./transport/stdio");
+Object.defineProperty(exports, "stdioTransportConfigSchema", { enumerable: true, get: function () { return stdio_1.stdioTransportConfigSchema; } });
+var oauth_1 = require("./experimental/oauth");
+Object.defineProperty(exports, "oauthConfigSchema", { enumerable: true, get: function () { return oauth_1.oauthConfigSchema; } });
+var experimental_1 = require("./experimental");
+Object.defineProperty(exports, "experimentalConfigSchema", { enumerable: true, get: function () { return experimental_1.experimentalConfigSchema; } });
+var paths_1 = require("./paths");
+Object.defineProperty(exports, "pathsConfigSchema", { enumerable: true, get: function () { return paths_1.pathsConfigSchema; } });
+var webpack_1 = require("./webpack");
+Object.defineProperty(exports, "webpackConfigSchema", { enumerable: true, get: function () { return webpack_1.webpackConfigSchema; } });

package/dist/compiler/config/schemas/paths.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const pathsConfigSchema: z.ZodObject<{
+    tools: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    tools: string;
+}, {
+    tools?: string | undefined;
+}>;
+export type PathsConfig = z.infer<typeof pathsConfigSchema>;

package/dist/compiler/config/schemas/paths.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathsConfigSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../constants");
+// ------------------------------------------------------------
+// Paths config schema
+// ------------------------------------------------------------
+exports.pathsConfigSchema = zod_1.z.object({
+    tools: zod_1.z.string().default(constants_1.DEFAULT_PATHS_CONFIG.tools),
+    // TO DO add resources prompts etc
+});

package/dist/compiler/config/schemas/transport/http.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export declare const corsConfigSchema: 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;
+}>;
+export type CorsConfig = z.infer<typeof corsConfigSchema>;
+export declare const httpTransportConfigSchema: 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;
+}>>>]>;
+export type HttpTransportConfig = z.infer<typeof httpTransportConfigSchema>;

package/dist/compiler/config/schemas/transport/http.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpTransportConfigSchema = exports.corsConfigSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+// ------------------------------------------------------------
+// Cors config schema
+// ------------------------------------------------------------
+exports.corsConfigSchema = zod_1.z.object({
+    origin: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string()), zod_1.z.boolean()]).optional(),
+    methods: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
+    allowedHeaders: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
+    exposedHeaders: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
+    credentials: zod_1.z.boolean().optional(),
+    maxAge: zod_1.z.number().optional(),
+});
+// ------------------------------------------------------------
+// HTTP Transport config schema
+// ------------------------------------------------------------
+exports.httpTransportConfigSchema = zod_1.z.union([
+    zod_1.z.boolean(),
+    zod_1.z
+        .object({
+        port: zod_1.z.number().optional(),
+        host: zod_1.z.string().optional(),
+        bodySizeLimit: zod_1.z.number().optional(),
+        debug: zod_1.z.boolean().optional(),
+        endpoint: zod_1.z.string().optional(),
+        cors: exports.corsConfigSchema.optional(),
+    })
+        .default(constants_1.DEFAULT_HTTP_CONFIG)
+        .optional(),
+]);

package/dist/compiler/config/schemas/transport/stdio.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const stdioTransportConfigSchema: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+    debug: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    debug: boolean;
+}, {
+    debug?: boolean | undefined;
+}>]>>;
+export type StdioTransportConfig = z.infer<typeof stdioTransportConfigSchema>;

package/dist/compiler/config/schemas/transport/stdio.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stdioTransportConfigSchema = void 0;
+const zod_1 = require("zod");
+// ------------------------------------------------------------
+// stdio transport config schema
+// ------------------------------------------------------------
+exports.stdioTransportConfigSchema = zod_1.z
+    .union([
+    zod_1.z.boolean(),
+    zod_1.z.object({
+        debug: zod_1.z.boolean().default(false),
+    }),
+])
+    .optional();

package/dist/compiler/config/schemas/webpack.d.ts

@@ -0,0 +1,3 @@
+import z from "zod";
+export declare const webpackConfigSchema: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodAny>>;
+export type WebpackConfig = z.infer<typeof webpackConfigSchema>;

package/dist/compiler/config/schemas/webpack.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webpackConfigSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+// ------------------------------------------------------------
+// Webpack config schema
+// ------------------------------------------------------------
+exports.webpackConfigSchema = zod_1.default
+    .function()
+    .args(zod_1.default.any())
+    .returns(zod_1.default.any())
+    .optional();

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

@@ -0,0 +1 @@
+export type { HttpTransportConfig, StdioTransportConfig, CorsConfig, OAuthConfig, ExperimentalConfig, PathsConfig, WebpackConfig, } from "./schemas";

package/dist/compiler/config/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,20 @@
+import { HttpTransportConfig, CorsConfig, PathsConfig, OAuthConfig, StdioTransportConfig } from "./schemas";
+export declare function getResolvedHttpConfig(userConfig: HttpTransportConfig | undefined): {
+    port: number;
+    host: string;
+    bodySizeLimit: number;
+    debug: boolean;
+    endpoint: string;
+    cors: {
+        origin?: string | boolean | string[] | undefined;
+        methods?: string | string[] | undefined;
+        allowedHeaders?: string | string[] | undefined;
+        exposedHeaders?: string | string[] | undefined;
+        credentials?: boolean | undefined;
+        maxAge?: number | undefined;
+    };
+} | null;
+export declare function getResolvedCorsConfig(httpConfig: HttpTransportConfig | null): CorsConfig;
+export declare function getResolvedPathsConfig(userConfig: any): PathsConfig;
+export declare function getResolvedOAuthConfig(userConfig: any): OAuthConfig | null;
+export declare function getResolvedStdioConfig(userConfig: any): StdioTransportConfig | null;

package/dist/compiler/config/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResolvedHttpConfig = getResolvedHttpConfig;
+exports.getResolvedCorsConfig = getResolvedCorsConfig;
+exports.getResolvedPathsConfig = getResolvedPathsConfig;
+exports.getResolvedOAuthConfig = getResolvedOAuthConfig;
+exports.getResolvedStdioConfig = getResolvedStdioConfig;
+const constants_1 = require("./constants");
+function getResolvedHttpConfig(userConfig) {
+    if (typeof userConfig === "boolean") {
+        return userConfig ? constants_1.DEFAULT_HTTP_CONFIG : null;
+    }
+    if (typeof userConfig === "object") {
+        return { ...constants_1.DEFAULT_HTTP_CONFIG, ...userConfig };
+    }
+    return null;
+}
+function getResolvedCorsConfig(httpConfig) {
+    if (typeof httpConfig === "object" && httpConfig?.cors) {
+        return { ...constants_1.DEFAULT_HTTP_CONFIG.cors, ...httpConfig.cors };
+    }
+    return constants_1.DEFAULT_HTTP_CONFIG.cors;
+}
+function getResolvedPathsConfig(userConfig) {
+    const userPaths = userConfig?.paths;
+    if (!userPaths) {
+        return constants_1.DEFAULT_PATHS_CONFIG;
+    }
+    return { ...constants_1.DEFAULT_PATHS_CONFIG, ...userPaths };
+}
+function getResolvedOAuthConfig(userConfig) {
+    return userConfig?.experimental?.oauth || null;
+}
+function getResolvedStdioConfig(userConfig) {
+    return userConfig?.stdio || constants_1.DEFAULT_STDIO_CONFIG;
+}

package/dist/compiler/generate-env-code.d.ts

@@ -0,0 +1 @@
+export declare function generateEnvCode(): string;

package/dist/compiler/generate-env-code.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEnvCode = generateEnvCode;
+function generateEnvCode() {
+    return `/// <reference types="xmcp" />
+
+// Do not edit this file`;
+}

package/dist/compiler/generate-import-code.d.ts

@@ -0,0 +1 @@
+export declare function generateImportCode(): string;

package/dist/compiler/generate-import-code.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportCode = generateImportCode;
+const compiler_context_1 = require("./compiler-context");
+function generateImportCode() {
+    const { toolPaths, hasMiddleware } = compiler_context_1.compilerContext.getContext();
+    const importToolsCode = Array.from(toolPaths)
+        .map((p) => {
+        const path = p.replace(/\\/g, "/");
+        const relativePath = `../${path}`;
+        return `"${path}": () => import("${relativePath}"),`;
+    })
+        .join("\n");
+    const importMiddlewareCode = hasMiddleware
+        ? `export const middleware = () => import("../src/middleware.ts");`
+        : "";
+    return `
+export const tools = {
+${importToolsCode}
+};
+
+${importMiddlewareCode}
+`;
+}

package/dist/compiler/get-webpack-config/get-entries.d.ts

@@ -0,0 +1,3 @@
+import { XmcpConfigOuputSchema } from "../config";
+/** Get what packages are gonna be built by xmcp */
+export declare function getEntries(xmcpConfig: XmcpConfigOuputSchema): Record<string, string>;

package/dist/compiler/get-webpack-config/get-entries.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntries = getEntries;
+const constants_1 = require("../../utils/constants");
+const path_1 = __importDefault(require("path"));
+/** Get what packages are gonna be built by xmcp */
+function getEntries(xmcpConfig) {
+    const entries = {};
+    if (xmcpConfig.stdio) {
+        entries.stdio = path_1.default.join(constants_1.runtimeFolderPath, "stdio.js");
+    }
+    if (xmcpConfig["http"]) {
+        // non adapter mode
+        if (!xmcpConfig.experimental?.adapter) {
+            entries["http"] = path_1.default.join(constants_1.runtimeFolderPath, "http.js");
+        }
+        // adapter mode enabled
+        if (xmcpConfig.experimental?.adapter === "express") {
+            entries["adapter"] = path_1.default.join(constants_1.runtimeFolderPath, "adapter-express.js");
+        }
+        if (xmcpConfig.experimental?.adapter === "nextjs") {
+            entries["adapter"] = path_1.default.join(constants_1.runtimeFolderPath, "adapter-nextjs.js");
+        }
+    }
+    return entries;
+}

package/dist/compiler/get-webpack-config/get-externals.d.ts

@@ -0,0 +1,7 @@
+import { Configuration } from "webpack";
+/**
+ * This function will decide is a file is bundled by xmcp compiler or not.
+ * We want to avoid building node modules.
+ * When using Next.js, we want to avoid building tools/*, since the nexjs compiler will handle that code.
+ */
+export declare function getExternals(): Configuration["externals"];

package/dist/compiler/get-webpack-config/get-externals.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExternals = getExternals;
+const compiler_context_1 = require("../compiler-context");
+const module_1 = require("module");
+const plugins_1 = require("./plugins");
+/**
+ * This function will decide is a file is bundled by xmcp compiler or not.
+ * We want to avoid building node modules.
+ * When using Next.js, we want to avoid building tools/*, since the nexjs compiler will handle that code.
+ */
+function getExternals() {
+    const xmcpConfig = (0, compiler_context_1.getXmcpConfig)();
+    const replacedImports = new Set();
+    return [
+        function (data, callback) {
+            const { request } = data;
+            if (!request) {
+                return callback();
+            }
+            /**
+             * Externalize Node.js built-in modules, bundle everything else
+             */
+            const isBuiltinModule = module_1.builtinModules.includes(request) ||
+                module_1.builtinModules.includes(request.replace(/^node:/, ""));
+            if (isBuiltinModule) {
+                return callback(null, `commonjs ${request}`);
+            }
+            /**
+             * Externalize packages with native binaries (.node files)
+             * These can't be bundled by webpack and must be external
+             */
+            const nativeBinaryPackages = [
+                'fsevents',
+                'cpu-features',
+                '@swc/wasm',
+                '@swc/core-darwin-arm64',
+                '@swc/core-darwin-x64',
+                '@swc/core-linux-arm64-gnu',
+                '@swc/core-linux-arm64-musl',
+                '@swc/core-linux-x64-gnu',
+                '@swc/core-linux-x64-musl',
+                '@swc/core-win32-arm64-msvc',
+                '@swc/core-win32-ia32-msvc',
+                '@swc/core-win32-x64-msvc',
+            ];
+            if (nativeBinaryPackages.some(pkg => request === pkg || request.startsWith(`${pkg}/`))) {
+                return callback(null, `commonjs ${request}`);
+            }
+            // Check if request is inside .xmcp folder - if so, bundle it
+            if (request.includes(".xmcp")) {
+                return callback();
+            }
+            // Check if request is a runtime file - if so, bundle it
+            const filesToInclude = [...Object.keys(plugins_1.runtimeFiles), "import-map.js"];
+            for (const file of filesToInclude) {
+                if (request.endsWith(`./${file}`) ||
+                    request.endsWith(`./${file.replace(".js", "")}`)) {
+                    return callback();
+                }
+            }
+            /**
+             * When using Next.js, we want them to bundle the code for the tool file,
+             * so just keep the reference for the import as external
+             */
+            if (xmcpConfig.experimental?.adapter === "nextjs") {
+                // Bundle imports from the same folder
+                if (request.startsWith("./")) {
+                    return callback();
+                }
+                let pathRequest = request;
+                /**
+                 * Paths are relative to the .xmcp/nextjs-adapter folder,
+                 * but we are building in .xmcp/adapter/index.js, so we need to go up 2 levels
+                 */
+                if (request.startsWith("../")) {
+                    // Only replace the import if it hasn't been replaced yet
+                    if (!replacedImports.has(request)) {
+                        pathRequest = pathRequest.replace("../", "../../");
+                        replacedImports.add(pathRequest);
+                    }
+                }
+                return callback(null, `commonjs ${pathRequest}`);
+            }
+            callback();
+        },
+    ];
+}

package/dist/compiler/get-webpack-config/get-injected-variables.d.ts

@@ -0,0 +1,8 @@
+import { XmcpConfigOuputSchema } from "../config";
+import { InjectedVariables } from "../config/injection";
+/**
+ * The XMCP runtime uses variables that are not defined by default.
+ *
+ * This utility will define those variables based on the user's config.
+ */
+export declare function getInjectedVariables(xmcpConfig: XmcpConfigOuputSchema): InjectedVariables;

package/dist/compiler/get-webpack-config/get-injected-variables.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInjectedVariables = getInjectedVariables;
+const compiler_context_1 = require("../compiler-context");
+const injection_1 = require("../config/injection");
+/**
+ * The XMCP runtime uses variables that are not defined by default.
+ *
+ * This utility will define those variables based on the user's config.
+ */
+function getInjectedVariables(xmcpConfig) {
+    const { mode } = compiler_context_1.compilerContext.getContext();
+    const httpVariables = (0, injection_1.injectHttpVariables)(xmcpConfig.http, mode);
+    const corsVariables = (0, injection_1.injectCorsVariables)(xmcpConfig.http);
+    const oauthVariables = (0, injection_1.injectOAuthVariables)(xmcpConfig);
+    const pathsVariables = (0, injection_1.injectPathsVariables)(xmcpConfig);
+    const stdioVariables = (0, injection_1.injectStdioVariables)(xmcpConfig.stdio);
+    return {
+        ...httpVariables,
+        ...corsVariables,
+        ...oauthVariables,
+        ...pathsVariables,
+        ...stdioVariables,
+    };
+}

package/dist/compiler/get-webpack-config/index.d.ts

@@ -0,0 +1,4 @@
+import { Configuration } from "webpack";
+import { XmcpConfigOuputSchema } from "../config";
+/** Creates the webpack configuration that xmcp will use to bundle the user's code */
+export declare function getWebpackConfig(xmcpConfig: XmcpConfigOuputSchema): Configuration;