@mastra/server 1.58.0-alpha.9 → 1.58.0

package/dist/server/handlers/agent-controller.d.ts

@@ -1,919 +1,1573 @@
 import { z } from 'zod/v4';
-export declare const LIST_AGENT_CONTROLLERS_ROUTE: import("../server-adapter").ServerRoute<{}, {
-    agentControllers: {
-        id: string;
-    }[];
-}, "json", import("../server-adapter").RouteSchemas<undefined, undefined, undefined, z.ZodObject<{
-    agentControllers: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, "GET", "/agent-controller">;
-export declare const CREATE_AGENT_CONTROLLER_SESSION_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    resourceId: z.ZodString;
-    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    threadId: z.ZodOptional<z.ZodString>;
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>, {
-    controllerId: string;
-    resourceId: string;
-    threadId?: string | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    resourceId: z.ZodString;
-    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    threadId: z.ZodOptional<z.ZodString>;
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-    threadId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions">;
-export declare const STREAM_AGENT_CONTROLLER_SESSION_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined>, unknown, "stream", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined, undefined>, "GET", "/agent-controller/:controllerId/sessions/:resourceId/stream">;
-export declare const SEND_AGENT_CONTROLLER_MESSAGE_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    message: z.ZodString;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        data: z.ZodString;
-        mediaType: z.ZodString;
-        filename: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    message: z.ZodString;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        data: z.ZodString;
-        mediaType: z.ZodString;
-        filename: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/messages">;
-export declare const ABORT_AGENT_CONTROLLER_SESSION_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/abort">;
-export declare const AGENT_CONTROLLER_TOOL_APPROVAL_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    toolCallId: z.ZodString;
-    approved: z.ZodBoolean;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    toolCallId: z.ZodString;
-    approved: z.ZodBoolean;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/tool-approval">;
-export declare const AGENT_CONTROLLER_TOOL_SUSPENSION_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    toolCallId: z.ZodString;
-    resumeData: z.ZodUnknown;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    toolCallId: z.ZodString;
-    resumeData: z.ZodUnknown;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/tool-suspension">;
-export declare const STEER_AGENT_CONTROLLER_SESSION_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    message: z.ZodString;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    message: z.ZodString;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/steer">;
-export declare const SWITCH_AGENT_CONTROLLER_MODE_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    modeId: z.ZodString;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    modeId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/mode">;
-export declare const SWITCH_AGENT_CONTROLLER_MODEL_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    modelId: z.ZodString;
-    scope: z.ZodOptional<z.ZodEnum<{
-        thread: "thread";
-        global: "global";
-    }>>;
-    modeId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    modelId: z.ZodString;
-    scope: z.ZodOptional<z.ZodEnum<{
-        thread: "thread";
-        global: "global";
-    }>>;
-    modeId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/model">;
-export declare const SWITCH_AGENT_CONTROLLER_THREAD_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    threadId: z.ZodString;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    threadId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/thread">;
-export declare const GET_AGENT_CONTROLLER_SESSION_STATE_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined>, {
-    controllerId: string;
-    resourceId: string;
-    modeId: string;
-    modelId: string;
-    threadId?: string | undefined;
-    running?: boolean | undefined;
-    omProgress?: {
-        status: string;
-        pendingTokens: number;
-        threshold: number;
-        thresholdPercent: number;
-        observationTokens: number;
-        reflectionThreshold: number;
-        reflectionThresholdPercent: number;
-        projectedMessageRemoval: number;
-        projectedReflectionSavings: number;
-    } | undefined;
-    tokenUsage?: Record<string, unknown> | undefined;
-    settings?: {
-        yolo: boolean;
-        notifications: "system" | "off" | "both" | "bell";
-        smartEditing: boolean;
-        thinkingLevel?: "low" | "medium" | "high" | "xhigh" | "max" | "off" | undefined;
-    } | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-    threadId: z.ZodOptional<z.ZodString>;
-    modeId: z.ZodString;
-    modelId: z.ZodString;
-    running: z.ZodOptional<z.ZodBoolean>;
-    omProgress: z.ZodOptional<z.ZodObject<{
-        status: z.ZodString;
-        pendingTokens: z.ZodNumber;
-        threshold: z.ZodNumber;
-        thresholdPercent: z.ZodNumber;
-        observationTokens: z.ZodNumber;
-        reflectionThreshold: z.ZodNumber;
-        reflectionThresholdPercent: z.ZodNumber;
-        projectedMessageRemoval: z.ZodNumber;
-        projectedReflectionSavings: z.ZodNumber;
-    }, z.core.$strip>>;
-    tokenUsage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    settings: z.ZodOptional<z.ZodObject<{
-        yolo: z.ZodBoolean;
-        thinkingLevel: z.ZodOptional<z.ZodEnum<{
+export declare const LIST_AGENT_CONTROLLERS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/agent-controller";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: import("../server-adapter").ServerContext): Promise<{
+        agentControllers: {
+            id: string;
+        }[];
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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, z.ZodObject<{
+        agentControllers: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const CREATE_AGENT_CONTROLLER_SESSION_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+    } & {
+        resourceId: string;
+        tags?: Record<string, string> | undefined;
+        threadId?: string | undefined;
+        sessionScope?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        controllerId: string;
+        resourceId: string;
+        threadId?: string | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        resourceId: z.ZodString;
+        tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        threadId: z.ZodOptional<z.ZodString>;
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+        threadId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const STREAM_AGENT_CONTROLLER_SESSION_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/stream";
+    responseType: "stream";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<import("../server-adapter/routes/stream-types").MastraStreamReturn>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, undefined, undefined> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const SEND_AGENT_CONTROLLER_MESSAGE_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/messages";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        message: string;
+        requestContext?: Record<string, unknown> | undefined;
+        files?: {
+            data: string;
+            mediaType: string;
+            filename?: string | undefined;
+        }[] | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        message: z.ZodString;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            data: z.ZodString;
+            mediaType: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const ABORT_AGENT_CONTROLLER_SESSION_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/abort";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const AGENT_CONTROLLER_TOOL_APPROVAL_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/tool-approval";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        toolCallId: string;
+        approved: boolean;
+        requestContext?: Record<string, unknown> | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        toolCallId: z.ZodString;
+        approved: z.ZodBoolean;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const AGENT_CONTROLLER_TOOL_SUSPENSION_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/tool-suspension";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        toolCallId: string;
+        resumeData: unknown;
+        requestContext?: Record<string, unknown> | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        toolCallId: z.ZodString;
+        resumeData: z.ZodUnknown;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const STEER_AGENT_CONTROLLER_SESSION_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/steer";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        message: string;
+        requestContext?: Record<string, unknown> | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        message: z.ZodString;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const SWITCH_AGENT_CONTROLLER_MODE_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/mode";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        modeId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        modeId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const SWITCH_AGENT_CONTROLLER_MODEL_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/model";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        modelId: string;
+        scope?: "thread" | "global" | undefined;
+        modeId?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        modelId: z.ZodString;
+        scope: z.ZodOptional<z.ZodEnum<{
+            thread: "thread";
+            global: "global";
+        }>>;
+        modeId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const SWITCH_AGENT_CONTROLLER_THREAD_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/thread";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        threadId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        threadId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const GET_AGENT_CONTROLLER_SESSION_STATE_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/agent-controller/:controllerId/sessions/:resourceId";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        controllerId: string;
+        resourceId: string;
+        modeId: string;
+        modelId: string;
+        threadId?: string | undefined;
+        running?: boolean | undefined;
+        omProgress?: {
+            status: string;
+            pendingTokens: number;
+            threshold: number;
+            thresholdPercent: number;
+            observationTokens: number;
+            reflectionThreshold: number;
+            reflectionThresholdPercent: number;
+            projectedMessageRemoval: number;
+            projectedReflectionSavings: number;
+        } | undefined;
+        tokenUsage?: Record<string, unknown> | undefined;
+        settings?: {
+            yolo: boolean;
+            notifications: "system" | "off" | "both" | "bell";
+            smartEditing: boolean;
+            thinkingLevel?: "low" | "medium" | "high" | "xhigh" | "max" | "off" | undefined;
+        } | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+        threadId: z.ZodOptional<z.ZodString>;
+        modeId: z.ZodString;
+        modelId: z.ZodString;
+        running: z.ZodOptional<z.ZodBoolean>;
+        omProgress: z.ZodOptional<z.ZodObject<{
+            status: z.ZodString;
+            pendingTokens: z.ZodNumber;
+            threshold: z.ZodNumber;
+            thresholdPercent: z.ZodNumber;
+            observationTokens: z.ZodNumber;
+            reflectionThreshold: z.ZodNumber;
+            reflectionThresholdPercent: z.ZodNumber;
+            projectedMessageRemoval: z.ZodNumber;
+            projectedReflectionSavings: z.ZodNumber;
+        }, z.core.$strip>>;
+        tokenUsage: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        settings: z.ZodOptional<z.ZodObject<{
+            yolo: z.ZodBoolean;
+            thinkingLevel: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                max: "max";
+                off: "off";
+            }>>;
+            notifications: z.ZodEnum<{
+                system: "system";
+                off: "off";
+                both: "both";
+                bell: "bell";
+            }>;
+            smartEditing: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const LIST_AGENT_CONTROLLER_MODES_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/agent-controller/:controllerId/modes";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        modes: {
+            id: string;
+            name?: string | undefined;
+        }[];
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+    }, z.core.$strip>, undefined, undefined, z.ZodObject<{
+        modes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const LIST_AGENT_CONTROLLER_THREADS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/threads";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        limit?: number | undefined;
+        sessionScope?: string | undefined;
+        tags?: Record<string, string> | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        threads: {
+            id: string;
+            title?: string | undefined;
+            updatedAt?: string | undefined;
+            tags?: Record<string, string> | undefined;
+            state?: "active" | "idle" | undefined;
+        }[];
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        sessionScope: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodPreprocess<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>>;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        threads: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodOptional<z.ZodString>;
+            updatedAt: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            state: z.ZodOptional<z.ZodEnum<{
+                active: "active";
+                idle: "idle";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const SEND_AGENT_CONTROLLER_NOTIFICATION_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/notifications";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        source: string;
+        kind: string;
+        summary: string;
+        priority?: "low" | "medium" | "high" | "urgent" | undefined;
+        payload?: unknown;
+        sourceId?: string | undefined;
+        dedupeKey?: string | undefined;
+        coalesceKey?: string | undefined;
+        attributes?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        accepted: boolean;
+        notificationId?: string | undefined;
+        decision?: string | undefined;
+        runId?: string | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodString;
+        kind: z.ZodString;
+        summary: z.ZodString;
+        priority: z.ZodOptional<z.ZodEnum<{
             low: "low";
             medium: "medium";
             high: "high";
-            xhigh: "xhigh";
-            max: "max";
-            off: "off";
+            urgent: "urgent";
         }>>;
-        notifications: z.ZodEnum<{
-            system: "system";
-            off: "off";
-            both: "both";
-            bell: "bell";
-        }>;
-        smartEditing: z.ZodBoolean;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, "GET", "/agent-controller/:controllerId/sessions/:resourceId">;
-export declare const LIST_AGENT_CONTROLLER_MODES_ROUTE: import("../server-adapter").ServerRoute<{
-    controllerId: string;
-}, {
-    modes: {
-        id: string;
-        name?: string | undefined;
-    }[];
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-}, z.core.$strip>, undefined, undefined, z.ZodObject<{
-    modes: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, "GET", "/agent-controller/:controllerId/modes">;
-export declare const LIST_AGENT_CONTROLLER_THREADS_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    sessionScope: z.ZodOptional<z.ZodString>;
-    tags: z.ZodOptional<z.ZodPreprocess<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>>;
-}, z.core.$strip>, undefined>, {
-    threads: {
+        payload: z.ZodOptional<z.ZodUnknown>;
+        sourceId: z.ZodOptional<z.ZodString>;
+        dedupeKey: z.ZodOptional<z.ZodString>;
+        coalesceKey: z.ZodOptional<z.ZodString>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        accepted: z.ZodBoolean;
+        notificationId: z.ZodOptional<z.ZodString>;
+        decision: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const CREATE_AGENT_CONTROLLER_THREAD_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/threads";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        title?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
         id: string;
         title?: string | undefined;
+        resourceId?: string | undefined;
+        createdAt?: string | undefined;
         updatedAt?: string | undefined;
-        tags?: Record<string, string> | undefined;
-        state?: "active" | "idle" | undefined;
-    }[];
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    sessionScope: z.ZodOptional<z.ZodString>;
-    tags: z.ZodOptional<z.ZodPreprocess<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>>;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    threads: z.ZodArray<z.ZodObject<{
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
         id: z.ZodString;
         title: z.ZodOptional<z.ZodString>;
+        resourceId: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodOptional<z.ZodString>;
         updatedAt: z.ZodOptional<z.ZodString>;
-        tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        state: z.ZodOptional<z.ZodEnum<{
-            active: "active";
-            idle: "idle";
-        }>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, "GET", "/agent-controller/:controllerId/sessions/:resourceId/threads">;
-export declare const SEND_AGENT_CONTROLLER_NOTIFICATION_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    source: z.ZodString;
-    kind: z.ZodString;
-    summary: z.ZodString;
-    priority: z.ZodOptional<z.ZodEnum<{
-        low: "low";
-        medium: "medium";
-        high: "high";
-        urgent: "urgent";
-    }>>;
-    payload: z.ZodOptional<z.ZodUnknown>;
-    sourceId: z.ZodOptional<z.ZodString>;
-    dedupeKey: z.ZodOptional<z.ZodString>;
-    coalesceKey: z.ZodOptional<z.ZodString>;
-    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>>, {
-    accepted: boolean;
-    notificationId?: string | undefined;
-    decision?: string | undefined;
-    runId?: string | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    source: z.ZodString;
-    kind: z.ZodString;
-    summary: z.ZodString;
-    priority: z.ZodOptional<z.ZodEnum<{
-        low: "low";
-        medium: "medium";
-        high: "high";
-        urgent: "urgent";
-    }>>;
-    payload: z.ZodOptional<z.ZodUnknown>;
-    sourceId: z.ZodOptional<z.ZodString>;
-    dedupeKey: z.ZodOptional<z.ZodString>;
-    coalesceKey: z.ZodOptional<z.ZodString>;
-    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>, z.ZodObject<{
-    accepted: z.ZodBoolean;
-    notificationId: z.ZodOptional<z.ZodString>;
-    decision: z.ZodOptional<z.ZodString>;
-    runId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/notifications">;
-export declare const CREATE_AGENT_CONTROLLER_THREAD_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    title: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>, {
-    id: string;
-    title?: string | undefined;
-    resourceId?: string | undefined;
-    createdAt?: string | undefined;
-    updatedAt?: string | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    title: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodOptional<z.ZodString>;
-    resourceId: z.ZodOptional<z.ZodString>;
-    createdAt: z.ZodOptional<z.ZodString>;
-    updatedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/threads">;
-export declare const DELETE_AGENT_CONTROLLER_THREAD_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-    threadId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-    threadId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "DELETE", "/agent-controller/:controllerId/sessions/:resourceId/threads/:threadId">;
-export declare const RENAME_AGENT_CONTROLLER_THREAD_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-    threadId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    title: z.ZodString;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-    threadId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    title: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "PUT", "/agent-controller/:controllerId/sessions/:resourceId/threads/:threadId">;
-export declare const CLONE_AGENT_CONTROLLER_THREAD_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    sourceThreadId: z.ZodOptional<z.ZodString>;
-    title: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>, {
-    id: string;
-    title?: string | undefined;
-    resourceId?: string | undefined;
-    createdAt?: string | undefined;
-    updatedAt?: string | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    sourceThreadId: z.ZodOptional<z.ZodString>;
-    title: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodOptional<z.ZodString>;
-    resourceId: z.ZodOptional<z.ZodString>;
-    createdAt: z.ZodOptional<z.ZodString>;
-    updatedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/threads/clone">;
-export declare const LIST_AGENT_CONTROLLER_THREAD_MESSAGES_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-    threadId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined>, {
-    messages: {
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const DELETE_AGENT_CONTROLLER_THREAD_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "DELETE";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/threads/:threadId";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+        threadId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+        threadId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const RENAME_AGENT_CONTROLLER_THREAD_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "PUT";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/threads/:threadId";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+        threadId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        title: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+        threadId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        title: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const CLONE_AGENT_CONTROLLER_THREAD_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/threads/clone";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        sourceThreadId?: string | undefined;
+        title?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
         id: string;
-        role: "tool" | "user" | "system" | "signal" | "assistant";
-        content: {
-            [x: string]: unknown;
-            format: 2;
-            parts: {
-                [x: string]: unknown;
-                type: string;
-            }[];
-        };
-        createdAt?: string | undefined;
-        threadId?: string | undefined;
+        title?: string | undefined;
         resourceId?: string | undefined;
-        type?: string | undefined;
-    }[];
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-    threadId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    messages: z.ZodArray<z.ZodObject<{
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        sourceThreadId: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
         id: z.ZodString;
-        role: z.ZodEnum<{
-            tool: "tool";
-            user: "user";
-            system: "system";
-            signal: "signal";
-            assistant: "assistant";
-        }>;
-        content: z.ZodObject<{
-            format: z.ZodLiteral<2>;
-            parts: z.ZodArray<z.ZodObject<{
-                type: z.ZodString;
-            }, z.core.$loose>>;
-        }, z.core.$loose>;
-        createdAt: z.ZodOptional<z.ZodString>;
-        threadId: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
         resourceId: z.ZodOptional<z.ZodString>;
-        type: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, "GET", "/agent-controller/:controllerId/sessions/:resourceId/threads/:threadId/messages">;
-export declare const FOLLOW_UP_AGENT_CONTROLLER_SESSION_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    message: z.ZodString;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    message: z.ZodString;
-    requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/follow-up">;
-export declare const LIST_AGENT_CONTROLLER_MODELS_ROUTE: import("../server-adapter").ServerRoute<{
-    controllerId: string;
-}, {
-    models: {
-        id: string;
-        provider: string;
-        modelName: string;
-        hasApiKey: boolean;
-        useCount: number;
-    }[];
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-}, z.core.$strip>, undefined, undefined, z.ZodObject<{
-    models: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        provider: z.ZodString;
-        modelName: z.ZodString;
-        hasApiKey: z.ZodBoolean;
-        useCount: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, "GET", "/agent-controller/:controllerId/models">;
-export declare const GET_AGENT_CONTROLLER_WORKSPACE_STATUS_ROUTE: import("../server-adapter").ServerRoute<{
-    controllerId: string;
-}, {
-    hasWorkspace: boolean;
-    isReady: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-}, z.core.$strip>, undefined, undefined, z.ZodObject<{
-    hasWorkspace: z.ZodBoolean;
-    isReady: z.ZodBoolean;
-}, z.core.$strip>>, "GET", "/agent-controller/:controllerId/workspace">;
-export declare const GET_AGENT_CONTROLLER_OM_RECORD_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined>, {
-    record?: unknown;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    record: z.ZodOptional<z.ZodUnknown>;
-}, z.core.$strip>>, "GET", "/agent-controller/:controllerId/sessions/:resourceId/om">;
-export declare const SET_AGENT_CONTROLLER_RESOURCE_ID_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    newResourceId: z.ZodString;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    newResourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/resource">;
-export declare const GET_AGENT_CONTROLLER_RESOURCE_IDS_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined>, {
-    resourceIds: string[];
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    resourceIds: z.ZodArray<z.ZodString>;
-}, z.core.$strip>>, "GET", "/agent-controller/:controllerId/sessions/:resourceId/resources">;
-export declare const GET_AGENT_CONTROLLER_GOAL_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined>, {
-    goal?: {
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const LIST_AGENT_CONTROLLER_THREAD_MESSAGES_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/threads/:threadId/messages";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+        threadId: string;
+    } & {
+        limit?: number | undefined;
+        sessionScope?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        messages: {
+            id: string;
+            role: "tool" | "user" | "system" | "signal" | "assistant";
+            content: {
+                [x: string]: unknown;
+                format: 2;
+                parts: {
+                    [x: string]: unknown;
+                    type: string;
+                }[];
+            };
+            createdAt?: string | undefined;
+            threadId?: string | undefined;
+            resourceId?: string | undefined;
+            type?: string | undefined;
+        }[];
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+        threadId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        messages: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodEnum<{
+                tool: "tool";
+                user: "user";
+                system: "system";
+                signal: "signal";
+                assistant: "assistant";
+            }>;
+            content: z.ZodObject<{
+                format: z.ZodLiteral<2>;
+                parts: z.ZodArray<z.ZodObject<{
+                    type: z.ZodString;
+                }, z.core.$loose>>;
+            }, z.core.$loose>;
+            createdAt: z.ZodOptional<z.ZodString>;
+            threadId: z.ZodOptional<z.ZodString>;
+            resourceId: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const FOLLOW_UP_AGENT_CONTROLLER_SESSION_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/follow-up";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        message: string;
+        requestContext?: Record<string, unknown> | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        message: z.ZodString;
+        requestContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const LIST_AGENT_CONTROLLER_MODELS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/agent-controller/:controllerId/models";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        models: {
+            id: string;
+            provider: string;
+            modelName: string;
+            hasApiKey: boolean;
+            useCount: number;
+        }[];
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+    }, z.core.$strip>, undefined, undefined, z.ZodObject<{
+        models: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            provider: z.ZodString;
+            modelName: z.ZodString;
+            hasApiKey: z.ZodBoolean;
+            useCount: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const GET_AGENT_CONTROLLER_WORKSPACE_STATUS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/agent-controller/:controllerId/workspace";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        hasWorkspace: boolean;
+        isReady: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+    }, z.core.$strip>, undefined, undefined, z.ZodObject<{
+        hasWorkspace: z.ZodBoolean;
+        isReady: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const GET_AGENT_CONTROLLER_OM_RECORD_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/om";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        record?: unknown;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        record: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const SET_AGENT_CONTROLLER_RESOURCE_ID_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/resource";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        newResourceId: string;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        newResourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const GET_AGENT_CONTROLLER_RESOURCE_IDS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/resources";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        resourceIds: string[];
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        resourceIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const GET_AGENT_CONTROLLER_GOAL_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/goal";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        goal?: {
+            objective: string;
+            status: "paused" | "active" | "done";
+            runsUsed: number;
+            startedAt: number;
+            updatedAt: number;
+            id?: string | undefined;
+            maxRuns?: number | undefined;
+            judgeModelId?: string | undefined;
+            pausedReason?: string | undefined;
+        } | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        goal: z.ZodOptional<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            objective: z.ZodString;
+            status: z.ZodEnum<{
+                paused: "paused";
+                active: "active";
+                done: "done";
+            }>;
+            runsUsed: z.ZodNumber;
+            maxRuns: z.ZodOptional<z.ZodNumber>;
+            judgeModelId: z.ZodOptional<z.ZodString>;
+            startedAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            pausedReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const SET_AGENT_CONTROLLER_GOAL_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "POST";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/goal";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
         objective: string;
-        status: "paused" | "active" | "done";
-        runsUsed: number;
-        startedAt: number;
-        updatedAt: number;
-        id?: string | undefined;
-        maxRuns?: number | undefined;
         judgeModelId?: string | undefined;
-        pausedReason?: string | undefined;
-    } | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    goal: z.ZodOptional<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        objective: z.ZodString;
-        status: z.ZodEnum<{
-            paused: "paused";
-            active: "active";
-            done: "done";
-        }>;
-        runsUsed: z.ZodNumber;
-        maxRuns: z.ZodOptional<z.ZodNumber>;
-        judgeModelId: z.ZodOptional<z.ZodString>;
-        startedAt: z.ZodNumber;
-        updatedAt: z.ZodNumber;
-        pausedReason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, "GET", "/agent-controller/:controllerId/sessions/:resourceId/goal">;
-export declare const SET_AGENT_CONTROLLER_GOAL_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    objective: z.ZodString;
-    judgeModelId: z.ZodOptional<z.ZodString>;
-    maxRuns: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>>, {
-    goal?: {
-        objective: string;
-        status: "paused" | "active" | "done";
-        runsUsed: number;
-        startedAt: number;
-        updatedAt: number;
-        id?: string | undefined;
         maxRuns?: number | undefined;
-        judgeModelId?: string | undefined;
-        pausedReason?: string | undefined;
-    } | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    objective: z.ZodString;
-    judgeModelId: z.ZodOptional<z.ZodString>;
-    maxRuns: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodObject<{
-    goal: z.ZodOptional<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
+    } & import("../server-adapter").ServerContext): Promise<{
+        goal?: {
+            objective: string;
+            status: "paused" | "active" | "done";
+            runsUsed: number;
+            startedAt: number;
+            updatedAt: number;
+            id?: string | undefined;
+            maxRuns?: number | undefined;
+            judgeModelId?: string | undefined;
+            pausedReason?: string | undefined;
+        } | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
         objective: z.ZodString;
-        status: z.ZodEnum<{
-            paused: "paused";
-            active: "active";
-            done: "done";
-        }>;
-        runsUsed: z.ZodNumber;
-        maxRuns: z.ZodOptional<z.ZodNumber>;
         judgeModelId: z.ZodOptional<z.ZodString>;
-        startedAt: z.ZodNumber;
-        updatedAt: z.ZodNumber;
-        pausedReason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, "POST", "/agent-controller/:controllerId/sessions/:resourceId/goal">;
-export declare const UPDATE_AGENT_CONTROLLER_GOAL_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    judgeModelId: z.ZodOptional<z.ZodString>;
-    maxRuns: z.ZodOptional<z.ZodNumber>;
-    status: z.ZodOptional<z.ZodEnum<{
-        paused: "paused";
-        active: "active";
-        done: "done";
-    }>>;
-}, z.core.$strip>>, {
-    goal?: {
-        objective: string;
-        status: "paused" | "active" | "done";
-        runsUsed: number;
-        startedAt: number;
-        updatedAt: number;
-        id?: string | undefined;
-        maxRuns?: number | undefined;
+        maxRuns: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        goal: z.ZodOptional<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            objective: z.ZodString;
+            status: z.ZodEnum<{
+                paused: "paused";
+                active: "active";
+                done: "done";
+            }>;
+            runsUsed: z.ZodNumber;
+            maxRuns: z.ZodOptional<z.ZodNumber>;
+            judgeModelId: z.ZodOptional<z.ZodString>;
+            startedAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            pausedReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const UPDATE_AGENT_CONTROLLER_GOAL_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "PUT";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/goal";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
         judgeModelId?: string | undefined;
-        pausedReason?: string | undefined;
-    } | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    judgeModelId: z.ZodOptional<z.ZodString>;
-    maxRuns: z.ZodOptional<z.ZodNumber>;
-    status: z.ZodOptional<z.ZodEnum<{
-        paused: "paused";
-        active: "active";
-        done: "done";
-    }>>;
-}, z.core.$strip>, z.ZodObject<{
-    goal: z.ZodOptional<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        objective: z.ZodString;
-        status: z.ZodEnum<{
+        maxRuns?: number | undefined;
+        status?: "paused" | "active" | "done" | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        goal?: {
+            objective: string;
+            status: "paused" | "active" | "done";
+            runsUsed: number;
+            startedAt: number;
+            updatedAt: number;
+            id?: string | undefined;
+            maxRuns?: number | undefined;
+            judgeModelId?: string | undefined;
+            pausedReason?: string | undefined;
+        } | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        judgeModelId: z.ZodOptional<z.ZodString>;
+        maxRuns: z.ZodOptional<z.ZodNumber>;
+        status: z.ZodOptional<z.ZodEnum<{
             paused: "paused";
             active: "active";
             done: "done";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        goal: z.ZodOptional<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            objective: z.ZodString;
+            status: z.ZodEnum<{
+                paused: "paused";
+                active: "active";
+                done: "done";
+            }>;
+            runsUsed: z.ZodNumber;
+            maxRuns: z.ZodOptional<z.ZodNumber>;
+            judgeModelId: z.ZodOptional<z.ZodString>;
+            startedAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            pausedReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const CLEAR_AGENT_CONTROLLER_GOAL_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "DELETE";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/goal";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const GET_AGENT_CONTROLLER_PERMISSIONS_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "GET";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/permissions";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & import("../server-adapter").ServerContext): Promise<{
+        categories?: Record<string, "allow" | "ask" | "deny"> | undefined;
+        tools?: Record<string, "allow" | "ask" | "deny"> | undefined;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, undefined, z.ZodObject<{
+        categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>>>;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>>>;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const SET_AGENT_CONTROLLER_CATEGORY_PERMISSION_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "PUT";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/permissions/category";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        category: "execute" | "other" | "read" | "edit" | "mcp";
+        policy: "allow" | "ask" | "deny";
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        category: z.ZodEnum<{
+            execute: "execute";
+            other: "other";
+            read: "read";
+            edit: "edit";
+            mcp: "mcp";
         }>;
-        runsUsed: z.ZodNumber;
-        maxRuns: z.ZodOptional<z.ZodNumber>;
-        judgeModelId: z.ZodOptional<z.ZodString>;
-        startedAt: z.ZodNumber;
-        updatedAt: z.ZodNumber;
-        pausedReason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, "PUT", "/agent-controller/:controllerId/sessions/:resourceId/goal">;
-export declare const CLEAR_AGENT_CONTROLLER_GOAL_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "DELETE", "/agent-controller/:controllerId/sessions/:resourceId/goal">;
-export declare const GET_AGENT_CONTROLLER_PERMISSIONS_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined>, {
-    categories?: Record<string, "allow" | "ask" | "deny"> | undefined;
-    tools?: Record<string, "allow" | "ask" | "deny"> | undefined;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, undefined, z.ZodObject<{
-    categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
-        allow: "allow";
-        ask: "ask";
-        deny: "deny";
-    }>>>;
-    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
-        allow: "allow";
-        ask: "ask";
-        deny: "deny";
-    }>>>;
-}, z.core.$strip>>, "GET", "/agent-controller/:controllerId/sessions/:resourceId/permissions">;
-export declare const SET_AGENT_CONTROLLER_CATEGORY_PERMISSION_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    category: z.ZodEnum<{
-        execute: "execute";
-        other: "other";
-        read: "read";
-        edit: "edit";
-        mcp: "mcp";
-    }>;
-    policy: z.ZodEnum<{
-        allow: "allow";
-        ask: "ask";
-        deny: "deny";
-    }>;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    category: z.ZodEnum<{
-        execute: "execute";
-        other: "other";
-        read: "read";
-        edit: "edit";
-        mcp: "mcp";
-    }>;
-    policy: z.ZodEnum<{
-        allow: "allow";
-        ask: "ask";
-        deny: "deny";
-    }>;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "PUT", "/agent-controller/:controllerId/sessions/:resourceId/permissions/category">;
-export declare const SET_AGENT_CONTROLLER_TOOL_PERMISSION_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    toolName: z.ZodString;
-    policy: z.ZodEnum<{
-        allow: "allow";
-        ask: "ask";
-        deny: "deny";
-    }>;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    toolName: z.ZodString;
-    policy: z.ZodEnum<{
-        allow: "allow";
-        ask: "ask";
-        deny: "deny";
-    }>;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "PUT", "/agent-controller/:controllerId/sessions/:resourceId/permissions/tool">;
-export declare const SET_AGENT_CONTROLLER_SESSION_STATE_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>>, {
-    ok: boolean;
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    controllerId: z.ZodString;
-    resourceId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    sessionScope: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>, z.ZodObject<{
-    ok: z.ZodBoolean;
-}, z.core.$strip>>, "PUT", "/agent-controller/:controllerId/sessions/:resourceId/state">;
+        policy: z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const SET_AGENT_CONTROLLER_TOOL_PERMISSION_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "PUT";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/permissions/tool";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        toolName: string;
+        policy: "allow" | "ask" | "deny";
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        toolName: z.ZodString;
+        policy: z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
+export declare const SET_AGENT_CONTROLLER_SESSION_STATE_ROUTE: Omit<import("@mastra/core/server").ApiRoute, "path" | "method" | "handler" | "createHandler" | "openapi"> & {
+    method: "PUT";
+    path: "/agent-controller/:controllerId/sessions/:resourceId/state";
+    responseType: "json";
+    streamFormat?: "sse" | "stream";
+    sseFlushOnConnect?: boolean;
+    handler(params: {
+        controllerId: string;
+        resourceId: string;
+    } & {
+        sessionScope?: string | undefined;
+    } & {
+        state: Record<string, unknown>;
+    } & import("../server-adapter").ServerContext): Promise<{
+        ok: boolean;
+    }>;
+    pathParamSchema?: z.ZodType;
+    queryParamSchema?: z.ZodType;
+    bodySchema?: z.ZodType;
+    responseSchema?: z.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<z.ZodObject<{
+        controllerId: z.ZodString;
+        resourceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        sessionScope: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodBoolean;
+    }, z.core.$strip>> | undefined;
+} & {
+    readonly _mastraSchemaRoute: true;
+};
 //# sourceMappingURL=agent-controller.d.ts.map