@mastra/server 1.36.0-alpha.1 → 1.36.0-alpha.2

package/dist/server/handlers/editor-builder.d.ts

@@ -0,0 +1,259 @@
+import type { Mastra } from '@mastra/core';
+import type { AgentFeatures } from '../schemas/editor-builder.js';
+/**
+ * Returns whether a given agent-builder feature is enabled. Used by list /
+ * get-by-id handlers to soft-gate response enrichment (omit fields, ignore
+ * favoritedOnly / pinFavoritedFor params) when the feature is off.
+ */
+export declare function isBuilderFeatureEnabled(mastra: Mastra, feature: keyof AgentFeatures): Promise<boolean>;
+/**
+ * Hard-gate helper for mutation routes that must not exist when the feature
+ * is off. Throws `HTTPException(404)` so we don't leak the existence of the
+ * feature surface (matches behavior of unregistered routes).
+ */
+export declare function requireBuilderFeature(mastra: Mastra, feature: keyof AgentFeatures): Promise<void>;
+/**
+ * GET /editor/builder/settings
+ *
+ * Returns the agent builder settings configured by the admin.
+ * Used by frontend to determine which features to display.
+ */
+export declare const GET_EDITOR_BUILDER_SETTINGS_ROUTE: import("../server-adapter").ServerRoute<{}, {
+    enabled: boolean;
+    features?: {
+        agent?: {
+            tools?: boolean | undefined;
+            agents?: boolean | undefined;
+            workflows?: boolean | undefined;
+            scorers?: boolean | undefined;
+            skills?: boolean | undefined;
+            memory?: boolean | undefined;
+            variables?: boolean | undefined;
+            favorites?: boolean | undefined;
+            avatarUpload?: boolean | undefined;
+            browser?: boolean | undefined;
+            model?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+    configuration?: {
+        agent?: {
+            [x: string]: unknown;
+            models?: {
+                allowed?: ({
+                    provider: string;
+                    modelId?: string | undefined;
+                } | {
+                    kind: "custom";
+                    provider: string;
+                    modelId?: string | undefined;
+                })[] | undefined;
+                default?: {
+                    provider: string;
+                    modelId: string;
+                } | {
+                    kind: "custom";
+                    provider: string;
+                    modelId: string;
+                } | undefined;
+            } | undefined;
+            tools?: {
+                allowed?: string[] | undefined;
+            } | undefined;
+            agents?: {
+                allowed?: string[] | undefined;
+            } | undefined;
+            workflows?: {
+                allowed?: string[] | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+    modelPolicy?: {
+        active: boolean;
+        pickerVisible?: boolean | undefined;
+        allowed?: ({
+            provider: string;
+            modelId?: string | undefined;
+        } | {
+            kind: "custom";
+            provider: string;
+            modelId?: string | undefined;
+        })[] | undefined;
+        default?: {
+            provider: string;
+            modelId: string;
+        } | {
+            kind: "custom";
+            provider: string;
+            modelId: string;
+        } | undefined;
+    } | undefined;
+    picker?: {
+        visibleTools: string[] | null;
+        visibleAgents: string[] | null;
+        visibleWorkflows: string[] | null;
+    } | undefined;
+    modelPolicyWarnings?: string[] | undefined;
+}, "json", import("../server-adapter").RouteSchemas<undefined, undefined, undefined, import("zod").ZodObject<{
+    enabled: import("zod").ZodBoolean;
+    features: import("zod").ZodOptional<import("zod").ZodObject<{
+        agent: import("zod").ZodOptional<import("zod").ZodObject<{
+            tools: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            agents: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            workflows: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            scorers: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            skills: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            memory: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            variables: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            favorites: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            avatarUpload: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            browser: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            model: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    configuration: import("zod").ZodOptional<import("zod").ZodObject<{
+        agent: import("zod").ZodOptional<import("zod").ZodObject<{
+            models: import("zod").ZodOptional<import("zod").ZodObject<{
+                allowed: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"custom">;
+                    provider: import("zod").ZodString;
+                    modelId: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    provider: import("zod").ZodString;
+                    modelId: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>]>>>;
+                default: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"custom">;
+                    provider: import("zod").ZodString;
+                    modelId: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                    provider: import("zod").ZodString;
+                    modelId: import("zod").ZodString;
+                }, import("zod/v4/core").$strict>]>>;
+            }, import("zod/v4/core").$strip>>;
+            tools: import("zod").ZodOptional<import("zod").ZodObject<{
+                allowed: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strict>>;
+            agents: import("zod").ZodOptional<import("zod").ZodObject<{
+                allowed: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strict>>;
+            workflows: import("zod").ZodOptional<import("zod").ZodObject<{
+                allowed: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$catchall<import("zod").ZodUnknown>>>;
+    }, import("zod/v4/core").$strip>>;
+    modelPolicy: import("zod").ZodOptional<import("zod").ZodObject<{
+        active: import("zod").ZodBoolean;
+        pickerVisible: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        allowed: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"custom">;
+            provider: import("zod").ZodString;
+            modelId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            provider: import("zod").ZodString;
+            modelId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strict>]>>>;
+        default: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"custom">;
+            provider: import("zod").ZodString;
+            modelId: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            provider: import("zod").ZodString;
+            modelId: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>]>>;
+    }, import("zod/v4/core").$strip>>;
+    picker: import("zod").ZodOptional<import("zod").ZodObject<{
+        visibleTools: import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodString>>;
+        visibleAgents: import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodString>>;
+        visibleWorkflows: import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strip>>;
+    modelPolicyWarnings: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>>, "GET", "/editor/builder/settings">;
+/**
+ * GET /editor/builder/infrastructure
+ *
+ * Returns the runtime status of Mastra-opinionated primitives (channels,
+ * browser providers, workspaces). Admin-only; surfaced in Studio Settings so
+ * admins can sanity-check what's wired up to the running server.
+ */
+export declare const GET_INFRASTRUCTURE_STATUS_ROUTE: import("../server-adapter").ServerRoute<{}, {
+    channels: {
+        providers: {
+            id: string;
+            name: string;
+            isConfigured: boolean;
+            routeCount: number;
+        }[];
+    };
+    browser: {
+        type: string | null;
+        provider: string | null;
+        env: string | null;
+        registered: boolean;
+        availableProviders: string[];
+        config: {
+            key: string;
+            value: string;
+        }[];
+    };
+    workspace: {
+        type: string | null;
+        workspaceId: string | null;
+        name: string | null;
+        source: string | null;
+        registered: boolean;
+        hasFilesystem: boolean;
+        hasSandbox: boolean;
+        filesystemProvider: string | null;
+        sandboxProvider: string | null;
+        config: {
+            key: string;
+            value: string;
+        }[];
+    };
+    registries: {
+        skillsSh: {
+            enabled: boolean;
+        };
+    };
+}, "json", import("../server-adapter").RouteSchemas<undefined, undefined, undefined, import("zod").ZodObject<{
+    channels: import("zod").ZodObject<{
+        providers: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            name: import("zod").ZodString;
+            isConfigured: import("zod").ZodBoolean;
+            routeCount: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    browser: import("zod").ZodObject<{
+        type: import("zod").ZodNullable<import("zod").ZodString>;
+        provider: import("zod").ZodNullable<import("zod").ZodString>;
+        env: import("zod").ZodNullable<import("zod").ZodString>;
+        registered: import("zod").ZodBoolean;
+        availableProviders: import("zod").ZodArray<import("zod").ZodString>;
+        config: import("zod").ZodArray<import("zod").ZodObject<{
+            key: import("zod").ZodString;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    workspace: import("zod").ZodObject<{
+        type: import("zod").ZodNullable<import("zod").ZodString>;
+        workspaceId: import("zod").ZodNullable<import("zod").ZodString>;
+        name: import("zod").ZodNullable<import("zod").ZodString>;
+        source: import("zod").ZodNullable<import("zod").ZodString>;
+        registered: import("zod").ZodBoolean;
+        hasFilesystem: import("zod").ZodBoolean;
+        hasSandbox: import("zod").ZodBoolean;
+        filesystemProvider: import("zod").ZodNullable<import("zod").ZodString>;
+        sandboxProvider: import("zod").ZodNullable<import("zod").ZodString>;
+        config: import("zod").ZodArray<import("zod").ZodObject<{
+            key: import("zod").ZodString;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    registries: import("zod").ZodObject<{
+        skillsSh: import("zod").ZodObject<{
+            enabled: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>>, "GET", "/editor/builder/infrastructure">;
+//# sourceMappingURL=editor-builder.d.ts.map

package/dist/server/handlers/editor-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-builder.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/editor-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAS3C,OAAO,KAAK,EAAE,aAAa,EAAwB,MAAM,2BAA2B,CAAC;AAqBrF;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAG5G;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAIvG;AAED;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEA+G5C,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAkJ1C,CAAC"}

package/dist/server/handlers/editor-builder.js

@@ -0,0 +1,3 @@
+export { GET_EDITOR_BUILDER_SETTINGS_ROUTE, GET_INFRASTRUCTURE_STATUS_ROUTE, isBuilderFeatureEnabled, requireBuilderFeature } from '../../chunk-6JCLSYOU.js';
+//# sourceMappingURL=editor-builder.js.map
+//# sourceMappingURL=editor-builder.js.map

package/dist/server/handlers/editor-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"editor-builder.js"}

package/dist/server/handlers/error.cjs

@@ -1,16 +1,16 @@
 'use strict';
 
-var chunkB34S64RC_cjs = require('../../chunk-B34S64RC.cjs');
+var chunkYNSUYESL_cjs = require('../../chunk-YNSUYESL.cjs');
 
 
 
 Object.defineProperty(exports, "formatZodError", {
   enumerable: true,
-  get: function () { return chunkB34S64RC_cjs.formatZodError; }
+  get: function () { return chunkYNSUYESL_cjs.formatZodError; }
 });
 Object.defineProperty(exports, "handleError", {
   enumerable: true,
-  get: function () { return chunkB34S64RC_cjs.handleError; }
+  get: function () { return chunkYNSUYESL_cjs.handleError; }
 });
 //# sourceMappingURL=error.cjs.map
 //# sourceMappingURL=error.cjs.map

package/dist/server/handlers/error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/error.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,UAAU,YAAY;IACpB,MAAM,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,WAAW,EAAE,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;CACJ;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,MAAM,GACd;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAUtE;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,KAAK,CAUzE"}
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/error.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,UAAU,YAAY;IACpB,MAAM,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,WAAW,EAAE,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;CACJ;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,MAAM,GACd;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAUtE;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,KAAK,CA+BzE"}

package/dist/server/handlers/error.js

@@ -1,3 +1,3 @@
-export { formatZodError, handleError } from '../../chunk-P23KBWKB.js';
+export { formatZodError, handleError } from '../../chunk-GA4BG5JK.js';
 //# sourceMappingURL=error.js.map
 //# sourceMappingURL=error.js.map

package/dist/server/handlers/favorites-enrichment.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var chunkV4ATNZXG_cjs = require('../../chunk-V4ATNZXG.cjs');
+
+
+
+Object.defineProperty(exports, "prepareFavoritesEnrichment", {
+  enumerable: true,
+  get: function () { return chunkV4ATNZXG_cjs.prepareFavoritesEnrichment; }
+});
+Object.defineProperty(exports, "stripFavoriteFields", {
+  enumerable: true,
+  get: function () { return chunkV4ATNZXG_cjs.stripFavoriteFields; }
+});
+//# sourceMappingURL=favorites-enrichment.cjs.map
+//# sourceMappingURL=favorites-enrichment.cjs.map

package/dist/server/handlers/favorites-enrichment.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"favorites-enrichment.cjs"}

package/dist/server/handlers/favorites-enrichment.d.ts

@@ -0,0 +1,27 @@
+import type { Mastra } from '@mastra/core';
+import type { RequestContext } from '@mastra/core/di';
+import type { FavoritesStorage, StorageFavoriteEntityType } from '@mastra/core/storage';
+/**
+ * Result of `prepareFavoritesEnrichment` — `null` when the `favorites` EE feature is off.
+ * When non-null the caller may use `starredIds` to set `isFavorited` on records
+ * and may pass `userId` along to storage list paths for pin-favorited-first
+ * sorting (`pinFavoritedFor`).
+ */
+export type FavoritesEnrichmentContext = {
+    userId: string;
+    starredIds: Set<string>;
+    favoritesStore: FavoritesStorage;
+} | null;
+/**
+ * Resolve the EE feature flag plus the caller's favorited set for a list of
+ * candidate entity IDs in one shot. Soft-gated: returns `null` if the feature
+ * is off or there's no caller — handlers should drop `isFavorited` / `favoriteCount`
+ * fields and ignore `?favoritedOnly=true` in that case.
+ */
+export declare function prepareFavoritesEnrichment(mastra: Mastra, requestContext: RequestContext, entityType: StorageFavoriteEntityType, entityIds: string[]): Promise<FavoritesEnrichmentContext>;
+/**
+ * Strip the favorites EE fields from a record. Used when the feature is off so
+ * stale values from storage do not leak through the API.
+ */
+export declare function stripFavoriteFields<T extends object>(record: T): T;
+//# sourceMappingURL=favorites-enrichment.d.ts.map

package/dist/server/handlers/favorites-enrichment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"favorites-enrichment.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/favorites-enrichment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAKxF;;;;;GAKG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACxB,cAAc,EAAE,gBAAgB,CAAC;CAClC,GAAG,IAAI,CAAC;AAET;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,cAAc,EAC9B,UAAU,EAAE,yBAAyB,EACrC,SAAS,EAAE,MAAM,EAAE,GAClB,OAAO,CAAC,0BAA0B,CAAC,CAgBrC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAQlE"}

package/dist/server/handlers/favorites-enrichment.js

@@ -0,0 +1,3 @@
+export { prepareFavoritesEnrichment, stripFavoriteFields } from '../../chunk-JUYUBEMU.js';
+//# sourceMappingURL=favorites-enrichment.js.map
+//# sourceMappingURL=favorites-enrichment.js.map

package/dist/server/handlers/favorites-enrichment.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"favorites-enrichment.js"}

package/dist/server/handlers/logs.cjs

@@ -1,20 +1,20 @@
 'use strict';
 
-var chunkES23WZRF_cjs = require('../../chunk-ES23WZRF.cjs');
+var chunkLEIV627E_cjs = require('../../chunk-LEIV627E.cjs');
 
 
 
 Object.defineProperty(exports, "LIST_LOGS_BY_RUN_ID_ROUTE", {
   enumerable: true,
-  get: function () { return chunkES23WZRF_cjs.LIST_LOGS_BY_RUN_ID_ROUTE; }
+  get: function () { return chunkLEIV627E_cjs.LIST_LOGS_BY_RUN_ID_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_LOGS_ROUTE", {
   enumerable: true,
-  get: function () { return chunkES23WZRF_cjs.LIST_LOGS_ROUTE; }
+  get: function () { return chunkLEIV627E_cjs.LIST_LOGS_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_LOG_TRANSPORTS_ROUTE", {
   enumerable: true,
-  get: function () { return chunkES23WZRF_cjs.LIST_LOG_TRANSPORTS_ROUTE; }
+  get: function () { return chunkLEIV627E_cjs.LIST_LOG_TRANSPORTS_ROUTE; }
 });
 //# sourceMappingURL=logs.cjs.map
 //# sourceMappingURL=logs.cjs.map

package/dist/server/handlers/logs.js

@@ -1,3 +1,3 @@
-export { LIST_LOGS_BY_RUN_ID_ROUTE, LIST_LOGS_ROUTE, LIST_LOG_TRANSPORTS_ROUTE } from '../../chunk-N44OOOAL.js';
+export { LIST_LOGS_BY_RUN_ID_ROUTE, LIST_LOGS_ROUTE, LIST_LOG_TRANSPORTS_ROUTE } from '../../chunk-6GMGCV74.js';
 //# sourceMappingURL=logs.js.map
 //# sourceMappingURL=logs.js.map

package/dist/server/handlers/mcp-client-versions.cjs

@@ -1,36 +1,36 @@
 'use strict';
 
-var chunkJRFHBWKQ_cjs = require('../../chunk-JRFHBWKQ.cjs');
+var chunkAY3ZP465_cjs = require('../../chunk-AY3ZP465.cjs');
 
 
 
 Object.defineProperty(exports, "ACTIVATE_MCP_CLIENT_VERSION_ROUTE", {
   enumerable: true,
-  get: function () { return chunkJRFHBWKQ_cjs.ACTIVATE_MCP_CLIENT_VERSION_ROUTE; }
+  get: function () { return chunkAY3ZP465_cjs.ACTIVATE_MCP_CLIENT_VERSION_ROUTE; }
 });
 Object.defineProperty(exports, "COMPARE_MCP_CLIENT_VERSIONS_ROUTE", {
   enumerable: true,
-  get: function () { return chunkJRFHBWKQ_cjs.COMPARE_MCP_CLIENT_VERSIONS_ROUTE; }
+  get: function () { return chunkAY3ZP465_cjs.COMPARE_MCP_CLIENT_VERSIONS_ROUTE; }
 });
 Object.defineProperty(exports, "CREATE_MCP_CLIENT_VERSION_ROUTE", {
   enumerable: true,
-  get: function () { return chunkJRFHBWKQ_cjs.CREATE_MCP_CLIENT_VERSION_ROUTE; }
+  get: function () { return chunkAY3ZP465_cjs.CREATE_MCP_CLIENT_VERSION_ROUTE; }
 });
 Object.defineProperty(exports, "DELETE_MCP_CLIENT_VERSION_ROUTE", {
   enumerable: true,
-  get: function () { return chunkJRFHBWKQ_cjs.DELETE_MCP_CLIENT_VERSION_ROUTE; }
+  get: function () { return chunkAY3ZP465_cjs.DELETE_MCP_CLIENT_VERSION_ROUTE; }
 });
 Object.defineProperty(exports, "GET_MCP_CLIENT_VERSION_ROUTE", {
   enumerable: true,
-  get: function () { return chunkJRFHBWKQ_cjs.GET_MCP_CLIENT_VERSION_ROUTE; }
+  get: function () { return chunkAY3ZP465_cjs.GET_MCP_CLIENT_VERSION_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_MCP_CLIENT_VERSIONS_ROUTE", {
   enumerable: true,
-  get: function () { return chunkJRFHBWKQ_cjs.LIST_MCP_CLIENT_VERSIONS_ROUTE; }
+  get: function () { return chunkAY3ZP465_cjs.LIST_MCP_CLIENT_VERSIONS_ROUTE; }
 });
 Object.defineProperty(exports, "RESTORE_MCP_CLIENT_VERSION_ROUTE", {
   enumerable: true,
-  get: function () { return chunkJRFHBWKQ_cjs.RESTORE_MCP_CLIENT_VERSION_ROUTE; }
+  get: function () { return chunkAY3ZP465_cjs.RESTORE_MCP_CLIENT_VERSION_ROUTE; }
 });
 //# sourceMappingURL=mcp-client-versions.cjs.map
 //# sourceMappingURL=mcp-client-versions.cjs.map

package/dist/server/handlers/mcp-client-versions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-client-versions.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/mcp-client-versions.ts"],"names":[],"mappings":"AA4BA;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sFAyCzC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uFAoF1C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iGAwCvC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;2GAwD5C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0GAyF3C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;oGAyD1C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8FAgE5C,CAAC"}
+{"version":3,"file":"mcp-client-versions.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/mcp-client-versions.ts"],"names":[],"mappings":"AA6BA;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sFA0CzC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uFAqF1C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iGA0CvC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;2GAyD5C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0GA0F3C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;oGA0D1C,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8FAkE5C,CAAC"}

package/dist/server/handlers/mcp-client-versions.js

@@ -1,3 +1,3 @@
-export { ACTIVATE_MCP_CLIENT_VERSION_ROUTE, COMPARE_MCP_CLIENT_VERSIONS_ROUTE, CREATE_MCP_CLIENT_VERSION_ROUTE, DELETE_MCP_CLIENT_VERSION_ROUTE, GET_MCP_CLIENT_VERSION_ROUTE, LIST_MCP_CLIENT_VERSIONS_ROUTE, RESTORE_MCP_CLIENT_VERSION_ROUTE } from '../../chunk-MXGCIYNM.js';
+export { ACTIVATE_MCP_CLIENT_VERSION_ROUTE, COMPARE_MCP_CLIENT_VERSIONS_ROUTE, CREATE_MCP_CLIENT_VERSION_ROUTE, DELETE_MCP_CLIENT_VERSION_ROUTE, GET_MCP_CLIENT_VERSION_ROUTE, LIST_MCP_CLIENT_VERSIONS_ROUTE, RESTORE_MCP_CLIENT_VERSION_ROUTE } from '../../chunk-XI3XH4G7.js';
 //# sourceMappingURL=mcp-client-versions.js.map
 //# sourceMappingURL=mcp-client-versions.js.map

package/dist/server/handlers/mcp.cjs

@@ -1,48 +1,48 @@
 'use strict';
 
-var chunkXHA6OBT3_cjs = require('../../chunk-XHA6OBT3.cjs');
+var chunk4UFLVROK_cjs = require('../../chunk-4UFLVROK.cjs');
 
 
 
 Object.defineProperty(exports, "EXECUTE_MCP_SERVER_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkXHA6OBT3_cjs.EXECUTE_MCP_SERVER_TOOL_ROUTE; }
+  get: function () { return chunk4UFLVROK_cjs.EXECUTE_MCP_SERVER_TOOL_ROUTE; }
 });
 Object.defineProperty(exports, "GET_MCP_SERVER_DETAIL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkXHA6OBT3_cjs.GET_MCP_SERVER_DETAIL_ROUTE; }
+  get: function () { return chunk4UFLVROK_cjs.GET_MCP_SERVER_DETAIL_ROUTE; }
 });
 Object.defineProperty(exports, "GET_MCP_SERVER_TOOL_DETAIL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkXHA6OBT3_cjs.GET_MCP_SERVER_TOOL_DETAIL_ROUTE; }
+  get: function () { return chunk4UFLVROK_cjs.GET_MCP_SERVER_TOOL_DETAIL_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_MCP_SERVERS_ROUTE", {
   enumerable: true,
-  get: function () { return chunkXHA6OBT3_cjs.LIST_MCP_SERVERS_ROUTE; }
+  get: function () { return chunk4UFLVROK_cjs.LIST_MCP_SERVERS_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_MCP_SERVER_RESOURCES_ROUTE", {
   enumerable: true,
-  get: function () { return chunkXHA6OBT3_cjs.LIST_MCP_SERVER_RESOURCES_ROUTE; }
+  get: function () { return chunk4UFLVROK_cjs.LIST_MCP_SERVER_RESOURCES_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_MCP_SERVER_TOOLS_ROUTE", {
   enumerable: true,
-  get: function () { return chunkXHA6OBT3_cjs.LIST_MCP_SERVER_TOOLS_ROUTE; }
+  get: function () { return chunk4UFLVROK_cjs.LIST_MCP_SERVER_TOOLS_ROUTE; }
 });
 Object.defineProperty(exports, "MCP_HTTP_TRANSPORT_ROUTE", {
   enumerable: true,
-  get: function () { return chunkXHA6OBT3_cjs.MCP_HTTP_TRANSPORT_ROUTE; }
+  get: function () { return chunk4UFLVROK_cjs.MCP_HTTP_TRANSPORT_ROUTE; }
 });
 Object.defineProperty(exports, "MCP_SSE_MESSAGES_ROUTE", {
   enumerable: true,
-  get: function () { return chunkXHA6OBT3_cjs.MCP_SSE_MESSAGES_ROUTE; }
+  get: function () { return chunk4UFLVROK_cjs.MCP_SSE_MESSAGES_ROUTE; }
 });
 Object.defineProperty(exports, "MCP_SSE_TRANSPORT_ROUTE", {
   enumerable: true,
-  get: function () { return chunkXHA6OBT3_cjs.MCP_SSE_TRANSPORT_ROUTE; }
+  get: function () { return chunk4UFLVROK_cjs.MCP_SSE_TRANSPORT_ROUTE; }
 });
 Object.defineProperty(exports, "READ_MCP_SERVER_RESOURCE_ROUTE", {
   enumerable: true,
-  get: function () { return chunkXHA6OBT3_cjs.READ_MCP_SERVER_RESOURCE_ROUTE; }
+  get: function () { return chunk4UFLVROK_cjs.READ_MCP_SERVER_RESOURCE_ROUTE; }
 });
 //# sourceMappingURL=mcp.cjs.map
 //# sourceMappingURL=mcp.cjs.map

package/dist/server/handlers/mcp.js

@@ -1,3 +1,3 @@
-export { EXECUTE_MCP_SERVER_TOOL_ROUTE, GET_MCP_SERVER_DETAIL_ROUTE, GET_MCP_SERVER_TOOL_DETAIL_ROUTE, LIST_MCP_SERVERS_ROUTE, LIST_MCP_SERVER_RESOURCES_ROUTE, LIST_MCP_SERVER_TOOLS_ROUTE, MCP_HTTP_TRANSPORT_ROUTE, MCP_SSE_MESSAGES_ROUTE, MCP_SSE_TRANSPORT_ROUTE, READ_MCP_SERVER_RESOURCE_ROUTE } from '../../chunk-LBEQ4EE4.js';
+export { EXECUTE_MCP_SERVER_TOOL_ROUTE, GET_MCP_SERVER_DETAIL_ROUTE, GET_MCP_SERVER_TOOL_DETAIL_ROUTE, LIST_MCP_SERVERS_ROUTE, LIST_MCP_SERVER_RESOURCES_ROUTE, LIST_MCP_SERVER_TOOLS_ROUTE, MCP_HTTP_TRANSPORT_ROUTE, MCP_SSE_MESSAGES_ROUTE, MCP_SSE_TRANSPORT_ROUTE, READ_MCP_SERVER_RESOURCE_ROUTE } from '../../chunk-SPGVPADY.js';
 //# sourceMappingURL=mcp.js.map
 //# sourceMappingURL=mcp.js.map