@mastra/server 1.67.0-alpha.3 → 1.67.0-alpha.4

package/dist/server/handlers/logs.cjs

@@ -3,7 +3,7 @@ const require_rolldown_runtime = require("../../rolldown-runtime-Bd6kNlEP.cjs");
 const require_common = require("../../common-DQn8jX5T.cjs");
 const require_route_builder = require("../../route-builder-DupY8fkI.cjs");
 const require_server_handlers_error = require("./error.cjs");
-const require_utils = require("../../utils-BtkczLrA.cjs");
+const require_utils = require("../../utils-aIu3gkhJ.cjs");
 const require_logs = require("../../logs-BDuGFqxu.cjs");
 //#region src/server/handlers/logs.ts
 var logs_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({

package/dist/server/handlers/logs.js

@@ -2,7 +2,7 @@ import { r as __exportAll } from "../../rolldown-runtime-maW3aOIk.js";
 import { l as runIdSchema } from "../../common-5ZZuR6wj.js";
 import { n as createRoute } from "../../route-builder-BukcT_Kp.js";
 import { handleError } from "./error.js";
-import { a as parseFilters, l as validateBody } from "../../utils-CMWGBd0O.js";
+import { o as parseFilters, u as validateBody } from "../../utils-KsERfbhc.js";
 import { n as listLogsQuerySchema, r as listLogsResponseSchema, t as listLogTransportsResponseSchema } from "../../logs-Cz5NiwGP.js";
 //#region src/server/handlers/logs.ts
 var logs_exports = /* @__PURE__ */ __exportAll({

package/dist/server/handlers/memory.cjs

@@ -3,7 +3,7 @@ const require_rolldown_runtime = require("../../rolldown-runtime-Bd6kNlEP.cjs");
 const require_http_exception = require("../../http-exception-CKDHupKw.cjs");
 const require_route_builder = require("../../route-builder-DupY8fkI.cjs");
 const require_server_handlers_error = require("./error.cjs");
-const require_utils = require("../../utils-BtkczLrA.cjs");
+const require_utils = require("../../utils-aIu3gkhJ.cjs");
 const require_memory = require("../../memory-CE6rUGmo.cjs");
 const require_server_handlers_gateway_memory_client = require("./gateway-memory-client.cjs");
 let _mastra_core_agent = require("@mastra/core/agent");

package/dist/server/handlers/memory.js

@@ -2,7 +2,7 @@ import { r as __exportAll } from "../../rolldown-runtime-maW3aOIk.js";
 import { t as HTTPException } from "../../http-exception-CyfxZB6W.js";
 import { n as createRoute } from "../../route-builder-BukcT_Kp.js";
 import { handleError } from "./error.js";
-import { f as MastraFGAPermissions, i as getEffectiveThreadId, l as validateBody, n as getContextResourceId, r as getEffectiveResourceId, t as enforceThreadAccess } from "../../utils-CMWGBd0O.js";
+import { i as getEffectiveThreadId, n as getContextResourceId, p as MastraFGAPermissions, r as getEffectiveResourceId, t as enforceThreadAccess, u as validateBody } from "../../utils-KsERfbhc.js";
 import { A as listThreadsNetworkQuerySchema, B as searchMemoryQuerySchema, C as getThreadByIdResponseSchema, D as listMessagesNetworkQuerySchema, G as updateThreadBodySchema, H as threadIdPathParams, I as optionalAgentIdQuerySchema, J as updateWorkingMemoryResponseSchema, K as updateThreadNetworkQuerySchema, L as saveMessagesBodySchema, M as listThreadsResponseSchema, N as memoryConfigResponseSchema, O as listMessagesQuerySchema, P as memoryStatusResponseSchema, R as saveMessagesNetworkQuerySchema, S as getThreadByIdQuerySchema, T as getWorkingMemoryResponseSchema, U as transferThreadBodySchema, V as searchMemoryResponseSchema, W as transferThreadResponseSchema, _ as getMemoryStatusNetworkQuerySchema, a as cloneThreadResponseSchema, b as getObservationalMemoryResponseSchema, c as deleteMessagesBodySchema, d as deleteMessagesResponseSchema, f as deleteThreadNetworkQuerySchema, g as getMemoryConfigQuerySchema, i as cloneThreadBodySchema, j as listThreadsQuerySchema, k as listMessagesResponseSchema, l as deleteMessagesNetworkQuerySchema, m as deleteThreadResponseSchema, n as awaitBufferStatusBodySchema, o as createThreadBodySchema, p as deleteThreadQuerySchema, q as updateWorkingMemoryBodySchema, r as awaitBufferStatusResponseSchema, s as createThreadNetworkQuerySchema, t as agentIdQuerySchema, u as deleteMessagesQuerySchema, v as getMemoryStatusQuerySchema, w as getWorkingMemoryQuerySchema, x as getThreadByIdNetworkQuerySchema, y as getObservationalMemoryQuerySchema, z as saveMessagesResponseSchema } from "../../memory-Cp3Yo-OX.js";
 import { getGatewayClient, isGatewayAgentAsync, toLocalMessage, toLocalOMRecord, toLocalThread } from "./gateway-memory-client.js";
 import { Agent } from "@mastra/core/agent";

package/dist/server/handlers/plans.cjs

@@ -4,7 +4,7 @@ const require_http_exception = require("../../http-exception-CKDHupKw.cjs");
 const require_agents = require("../../agents-C3k-sZBO.cjs");
 const require_route_builder = require("../../route-builder-DupY8fkI.cjs");
 const require_server_handlers_error = require("./error.cjs");
-const require_utils = require("../../utils-BtkczLrA.cjs");
+const require_utils = require("../../utils-aIu3gkhJ.cjs");
 const require_server_handlers_agents = require("./agents.cjs");
 let _mastra_core_tools = require("@mastra/core/tools");
 //#region src/server/handlers/plans.ts

package/dist/server/handlers/plans.js

@@ -3,7 +3,7 @@ import { t as HTTPException } from "../../http-exception-CyfxZB6W.js";
 import { a as agentIdPathParams, o as agentPlanQuerySchema, s as agentPlanResponseSchema } from "../../agents-AMeMJBI1.js";
 import { n as createRoute } from "../../route-builder-BukcT_Kp.js";
 import { handleError } from "./error.js";
-import { f as MastraFGAPermissions } from "../../utils-CMWGBd0O.js";
+import { p as MastraFGAPermissions } from "../../utils-KsERfbhc.js";
 import { getAgentFromSystem } from "./agents.js";
 import { submitPlanTool } from "@mastra/core/tools";
 //#region src/server/handlers/plans.ts

package/dist/server/handlers/responses.cjs

@@ -3,7 +3,7 @@ const require_rolldown_runtime = require("../../rolldown-runtime-Bd6kNlEP.cjs");
 const require_http_exception = require("../../http-exception-CKDHupKw.cjs");
 const require_route_builder = require("../../route-builder-DupY8fkI.cjs");
 const require_server_handlers_error = require("./error.cjs");
-const require_utils = require("../../utils-BtkczLrA.cjs");
+const require_utils = require("../../utils-aIu3gkhJ.cjs");
 const require_server_handlers_agents = require("./agents.cjs");
 const require_responses = require("../../responses-CKNdSRkS.cjs");
 const require_server_handlers_responses_adapter = require("./responses.adapter.cjs");

package/dist/server/handlers/responses.d.ts

@@ -187,6 +187,17 @@ export declare const GET_RESPONSE_ROUTE: Omit<import("@mastra/core/server").ApiR
         model: string;
         status: "completed" | "in_progress" | "incomplete";
         output: ({
+            id: string;
+            type: "message";
+            role: "assistant";
+            status: "completed" | "in_progress" | "incomplete";
+            content: {
+                type: "output_text";
+                text: string;
+                annotations?: unknown[] | undefined;
+                logprobs?: unknown[] | undefined;
+            }[];
+        } | {
             id: string;
             type: "function_call";
             call_id: string;
@@ -198,17 +209,6 @@ export declare const GET_RESPONSE_ROUTE: Omit<import("@mastra/core/server").ApiR
             type: "function_call_output";
             call_id: string;
             output: string;
-        } | {
-            id: string;
-            type: "message";
-            role: "assistant";
-            status: "completed" | "in_progress" | "incomplete";
-            content: {
-                type: "output_text";
-                text: string;
-                annotations?: unknown[] | undefined;
-                logprobs?: unknown[] | undefined;
-            }[];
         })[];
         usage: {
             input_tokens: number;

package/dist/server/handlers/responses.js

@@ -2,7 +2,7 @@ import { r as __exportAll } from "../../rolldown-runtime-maW3aOIk.js";
 import { t as HTTPException } from "../../http-exception-CyfxZB6W.js";
 import { n as createRoute } from "../../route-builder-BukcT_Kp.js";
 import { handleError } from "./error.js";
-import { f as MastraFGAPermissions, i as getEffectiveThreadId, r as getEffectiveResourceId, t as enforceThreadAccess } from "../../utils-CMWGBd0O.js";
+import { i as getEffectiveThreadId, p as MastraFGAPermissions, r as getEffectiveResourceId, t as enforceThreadAccess } from "../../utils-KsERfbhc.js";
 import { getAgentFromSystem } from "./agents.js";
 import { a as deleteResponseSchema, i as createResponseBodySchema, o as responseIdPathParams, u as responseObjectSchema } from "../../responses-DJNJgCTg.js";
 import { buildCompletedResponse, buildInProgressResponse, createMessageId, createOutputTextPart, createResponseStreamEventTranslator, formatSseEvent, mapMastraToolsToResponseTools, mapResponseInputToExecutionMessages, mapResponseTurnRecordToResponse, toResponseStatus, toResponseUsage } from "./responses.adapter.js";

package/dist/server/handlers/responses.storage.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../../rolldown-runtime-Bd6kNlEP.cjs");
 const require_http_exception = require("../../http-exception-CKDHupKw.cjs");
-const require_utils = require("../../utils-BtkczLrA.cjs");
+const require_utils = require("../../utils-aIu3gkhJ.cjs");
 //#region src/server/handlers/responses.storage.ts
 function isPlainObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/server/handlers/responses.storage.js

@@ -1,5 +1,5 @@
 import { t as HTTPException } from "../../http-exception-CyfxZB6W.js";
-import { d as validateThreadOwnership, r as getEffectiveResourceId } from "../../utils-CMWGBd0O.js";
+import { f as validateThreadOwnership, r as getEffectiveResourceId } from "../../utils-KsERfbhc.js";
 //#region src/server/handlers/responses.storage.ts
 function isPlainObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/server/handlers/system.cjs

@@ -88,7 +88,7 @@ const GET_API_SCHEMA_ROUTE = require_route_builder.createRoute({
 	tags: ["System"],
 	requiresAuth: true,
 	handler: async () => {
-		const { buildApiSchemaManifest } = await Promise.resolve().then(() => require("../../api-schema-manifest-1LriOYQM.cjs"));
+		const { buildApiSchemaManifest } = await Promise.resolve().then(() => require("../../api-schema-manifest-nIt4xi1r.cjs"));
 		return buildApiSchemaManifest();
 	}
 });

package/dist/server/handlers/system.js

@@ -86,7 +86,7 @@ const GET_API_SCHEMA_ROUTE = createRoute({
 	tags: ["System"],
 	requiresAuth: true,
 	handler: async () => {
-		const { buildApiSchemaManifest } = await import("../../api-schema-manifest-DNk8B4kw.js");
+		const { buildApiSchemaManifest } = await import("../../api-schema-manifest-B8uyCfJp.js");
 		return buildApiSchemaManifest();
 	}
 });

package/dist/server/handlers/tools.cjs

@@ -8,7 +8,7 @@ const require_route_builder = require("../../route-builder-DupY8fkI.cjs");
 require("../../schema-C7CvwM1d.cjs");
 const require_utils = require("../../utils-WcR0QSUB.cjs");
 const require_server_handlers_error = require("./error.cjs");
-const require_utils$1 = require("../../utils-BtkczLrA.cjs");
+const require_utils$1 = require("../../utils-aIu3gkhJ.cjs");
 const require_server_handlers_tool_schema_overrides = require("./tool-schema-overrides.cjs");
 const require_server_handlers_agents = require("./agents.cjs");
 let _mastra_core_tools = require("@mastra/core/tools");

package/dist/server/handlers/tools.js

@@ -7,7 +7,7 @@ import { n as createRoute } from "../../route-builder-BukcT_Kp.js";
 import "../../schema-BF_cZG0Y.js";
 import { l as stringify } from "../../utils-Duk4hfT_.js";
 import { handleError } from "./error.js";
-import { f as MastraFGAPermissions, l as validateBody } from "../../utils-CMWGBd0O.js";
+import { p as MastraFGAPermissions, u as validateBody } from "../../utils-KsERfbhc.js";
 import { stripInjectedToolOverrideFields } from "./tool-schema-overrides.js";
 import { getAgentFromSystem } from "./agents.js";
 import { isProviderDefinedTool, isVercelTool } from "@mastra/core/tools";

package/dist/server/handlers/utils.cjs

@@ -1,10 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../../rolldown-runtime-Bd6kNlEP.cjs");
-const require_utils = require("../../utils-BtkczLrA.cjs");
+const require_utils = require("../../utils-aIu3gkhJ.cjs");
 exports.enforceThreadAccess = require_utils.enforceThreadAccess;
 exports.getContextResourceId = require_utils.getContextResourceId;
 exports.getEffectiveResourceId = require_utils.getEffectiveResourceId;
 exports.getEffectiveThreadId = require_utils.getEffectiveThreadId;
+exports.mergeBodyRequestContext = require_utils.mergeBodyRequestContext;
 exports.parseFilters = require_utils.parseFilters;
 exports.parsePerPage = require_utils.parsePerPage;
 exports.requireEffectiveResourceId = require_utils.requireEffectiveResourceId;

package/dist/server/handlers/utils.d.ts

@@ -12,6 +12,12 @@ export declare function parsePerPage(value: string | undefined, defaultValue?: n
  * Parses filter query parameters into a key-value object.
  */
 export declare function parseFilters(filters: string | string[] | undefined): Record<string, string> | undefined;
+/**
+ * Merges a body-supplied requestContext into the trusted server RequestContext.
+ * The server context is authoritative: reserved keys are skipped and body values
+ * only fill keys the server context has not already set.
+ */
+export declare function mergeBodyRequestContext(serverRequestContext: RequestContext, bodyRequestContext: unknown): void;
 /**
  * Gets the effective resourceId, preferring the reserved key from requestContext
  * over client-provided values for security.

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAOtD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAWzD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,EAAE,MAAM,EAAE,QAMnF;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,YAAY,GAAE,MAAY,EAC1B,GAAG,GAAE,MAAa,GACjB,MAAM,GAAG,KAAK,CAShB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAUvG;AAMD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,gBAAgB,EAAE,MAAM,GAAG,SAAS,GACnC,MAAM,GAAG,SAAS,CAGpB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,cAAc,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAEnG;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,OAAO,CAAC,mBAAmB,IAAI,MAAM,CAOvC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,MAAM,GAAG,SAAS,CAGpB;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EACzD,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,OAAO,CAAC,IAAI,CAAC,CAIf;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,EACxC,MAAM,EACN,cAAc,EACd,QAAQ,EACR,MAAM,EACN,mBAAmB,EACnB,UAA6C,GAC9C,EAAE;IACD,MAAM,EAAE,GAAG,CAAC;IACZ,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;IAC/C,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,UAAU,CAAC,EAAE,wBAAwB,CAAC;CACvC,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBhB;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EACtD,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,OAAO,CAAC,IAAI,CAAC,CAIf"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAOtD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAWzD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,EAAE,MAAM,EAAE,QAMnF;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,YAAY,GAAE,MAAY,EAC1B,GAAG,GAAE,MAAa,GACjB,MAAM,GAAG,KAAK,CAShB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAUvG;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,oBAAoB,EAAE,cAAc,EAAE,kBAAkB,EAAE,OAAO,GAAG,IAAI,CAW/G;AAMD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,gBAAgB,EAAE,MAAM,GAAG,SAAS,GACnC,MAAM,GAAG,SAAS,CAGpB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,cAAc,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAEnG;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,OAAO,CAAC,mBAAmB,IAAI,MAAM,CAOvC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,MAAM,GAAG,SAAS,CAGpB;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EACzD,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,OAAO,CAAC,IAAI,CAAC,CAIf;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,EACxC,MAAM,EACN,cAAc,EACd,QAAQ,EACR,MAAM,EACN,mBAAmB,EACnB,UAA6C,GAC9C,EAAE;IACD,MAAM,EAAE,GAAG,CAAC;IACZ,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;IAC/C,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,UAAU,CAAC,EAAE,wBAAwB,CAAC;CACvC,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBhB;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EACtD,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,OAAO,CAAC,IAAI,CAAC,CAIf"}

package/dist/server/handlers/utils.js

@@ -1,2 +1,2 @@
-import { a as parseFilters, c as sanitizeBody, d as validateThreadOwnership, i as getEffectiveThreadId, l as validateBody, n as getContextResourceId, o as parsePerPage, r as getEffectiveResourceId, s as requireEffectiveResourceId, t as enforceThreadAccess, u as validateRunOwnership } from "../../utils-CMWGBd0O.js";
-export { enforceThreadAccess, getContextResourceId, getEffectiveResourceId, getEffectiveThreadId, parseFilters, parsePerPage, requireEffectiveResourceId, sanitizeBody, validateBody, validateRunOwnership, validateThreadOwnership };
+import { a as mergeBodyRequestContext, c as requireEffectiveResourceId, d as validateRunOwnership, f as validateThreadOwnership, i as getEffectiveThreadId, l as sanitizeBody, n as getContextResourceId, o as parseFilters, r as getEffectiveResourceId, s as parsePerPage, t as enforceThreadAccess, u as validateBody } from "../../utils-KsERfbhc.js";
+export { enforceThreadAccess, getContextResourceId, getEffectiveResourceId, getEffectiveThreadId, mergeBodyRequestContext, parseFilters, parsePerPage, requireEffectiveResourceId, sanitizeBody, validateBody, validateRunOwnership, validateThreadOwnership };

package/dist/server/handlers/workflow-builder.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../../rolldown-runtime-Bd6kNlEP.cjs");
+const require_workflow_builder = require("../../workflow-builder-_rQWs1B6.cjs");
+exports.GET_WORKFLOW_BUILDER_SETTINGS_ROUTE = require_workflow_builder.GET_WORKFLOW_BUILDER_SETTINGS_ROUTE;
+exports.STREAM_WORKFLOW_BUILDER_ROUTE = require_workflow_builder.STREAM_WORKFLOW_BUILDER_ROUTE;

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

@@ -0,0 +1,322 @@
+export declare const GET_WORKFLOW_BUILDER_SETTINGS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "createHandler" | "handler" | "method" | "openapi" | "path"> & {
+    method: "GET";
+    path: "/editor/workflow-builder/settings";
+    responseType: "json";
+    streamFormat?: 'sse' | 'stream';
+    sseFlushOnConnect?: boolean;
+    handler(params: import("../server-adapter").ServerContext): Promise<{
+        enabled: boolean;
+        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;
+    }>;
+    pathParamSchema?: import("zod").ZodType;
+    queryParamSchema?: import("zod").ZodType;
+    bodySchema?: import("zod").ZodType;
+    responseSchema?: import("zod").ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<undefined, undefined, undefined, import("zod").ZodObject<{
+        enabled: import("zod").ZodBoolean;
+        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>>;
+    }, import("zod/v4/core").$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const STREAM_WORKFLOW_BUILDER_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "createHandler" | "handler" | "method" | "openapi" | "path"> & {
+    method: "POST";
+    path: "/editor/workflow-builder/stream";
+    responseType: "stream";
+    streamFormat?: 'sse' | 'stream';
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        [x: string]: unknown;
+        messages: string | import("@mastra/core/agent/message-list").MessageInput[];
+        instructions?: import("@mastra/core/llm").SystemMessage | undefined;
+        system?: import("@mastra/core/llm").SystemMessage | undefined;
+        context?: import("@mastra/core/agent/message-list").MessageInput[] | undefined;
+        memory?: {
+            thread: string | {
+                [x: string]: unknown;
+                id: string;
+            };
+            resource?: string | undefined;
+            options?: Record<string, unknown> | undefined;
+            readOnly?: boolean | undefined;
+        } | undefined;
+        runId?: string | undefined;
+        savePerStep?: boolean | undefined;
+        requestContext?: Record<string, unknown> | undefined;
+        versions?: {
+            agents?: Record<string, {
+                versionId: string;
+            } | {
+                status: "draft" | "published";
+            }> | undefined;
+            defaultStatus?: "draft" | "published" | undefined;
+        } | undefined;
+        maxSteps?: number | undefined;
+        stopWhen?: ((event: unknown) => boolean | PromiseLike<boolean>)[] | ((event: unknown) => boolean | PromiseLike<boolean>) | undefined;
+        model?: string | undefined;
+        providerOptions?: Record<string, Record<string, string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
+            [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null>> | undefined;
+        modelSettings?: {
+            maxOutputTokens?: number;
+            temperature?: number;
+            topP?: number;
+            topK?: number;
+            presencePenalty?: number;
+            frequencyPenalty?: number;
+            stopSequences?: string[];
+            seed?: number;
+            maxRetries?: number;
+            headers?: Record<string, string | undefined>;
+            reasoning?: import("@mastra/core/loop").ReasoningLevel;
+        } | undefined;
+        activeTools?: string[] | undefined;
+        toolsets?: import("@mastra/core/agent").ToolsetsInput | undefined;
+        clientTools?: import("@mastra/core/agent").ToolsInput | undefined;
+        toolChoice?: "auto" | "none" | "required" | {
+            type: "tool";
+            toolName: string;
+        } | undefined;
+        requireToolApproval?: boolean | undefined;
+        scorers?: Record<string, {
+            scorer: string;
+            sampling?: import("@mastra/core/evals").ScoringSamplingConfig;
+        }> | undefined;
+        returnScorerData?: boolean | undefined;
+        tracingOptions?: {
+            metadata?: Record<string, unknown> | undefined;
+            requestContextKeys?: string[] | undefined;
+            traceId?: string | undefined;
+            parentSpanId?: string | undefined;
+            tags?: string[] | undefined;
+            hideInput?: boolean | undefined;
+            hideOutput?: boolean | undefined;
+        } | undefined;
+        output?: import("@mastra/core/llm").OutputType;
+        structuredOutput?: import("@mastra/core/agent").PublicStructuredOutputOptions<Record<string, unknown>> | undefined;
+        untilIdle?: boolean | {
+            maxIdleMs?: number | undefined;
+        } | undefined;
+    } & import("../server-adapter").ServerContext): Promise<import("../server-adapter/routes/stream-types").MastraStreamReturn>;
+    pathParamSchema?: import("zod").ZodType;
+    queryParamSchema?: import("zod").ZodType;
+    bodySchema?: import("zod").ZodType;
+    responseSchema?: import("zod").ZodType;
+    openapi?: import("../server-adapter/openapi-utils").OpenAPIRoute;
+    maxBodySize?: number;
+    deprecated?: boolean;
+    requiresPermission?: import("@mastra/core/auth").MastraFGAPermissionInput | import("@mastra/core/auth").MastraFGAPermissionInput[];
+    fga?: import("@mastra/core/auth").FGARouteConfig;
+    onValidationError?: import("@mastra/core/server").ValidationErrorHook;
+    readonly __schemas?: import("../server-adapter").RouteSchemas<undefined, undefined, import("zod").ZodObject<{
+        messages: import("zod").ZodUnion<readonly [import("zod").ZodArray<import("zod").ZodType<import("@mastra/core/agent/message-list").MessageInput, unknown, import("zod/v4/core").$ZodTypeInternals<import("@mastra/core/agent/message-list").MessageInput, unknown>>>, import("zod").ZodString]>;
+        instructions: import("zod").ZodOptional<import("zod").ZodType<import("@mastra/core/llm").SystemMessage, unknown, import("zod/v4/core").$ZodTypeInternals<import("@mastra/core/llm").SystemMessage, unknown>>>;
+        system: import("zod").ZodOptional<import("zod").ZodType<import("@mastra/core/llm").SystemMessage, unknown, import("zod/v4/core").$ZodTypeInternals<import("@mastra/core/llm").SystemMessage, unknown>>>;
+        context: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodType<import("@mastra/core/agent/message-list").MessageInput, unknown, import("zod/v4/core").$ZodTypeInternals<import("@mastra/core/agent/message-list").MessageInput, unknown>>>>;
+        memory: import("zod").ZodOptional<import("zod").ZodObject<{
+            thread: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+                id: import("zod").ZodString;
+            }, import("zod/v4/core").$loose>]>;
+            resource: import("zod").ZodOptional<import("zod").ZodString>;
+            options: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            readOnly: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+        runId: import("zod").ZodOptional<import("zod").ZodString>;
+        savePerStep: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        requestContext: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        versions: import("zod").ZodOptional<import("zod").ZodObject<{
+            agents: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                versionId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                status: import("zod").ZodEnum<{
+                    draft: "draft";
+                    published: "published";
+                }>;
+            }, import("zod/v4/core").$strip>]>>>;
+            defaultStatus: import("zod").ZodOptional<import("zod").ZodEnum<{
+                draft: "draft";
+                published: "published";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        maxSteps: import("zod").ZodOptional<import("zod").ZodNumber>;
+        stopWhen: import("zod").ZodOptional<import("zod").ZodType<((event: unknown) => boolean | PromiseLike<boolean>)[] | ((event: unknown) => boolean | PromiseLike<boolean>), unknown, import("zod/v4/core").$ZodTypeInternals<((event: unknown) => boolean | PromiseLike<boolean>)[] | ((event: unknown) => boolean | PromiseLike<boolean>), unknown>>>;
+        model: import("zod").ZodOptional<import("zod").ZodString>;
+        providerOptions: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
+            [key: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null, unknown, import("zod/v4/core").$ZodTypeInternals<string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | any | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null)[] | {
+            [key: string]: string | number | boolean | any | any | null;
+        } | null, unknown>>>>>;
+        modelSettings: import("zod").ZodOptional<import("zod").ZodType<{
+            maxOutputTokens?: number;
+            temperature?: number;
+            topP?: number;
+            topK?: number;
+            presencePenalty?: number;
+            frequencyPenalty?: number;
+            stopSequences?: string[];
+            seed?: number;
+            maxRetries?: number;
+            headers?: Record<string, string | undefined>;
+            reasoning?: import("@mastra/core/loop").ReasoningLevel;
+        }, unknown, import("zod/v4/core").$ZodTypeInternals<{
+            maxOutputTokens?: number;
+            temperature?: number;
+            topP?: number;
+            topK?: number;
+            presencePenalty?: number;
+            frequencyPenalty?: number;
+            stopSequences?: string[];
+            seed?: number;
+            maxRetries?: number;
+            headers?: Record<string, string | undefined>;
+            reasoning?: import("@mastra/core/loop").ReasoningLevel;
+        }, unknown>>>;
+        activeTools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+        toolsets: import("zod").ZodOptional<import("zod").ZodType<import("@mastra/core/agent").ToolsetsInput, unknown, import("zod/v4/core").$ZodTypeInternals<import("@mastra/core/agent").ToolsetsInput, unknown>>>;
+        clientTools: import("zod").ZodOptional<import("zod").ZodType<import("@mastra/core/agent").ToolsInput, unknown, import("zod/v4/core").$ZodTypeInternals<import("@mastra/core/agent").ToolsInput, unknown>>>;
+        toolChoice: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+            auto: "auto";
+            none: "none";
+            required: "required";
+        }>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"tool">;
+            toolName: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>]>>;
+        requireToolApproval: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        scorers: import("zod").ZodOptional<import("zod").ZodType<Record<string, {
+            scorer: string;
+            sampling?: import("@mastra/core/evals").ScoringSamplingConfig;
+        }>, unknown, import("zod/v4/core").$ZodTypeInternals<Record<string, {
+            scorer: string;
+            sampling?: import("@mastra/core/evals").ScoringSamplingConfig;
+        }>, unknown>>>;
+        returnScorerData: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        tracingOptions: import("zod").ZodOptional<import("zod").ZodObject<{
+            metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            requestContextKeys: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            traceId: import("zod").ZodOptional<import("zod").ZodString>;
+            parentSpanId: import("zod").ZodOptional<import("zod").ZodString>;
+            tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            hideInput: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            hideOutput: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+        output: import("zod").ZodOptional<import("zod").ZodType<import("@mastra/core/llm").OutputType, unknown, import("zod/v4/core").$ZodTypeInternals<import("@mastra/core/llm").OutputType, unknown>>>;
+        structuredOutput: import("zod").ZodOptional<import("zod").ZodType<import("@mastra/core/agent").PublicStructuredOutputOptions<Record<string, unknown>>, unknown, import("zod/v4/core").$ZodTypeInternals<import("@mastra/core/agent").PublicStructuredOutputOptions<Record<string, unknown>>, unknown>>>;
+        untilIdle: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodBoolean, import("zod").ZodObject<{
+            maxIdleMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>]>>;
+    }, import("zod/v4/core").$loose>, import("zod").ZodUnknown> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+//# sourceMappingURL=workflow-builder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-builder.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/workflow-builder.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyB9C,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwExC,CAAC"}

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

@@ -0,0 +1,2 @@
+import { n as STREAM_WORKFLOW_BUILDER_ROUTE, t as GET_WORKFLOW_BUILDER_SETTINGS_ROUTE } from "../../workflow-builder-C9DVk9Tw.js";
+export { GET_WORKFLOW_BUILDER_SETTINGS_ROUTE, STREAM_WORKFLOW_BUILDER_ROUTE };

package/dist/server/handlers/workflows.cjs

@@ -7,7 +7,7 @@ const require_agents = require("../../agents-C3k-sZBO.cjs");
 const require_route_builder = require("../../route-builder-DupY8fkI.cjs");
 const require_utils = require("../../utils-WcR0QSUB.cjs");
 const require_server_handlers_error = require("./error.cjs");
-const require_utils$1 = require("../../utils-BtkczLrA.cjs");
+const require_utils$1 = require("../../utils-aIu3gkhJ.cjs");
 let zod_v4 = require("zod/v4");
 let _mastra_core_stream = require("@mastra/core/stream");
 //#region src/server/handlers/workflows.ts

package/dist/server/handlers/workflows.js

@@ -6,7 +6,7 @@ import { K as streamResponseSchema } from "../../agents-AMeMJBI1.js";
 import { n as createRoute } from "../../route-builder-BukcT_Kp.js";
 import { a as getWorkflowInfo, t as WorkflowRegistry } from "../../utils-Duk4hfT_.js";
 import { handleError } from "./error.js";
-import { f as MastraFGAPermissions, r as getEffectiveResourceId, u as validateRunOwnership } from "../../utils-CMWGBd0O.js";
+import { d as validateRunOwnership, p as MastraFGAPermissions, r as getEffectiveResourceId } from "../../utils-KsERfbhc.js";
 import { z } from "zod/v4";
 import { createReplayStream } from "@mastra/core/stream";
 //#region src/server/handlers/workflows.ts

package/dist/server/schemas/datasets.d.ts

@@ -35,6 +35,17 @@ export declare const listExperimentResultsQuerySchema: z.ZodObject<{
     perPage: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
     tags: z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>;
+export declare const listDatasetsQuerySchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+    perPage: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+    targetType: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        processor: "processor";
+        scorer: "scorer";
+        workflow: "workflow";
+    }>>;
+    targetIds: z.ZodPreprocess<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
 export declare const listExperimentsQuerySchema: z.ZodObject<{
     page: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
     perPage: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
@@ -42,6 +53,13 @@ export declare const listExperimentsQuerySchema: z.ZodObject<{
     comparisonId: z.ZodOptional<z.ZodString>;
     variantId: z.ZodOptional<z.ZodString>;
     trialIndex: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    targetType: z.ZodOptional<z.ZodEnum<{
+        agent: "agent";
+        processor: "processor";
+        scorer: "scorer";
+        workflow: "workflow";
+    }>>;
+    targetId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const tenancyQuerySchema: z.ZodObject<{
     organizationId: z.ZodOptional<z.ZodString>;