@mastra/server 1.58.0-alpha.1 → 1.58.0-alpha.13

package/dist/server/handlers/processor-providers.d.ts

@@ -1,15 +1,79 @@
 /**
  * GET /processor-providers - List all registered processor providers
  */
-export declare const LIST_PROCESSOR_PROVIDERS_ROUTE: import("../server-adapter").ServerRoute<{}, {
-    providers: {
+export declare const LIST_PROCESSOR_PROVIDERS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/processor-providers";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: import("../server-adapter").ServerContext): Promise<{
+        providers: {
+            id: string;
+            name: string;
+            availablePhases: ("processInput" | "processInputStep" | "processOutputStream" | "processOutputResult" | "processOutputStep" | "processToolResult")[];
+            description?: string | 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<{
+        providers: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            availablePhases: import("zod").ZodArray<import("zod").ZodEnum<{
+                processInput: "processInput";
+                processInputStep: "processInputStep";
+                processOutputStream: "processOutputStream";
+                processOutputResult: "processOutputResult";
+                processOutputStep: "processOutputStep";
+                processToolResult: "processToolResult";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+/**
+ * GET /processor-providers/:providerId - Get a specific processor provider with config schema
+ */
+export declare const GET_PROCESSOR_PROVIDER_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/processor-providers/:providerId";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        providerId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
         id: string;
         name: string;
         availablePhases: ("processInput" | "processInputStep" | "processOutputStream" | "processOutputResult" | "processOutputStep" | "processToolResult")[];
+        configSchema: Record<string, unknown>;
         description?: string | undefined;
-    }[];
-}, "json", import("../server-adapter").RouteSchemas<undefined, undefined, undefined, import("zod").ZodObject<{
-    providers: import("zod").ZodArray<import("zod").ZodObject<{
+    }>;
+    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<import("zod").ZodObject<{
+        providerId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
         id: import("zod").ZodString;
         name: import("zod").ZodString;
         description: import("zod").ZodOptional<import("zod").ZodString>;
@@ -21,33 +85,9 @@ export declare const LIST_PROCESSOR_PROVIDERS_ROUTE: import("../server-adapter")
             processOutputStep: "processOutputStep";
             processToolResult: "processToolResult";
         }>>;
-    }, import("zod/v4/core").$strip>>;
-}, import("zod/v4/core").$strip>>, "GET", "/processor-providers">;
-/**
- * GET /processor-providers/:providerId - Get a specific processor provider with config schema
- */
-export declare const GET_PROCESSOR_PROVIDER_ROUTE: import("../server-adapter").ServerRoute<{
-    providerId: string;
-}, {
-    id: string;
-    name: string;
-    availablePhases: ("processInput" | "processInputStep" | "processOutputStream" | "processOutputResult" | "processOutputStep" | "processToolResult")[];
-    configSchema: Record<string, unknown>;
-    description?: string | undefined;
-}, "json", import("../server-adapter").RouteSchemas<import("zod").ZodObject<{
-    providerId: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
-    id: import("zod").ZodString;
-    name: import("zod").ZodString;
-    description: import("zod").ZodOptional<import("zod").ZodString>;
-    availablePhases: import("zod").ZodArray<import("zod").ZodEnum<{
-        processInput: "processInput";
-        processInputStep: "processInputStep";
-        processOutputStream: "processOutputStream";
-        processOutputResult: "processOutputResult";
-        processOutputStep: "processOutputStep";
-        processToolResult: "processToolResult";
-    }>>;
-    configSchema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
-}, import("zod/v4/core").$strip>>, "GET", "/processor-providers/:providerId">;
+        configSchema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
 //# sourceMappingURL=processor-providers.d.ts.map

package/dist/server/handlers/processor-providers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"processor-providers.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/processor-providers.ts"],"names":[],"mappings":"AAgBA;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;iEA6BzC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;6EAiCvC,CAAC"}
+{"version":3,"file":"processor-providers.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/processor-providers.ts"],"names":[],"mappings":"AAgBA;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BzC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCvC,CAAC"}

package/dist/server/handlers/processor-providers.js

@@ -1,5 +1,5 @@
 import { t as HTTPException } from "../../http-exception-CyfxZB6W.js";
-import { n as createRoute } from "../../route-builder-CIk5k35M.js";
+import { n as createRoute } from "../../route-builder-YQ_gLIvW.js";
 import { handleError } from "./error.js";
 import { n as getProcessorProvidersResponseSchema, r as processorProviderIdPathParams, t as getProcessorProviderResponseSchema } from "../../processor-providers-DBhZC6-4.js";
 import { zodToJsonSchema } from "@mastra/core/utils/zod-to-json";

package/dist/server/handlers/processors.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_http_exception = require("../../http-exception-CKDHupKw.cjs");
-const require_route_builder = require("../../route-builder-CgLVYL1c.cjs");
+const require_route_builder = require("../../route-builder-BAAedfru.cjs");
 const require_server_handlers_error = require("./error.cjs");
 const require_processors = require("../../processors-D6lRjS0e.cjs");
 let _mastra_core_agent = require("@mastra/core/agent");

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

@@ -1,118 +1,123 @@
-export declare const LIST_PROCESSORS_ROUTE: import("../server-adapter").ServerRoute<{}, Record<string, {
-    id: string;
-    phases: ("input" | "inputStep" | "outputStream" | "outputResult" | "outputStep" | "toolResult")[];
-    agentIds: string[];
-    configurations: {
-        agentId: string;
-        type: "input" | "output";
-    }[];
-    isWorkflow: boolean;
-    name?: string | undefined;
-    description?: string | undefined;
-}>, "json", import("../server-adapter").RouteSchemas<undefined, undefined, undefined, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-    id: import("zod").ZodString;
-    name: import("zod").ZodOptional<import("zod").ZodString>;
-    description: import("zod").ZodOptional<import("zod").ZodString>;
-    phases: import("zod").ZodArray<import("zod").ZodEnum<{
-        input: "input";
-        inputStep: "inputStep";
-        outputStream: "outputStream";
-        outputResult: "outputResult";
-        outputStep: "outputStep";
-        toolResult: "toolResult";
-    }>>;
-    agentIds: import("zod").ZodArray<import("zod").ZodString>;
-    configurations: import("zod").ZodArray<import("zod").ZodObject<{
-        agentId: import("zod").ZodString;
-        type: import("zod").ZodEnum<{
-            input: "input";
-            output: "output";
-        }>;
-    }, import("zod/v4/core").$strip>>;
-    isWorkflow: import("zod").ZodBoolean;
-}, import("zod/v4/core").$strip>>>, "GET", "/processors">;
-export declare const GET_PROCESSOR_BY_ID_ROUTE: import("../server-adapter").ServerRoute<{
-    processorId: string;
-}, {
-    id: string;
-    phases: ("input" | "inputStep" | "outputStream" | "outputResult" | "outputStep" | "toolResult")[];
-    configurations: {
-        agentId: string;
-        agentName: string;
-        type: "input" | "output";
-    }[];
-    isWorkflow: boolean;
-    name?: string | undefined;
-    description?: string | undefined;
-}, "json", import("../server-adapter").RouteSchemas<import("zod").ZodObject<{
-    processorId: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
-    id: import("zod").ZodString;
-    name: import("zod").ZodOptional<import("zod").ZodString>;
-    description: import("zod").ZodOptional<import("zod").ZodString>;
-    phases: import("zod").ZodArray<import("zod").ZodEnum<{
-        input: "input";
-        inputStep: "inputStep";
-        outputStream: "outputStream";
-        outputResult: "outputResult";
-        outputStep: "outputStep";
-        toolResult: "toolResult";
+export declare const LIST_PROCESSORS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/processors";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: import("../server-adapter").ServerContext): Promise<Record<string, {
+        id: string;
+        phases: ("input" | "inputStep" | "outputStream" | "outputResult" | "outputStep" | "toolResult")[];
+        agentIds: string[];
+        configurations: {
+            agentId: string;
+            type: "input" | "output";
+        }[];
+        isWorkflow: boolean;
+        name?: string | undefined;
+        description?: string | undefined;
     }>>;
-    configurations: import("zod").ZodArray<import("zod").ZodObject<{
-        agentId: import("zod").ZodString;
-        agentName: import("zod").ZodString;
-        type: import("zod").ZodEnum<{
+    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").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        phases: import("zod").ZodArray<import("zod").ZodEnum<{
             input: "input";
-            output: "output";
-        }>;
-    }, import("zod/v4/core").$strip>>;
-    isWorkflow: import("zod").ZodBoolean;
-}, import("zod/v4/core").$strip>>, "GET", "/processors/:processorId">;
-export declare const EXECUTE_PROCESSOR_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
-    processorId: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
-    phase: import("zod").ZodEnum<{
-        input: "input";
-        inputStep: "inputStep";
-        outputStream: "outputStream";
-        outputResult: "outputResult";
-        outputStep: "outputStep";
-        toolResult: "toolResult";
+            inputStep: "inputStep";
+            outputStream: "outputStream";
+            outputResult: "outputResult";
+            outputStep: "outputStep";
+            toolResult: "toolResult";
+        }>>;
+        agentIds: import("zod").ZodArray<import("zod").ZodString>;
+        configurations: import("zod").ZodArray<import("zod").ZodObject<{
+            agentId: import("zod").ZodString;
+            type: import("zod").ZodEnum<{
+                input: "input";
+                output: "output";
+            }>;
+        }, import("zod/v4/core").$strip>>;
+        isWorkflow: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const GET_PROCESSOR_BY_ID_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/processors/:processorId";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        processorId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        id: string;
+        phases: ("input" | "inputStep" | "outputStream" | "outputResult" | "outputStep" | "toolResult")[];
+        configurations: {
+            agentId: string;
+            agentName: string;
+            type: "input" | "output";
+        }[];
+        isWorkflow: boolean;
+        name?: string | undefined;
+        description?: string | undefined;
     }>;
-    messages: import("zod").ZodArray<import("zod").ZodObject<{
+    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<import("zod").ZodObject<{
+        processorId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
         id: import("zod").ZodString;
-        role: import("zod").ZodEnum<{
-            tool: "tool";
-            user: "user";
-            system: "system";
-            signal: "signal";
-            assistant: "assistant";
-        }>;
-        createdAt: import("zod").ZodOptional<import("zod").ZodCoercedDate<unknown>>;
-        content: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
-            format: import("zod").ZodOptional<import("zod").ZodLiteral<2>>;
-            parts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnknown>>;
-            content: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$loose>, import("zod").ZodString]>;
-    }, import("zod/v4/core").$loose>>;
-    agentId: import("zod").ZodOptional<import("zod").ZodString>;
-    requestContext: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
-}, import("zod/v4/core").$strip>>, {
-    success: boolean;
-    phase: string;
-    messages?: {
-        [x: string]: unknown;
-        id: string;
-        role: "tool" | "user" | "system" | "signal" | "assistant";
-        content: string | {
-            [x: string]: unknown;
-            format?: 2 | undefined;
-            parts?: unknown[] | undefined;
-            content?: string | undefined;
-        };
-        createdAt?: Date | undefined;
-    }[] | undefined;
-    messageList?: {
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        phases: import("zod").ZodArray<import("zod").ZodEnum<{
+            input: "input";
+            inputStep: "inputStep";
+            outputStream: "outputStream";
+            outputResult: "outputResult";
+            outputStep: "outputStep";
+            toolResult: "toolResult";
+        }>>;
+        configurations: import("zod").ZodArray<import("zod").ZodObject<{
+            agentId: import("zod").ZodString;
+            agentName: import("zod").ZodString;
+            type: import("zod").ZodEnum<{
+                input: "input";
+                output: "output";
+            }>;
+        }, import("zod/v4/core").$strip>>;
+        isWorkflow: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const EXECUTE_PROCESSOR_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/processors/:processorId/execute";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        processorId: string;
+    } & {
+        phase: "input" | "inputStep" | "outputStream" | "outputResult" | "outputStep" | "toolResult";
         messages: {
             [x: string]: unknown;
             id: string;
@@ -125,62 +130,65 @@ export declare const EXECUTE_PROCESSOR_ROUTE: import("../server-adapter").Server
             };
             createdAt?: Date | undefined;
         }[];
-    } | undefined;
-    tripwire?: {
-        triggered: boolean;
-        reason?: string | undefined;
-        metadata?: unknown;
-    } | undefined;
-    error?: string | undefined;
-}, "json", import("../server-adapter").RouteSchemas<import("zod").ZodObject<{
-    processorId: import("zod").ZodString;
-}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
-    phase: import("zod").ZodEnum<{
-        input: "input";
-        inputStep: "inputStep";
-        outputStream: "outputStream";
-        outputResult: "outputResult";
-        outputStep: "outputStep";
-        toolResult: "toolResult";
+        agentId?: string | undefined;
+        requestContext?: Record<string, unknown> | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        success: boolean;
+        phase: string;
+        messages?: {
+            [x: string]: unknown;
+            id: string;
+            role: "tool" | "user" | "system" | "signal" | "assistant";
+            content: string | {
+                [x: string]: unknown;
+                format?: 2 | undefined;
+                parts?: unknown[] | undefined;
+                content?: string | undefined;
+            };
+            createdAt?: Date | undefined;
+        }[] | undefined;
+        messageList?: {
+            messages: {
+                [x: string]: unknown;
+                id: string;
+                role: "tool" | "user" | "system" | "signal" | "assistant";
+                content: string | {
+                    [x: string]: unknown;
+                    format?: 2 | undefined;
+                    parts?: unknown[] | undefined;
+                    content?: string | undefined;
+                };
+                createdAt?: Date | undefined;
+            }[];
+        } | undefined;
+        tripwire?: {
+            triggered: boolean;
+            reason?: string | undefined;
+            metadata?: unknown;
+        } | undefined;
+        error?: string | undefined;
     }>;
-    messages: import("zod").ZodArray<import("zod").ZodObject<{
-        id: import("zod").ZodString;
-        role: import("zod").ZodEnum<{
-            tool: "tool";
-            user: "user";
-            system: "system";
-            signal: "signal";
-            assistant: "assistant";
-        }>;
-        createdAt: import("zod").ZodOptional<import("zod").ZodCoercedDate<unknown>>;
-        content: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
-            format: import("zod").ZodOptional<import("zod").ZodLiteral<2>>;
-            parts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnknown>>;
-            content: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$loose>, import("zod").ZodString]>;
-    }, import("zod/v4/core").$loose>>;
-    agentId: import("zod").ZodOptional<import("zod").ZodString>;
-    requestContext: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
-}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
-    success: import("zod").ZodBoolean;
-    phase: import("zod").ZodString;
-    messages: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-        id: import("zod").ZodString;
-        role: import("zod").ZodEnum<{
-            tool: "tool";
-            user: "user";
-            system: "system";
-            signal: "signal";
-            assistant: "assistant";
+    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<import("zod").ZodObject<{
+        processorId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+        phase: import("zod").ZodEnum<{
+            input: "input";
+            inputStep: "inputStep";
+            outputStream: "outputStream";
+            outputResult: "outputResult";
+            outputStep: "outputStep";
+            toolResult: "toolResult";
         }>;
-        createdAt: import("zod").ZodOptional<import("zod").ZodCoercedDate<unknown>>;
-        content: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
-            format: import("zod").ZodOptional<import("zod").ZodLiteral<2>>;
-            parts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnknown>>;
-            content: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$loose>, import("zod").ZodString]>;
-    }, import("zod/v4/core").$loose>>>;
-    messageList: import("zod").ZodOptional<import("zod").ZodObject<{
         messages: import("zod").ZodArray<import("zod").ZodObject<{
             id: import("zod").ZodString;
             role: import("zod").ZodEnum<{
@@ -197,12 +205,53 @@ export declare const EXECUTE_PROCESSOR_ROUTE: import("../server-adapter").Server
                 content: import("zod").ZodOptional<import("zod").ZodString>;
             }, import("zod/v4/core").$loose>, import("zod").ZodString]>;
         }, import("zod/v4/core").$loose>>;
-    }, import("zod/v4/core").$strip>>;
-    tripwire: import("zod").ZodOptional<import("zod").ZodObject<{
-        triggered: import("zod").ZodBoolean;
-        reason: import("zod").ZodOptional<import("zod").ZodString>;
-        metadata: import("zod").ZodOptional<import("zod").ZodUnknown>;
-    }, import("zod/v4/core").$strip>>;
-    error: import("zod").ZodOptional<import("zod").ZodString>;
-}, import("zod/v4/core").$strip>>, "POST", "/processors/:processorId/execute">;
+        agentId: import("zod").ZodOptional<import("zod").ZodString>;
+        requestContext: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        success: import("zod").ZodBoolean;
+        phase: import("zod").ZodString;
+        messages: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            role: import("zod").ZodEnum<{
+                tool: "tool";
+                user: "user";
+                system: "system";
+                signal: "signal";
+                assistant: "assistant";
+            }>;
+            createdAt: import("zod").ZodOptional<import("zod").ZodCoercedDate<unknown>>;
+            content: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                format: import("zod").ZodOptional<import("zod").ZodLiteral<2>>;
+                parts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnknown>>;
+                content: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$loose>, import("zod").ZodString]>;
+        }, import("zod/v4/core").$loose>>>;
+        messageList: import("zod").ZodOptional<import("zod").ZodObject<{
+            messages: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                role: import("zod").ZodEnum<{
+                    tool: "tool";
+                    user: "user";
+                    system: "system";
+                    signal: "signal";
+                    assistant: "assistant";
+                }>;
+                createdAt: import("zod").ZodOptional<import("zod").ZodCoercedDate<unknown>>;
+                content: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+                    format: import("zod").ZodOptional<import("zod").ZodLiteral<2>>;
+                    parts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnknown>>;
+                    content: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$loose>, import("zod").ZodString]>;
+            }, import("zod/v4/core").$loose>>;
+        }, import("zod/v4/core").$strip>>;
+        tripwire: import("zod").ZodOptional<import("zod").ZodObject<{
+            triggered: import("zod").ZodBoolean;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+            metadata: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        }, import("zod/v4/core").$strip>>;
+        error: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
 //# sourceMappingURL=processors.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"processors.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/processors.ts"],"names":[],"mappings":"AA6EA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDA0DhC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAqDpC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8EAyUlC,CAAC"}
+{"version":3,"file":"processors.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/processors.ts"],"names":[],"mappings":"AA6EA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DhC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDpC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyUlC,CAAC"}

package/dist/server/handlers/processors.js

@@ -1,5 +1,5 @@
 import { t as HTTPException } from "../../http-exception-CyfxZB6W.js";
-import { n as createRoute } from "../../route-builder-CIk5k35M.js";
+import { n as createRoute } from "../../route-builder-YQ_gLIvW.js";
 import { handleError } from "./error.js";
 import { a as processorIdPathParams, n as executeProcessorResponseSchema, o as serializedProcessorDetailSchema, r as listProcessorsResponseSchema, t as executeProcessorBodySchema } from "../../processors-88oJ_4J-.js";
 import { MessageList } from "@mastra/core/agent";

package/dist/server/handlers/prompt-block-versions.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_http_exception = require("../../http-exception-CKDHupKw.cjs");
-const require_route_builder = require("../../route-builder-CgLVYL1c.cjs");
-const require_utils = require("../../utils-wESuBh27.cjs");
+const require_route_builder = require("../../route-builder-BAAedfru.cjs");
+const require_utils = require("../../utils-Bna_JCkb.cjs");
 const require_server_handlers_error = require("./error.cjs");
-const require_prompt_block_versions = require("../../prompt-block-versions-Bl3RmkTE.cjs");
 const require_server_handlers_version_helpers = require("./version-helpers.cjs");
+const require_prompt_block_versions = require("../../prompt-block-versions-Cgt_Grk2.cjs");
 //#region src/server/handlers/prompt-block-versions.ts
 const SNAPSHOT_CONFIG_FIELDS = [
 	"name",