@mastra/server 0.0.0-separate-trace-data-from-component-20250501042644 → 0.0.0-share-agent-metadata-with-cloud-20250718110128

package/dist/_tsup-dts-rollup.d.ts

@@ -1,35 +1,76 @@
 import type { Agent } from '@mastra/core/agent';
+import type { AgentCard } from '@mastra/core/a2a';
 import type { AgentNetwork } from '@mastra/core/network';
+import type { Artifact } from '@mastra/core/a2a';
 import type { BaseLogMessage } from '@mastra/core/logger';
 import { CoreMessage } from 'ai';
-import { EvalRow } from '@mastra/core/storage';
+import type { CoreMessage as CoreMessage_2 } from '@mastra/core/llm';
+import { DefaultEngineType } from '@mastra/core';
+import { EvalRow } from '@mastra/core';
 import { GenerateObjectResult } from 'ai';
 import { GenerateTextResult } from 'ai';
+import type { IMastraLogger } from '@mastra/core/logger';
+import type { JSONRPCError } from '@mastra/core/a2a';
+import { JSONRPCResponse } from '@mastra/core/a2a';
+import { LegacyStep } from '@mastra/core/workflows/legacy';
+import type { LegacyWorkflow } from '@mastra/core/workflows/legacy';
+import { LegacyWorkflowRunResult } from '@mastra/core/workflows/legacy';
+import type { LegacyWorkflowRuns } from '@mastra/core/storage';
+import type { LogLevel } from '@mastra/core/logger';
 import type { Mastra } from '@mastra/core/mastra';
+import type { MastraError } from '@mastra/core/error';
 import type { MastraMemory } from '@mastra/core/memory';
-import { Message } from 'ai';
-import { MessageType } from '@mastra/core/memory';
-import { NewStep } from '@mastra/core/workflows/vNext';
-import type { NewWorkflow } from '@mastra/core/workflows/vNext';
+import { MastraMessageV1 } from '@mastra/core';
+import type { Message } from '@mastra/core/a2a';
 import type { QueryResult } from '@mastra/core/vector';
 import { ReadableStream as ReadableStream_2 } from 'node:stream/web';
-import type { RuntimeContext } from '@mastra/core/runtime-context';
+import { ReadableStream as ReadableStream_3 } from 'stream/web';
+import { RuntimeContext } from '@mastra/core/runtime-context';
 import type { RuntimeContext as RuntimeContext_2 } from '@mastra/core/di';
-import { SerializedStepFlowEntry } from '@mastra/core/workflows/vNext';
-import { Step } from '@mastra/core/workflows';
-import { StepExecutionContext } from '@mastra/core/workflows';
-import { StepGraph } from '@mastra/core/workflows';
-import { StorageThreadType } from '@mastra/core/memory';
+import type { SerializedStepFlowEntry } from '@mastra/core/workflows';
+import { Step } from '@mastra/core';
+import { StepExecutionContext } from '@mastra/core/workflows/legacy';
+import { StepGraph } from '@mastra/core/workflows/legacy';
+import { StepResult } from '@mastra/core';
+import { StorageThreadType } from '@mastra/core';
+import { StreamEvent } from '@mastra/core';
+import { Task } from '@mastra/core/a2a';
+import { TaskAndHistory } from '@mastra/core/a2a';
+import type { TaskContext } from '@mastra/core/a2a';
+import type { TaskIdParams } from '@mastra/core/a2a';
+import type { TaskQueryParams } from '@mastra/core/a2a';
+import type { TaskSendParams } from '@mastra/core/a2a';
+import type { TaskStatus } from '@mastra/core/a2a';
 import type { ToolAction } from '@mastra/core/tools';
+import { UIMessage } from 'ai';
 import type { VercelTool } from '@mastra/core/tools';
+import type { WatchEvent } from '@mastra/core/workflows';
 import type { Workflow } from '@mastra/core/workflows';
-import { WorkflowContext as WorkflowContext_2 } from '@mastra/core/workflows';
-import { WorkflowResult } from '@mastra/core/workflows/vNext';
-import { WorkflowRunResult } from '@mastra/core/workflows';
+import { WorkflowContext as WorkflowContext_2 } from '@mastra/core/workflows/legacy';
+import { WorkflowResult } from '@mastra/core';
 import type { WorkflowRuns } from '@mastra/core/storage';
+import { WorkingMemoryTemplate } from '@mastra/core';
+import { ZodBoolean } from 'zod';
+import { ZodEnum } from 'zod';
+import { ZodNumber } from 'zod';
+import { ZodObject } from 'zod';
+import { ZodOptional } from 'zod';
+import { ZodString } from 'zod';
 import { ZodType } from 'zod';
+import { ZodTypeAny } from 'zod';
 import { ZodTypeDef } from 'zod';
 
+export declare namespace a2a {
+    export {
+        getAgentCardByIdHandler,
+        handleTaskSend,
+        handleTaskGet,
+        handleTaskSendSubscribe,
+        handleTaskCancel,
+        getAgentExecutionHandler
+    }
+}
+
 export declare namespace agents {
     export {
         getAgentsHandler,
@@ -41,17 +82,27 @@ export declare namespace agents {
     }
 }
 
-export declare interface ApiError extends Error {
+export declare interface ApiError extends MastraError {
     message: string;
     status?: number;
 }
 
+export declare function applyUpdateToTaskAndHistory(current: TaskAndHistory, update: Omit<TaskStatus, 'timestamp'> | Artifact): TaskAndHistory;
+
+export declare function cancelWorkflowRunHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'>): Promise<{
+    message: string;
+}>;
+
 declare type ClientErrorStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
 
 export declare interface Context {
     mastra: Mastra;
 }
 
+export declare function convertToCoreMessage(message: Message): CoreMessage_2;
+
+export declare function createErrorResponse(id: number | string | null, error: JSONRPCError<unknown>): JSONRPCResponse<null, unknown>;
+
 export declare function createIndex({ mastra, vectorName, index, }: Pick<VectorContext, 'mastra' | 'vectorName'> & {
     index: CreateIndexRequest;
 }): Promise<{
@@ -64,17 +115,26 @@ declare interface CreateIndexRequest {
     metric?: 'cosine' | 'euclidean' | 'dotproduct';
 }
 
-export declare function createRunHandler({ mastra, workflowId, runId: prevRunId, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<{
+export declare function createLegacyWorkflowRunHandler({ mastra, workflowId, runId: prevRunId, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<{
     runId: string;
 }>;
 
-export declare function createThreadHandler({ mastra, agentId, body, }: Pick<MemoryContext, 'mastra' | 'agentId'> & {
+export declare function createSuccessResponse<T>(id: number | string | null, result: T): JSONRPCResponse<T>;
+
+export declare function createTaskContext({ task, userMessage, history, activeCancellations, }: {
+    task: Task;
+    userMessage: Message;
+    history: Message[];
+    activeCancellations: Set<string>;
+}): TaskContext;
+
+export declare function createThreadHandler({ mastra, agentId, body, networkId, runtimeContext, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'networkId' | 'runtimeContext'> & {
     body?: Omit<Parameters<MastraMemory['createThread']>[0], 'resourceId'> & {
         resourceId?: string;
     };
 }): Promise<StorageThreadType>;
 
-export declare function createVNextWorkflowRunHandler({ mastra, workflowId, runId: prevRunId, }: Pick<VNextWorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<{
+export declare function createWorkflowRunHandler({ mastra, workflowId, runId: prevRunId, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'>): Promise<{
     runId: string;
 }>;
 
@@ -84,7 +144,7 @@ export declare function deleteIndex({ mastra, vectorName, indexName, }: Pick<Vec
     success: boolean;
 }>;
 
-export declare function deleteThreadHandler({ mastra, agentId, threadId, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId'>): Promise<{
+export declare function deleteThreadHandler({ mastra, agentId, threadId, networkId, runtimeContext, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId' | 'networkId' | 'runtimeContext'>): Promise<{
     result: string;
 }>;
 
@@ -101,21 +161,23 @@ export declare function describeIndex({ mastra, vectorName, indexName, }: Pick<V
 export declare function executeAgentToolHandler({ mastra, agentId, toolId, data, runtimeContext, }: Pick<ToolsContext, 'mastra' | 'toolId'> & {
     agentId?: string;
     data: any;
-    runtimeContext: RuntimeContext;
+    runtimeContext: RuntimeContext_2;
 }): Promise<any>;
 
 export declare function executeToolHandler(tools: ToolsContext['tools']): ({ mastra, runId, toolId, data, runtimeContext, }: Pick<ToolsContext, "mastra" | "toolId" | "runId"> & {
     data?: unknown;
-    runtimeContext: RuntimeContext;
+    runtimeContext: RuntimeContext_2;
 }) => Promise<any>;
 
-export declare function generateHandler({ mastra, runtimeContext, agentId, body, }: Context & {
+export declare function generateHandler({ mastra, runtimeContext, agentId, body, abortSignal, }: Context & {
     runtimeContext: RuntimeContext;
     agentId: string;
     body: GetBody<'generate'> & {
         resourceid?: string;
+        runtimeContext?: Record<string, unknown>;
     };
-}): Promise<GenerateTextResult<any, any>>;
+    abortSignal?: AbortSignal;
+}): Promise<GenerateTextResult<any, unknown>>;
 
 export declare function generateHandler_alias_1({ mastra, runtimeContext, networkId, body, }: NetworkContext & {
     runtimeContext: RuntimeContext;
@@ -134,21 +196,70 @@ export declare function generateSpeechHandler({ mastra, agentId, body, }: VoiceC
     };
 }): Promise<NodeJS.ReadableStream>;
 
-export declare function getAgentByIdHandler({ mastra, runtimeContext, agentId, }: Context & {
+export declare function generateVNextNetworkHandler({ mastra, runtimeContext, networkId, body, }: NetworkContext_2 & {
+    runtimeContext: RuntimeContext;
+    body: {
+        message: string;
+        threadId?: string;
+        resourceId?: string;
+    };
+}): Promise<{
+    task: string;
+    result: string;
+    resourceId: string;
+    resourceType: "none" | "tool" | "workflow" | "agent";
+}>;
+
+export declare function getAgentByIdHandler({ mastra, runtimeContext, agentId, isPlayground, }: Context & {
+    isPlayground?: boolean;
     runtimeContext: RuntimeContext;
     agentId: string;
 }): Promise<{
     name: any;
     instructions: string;
     tools: any;
+    workflows: {};
     provider: string;
     modelId: string;
+    defaultGenerateOptions: any;
+    defaultStreamOptions: any;
 }>;
 
-export declare function getAgentsHandler({ mastra, runtimeContext }: Context & {
+export declare function getAgentCardByIdHandler({ mastra, agentId, executionUrl, provider, version, runtimeContext, }: Context & {
+    runtimeContext: RuntimeContext;
+    agentId: keyof ReturnType<typeof mastra.getAgents>;
+    executionUrl?: string;
+    version?: string;
+    provider?: {
+        organization: string;
+        url: string;
+    };
+}): Promise<AgentCard>;
+
+export declare function getAgentExecutionHandler({ requestId, mastra, agentId, runtimeContext, method, params, taskStore, logger, }: Context & {
+    requestId: string;
     runtimeContext: RuntimeContext;
+    agentId: string;
+    method: 'tasks/send' | 'tasks/sendSubscribe' | 'tasks/get' | 'tasks/cancel';
+    params: TaskSendParams | TaskQueryParams | TaskIdParams;
+    taskStore?: InMemoryTaskStore;
+    logger?: IMastraLogger;
 }): Promise<any>;
 
+export declare function getAgentsHandler({ mastra, runtimeContext }: Context & {
+    runtimeContext: RuntimeContext;
+}): Promise<Record<string, Omit<{
+    id: string;
+    name: any;
+    instructions: string;
+    tools: any;
+    workflows: {};
+    provider: string;
+    modelId: string;
+    defaultGenerateOptions: any;
+    defaultStreamOptions: any;
+}, "id">>>;
+
 declare type GetBody<T extends keyof Agent & {
     [K in keyof Agent]: Agent[K] extends (...args: any) => any ? K : never;
 }[keyof Agent]> = {
@@ -165,6 +276,35 @@ export declare function getEvalsByAgentIdHandler({ mastra, runtimeContext, agent
     evals: EvalRow[];
 }>;
 
+export declare function getLegacyWorkflowByIdHandler({ mastra, workflowId }: WorkflowContext): Promise<{
+    stepGraph: StepGraph;
+    stepSubscriberGraph: Record<string, StepGraph>;
+    serializedStepGraph: StepGraph;
+    serializedStepSubscriberGraph: Record<string, StepGraph>;
+    name: string;
+    triggerSchema: string | undefined;
+    steps: any;
+}>;
+
+export declare function getLegacyWorkflowRunHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<ReturnType<LegacyWorkflow['getRun']>>;
+
+export declare function getLegacyWorkflowRunsHandler({ mastra, workflowId, fromDate, toDate, limit, offset, resourceId, }: WorkflowContext & {
+    fromDate?: Date;
+    toDate?: Date;
+    limit?: number;
+    offset?: number;
+    resourceId?: string;
+}): Promise<LegacyWorkflowRuns>;
+
+export declare function getLegacyWorkflowsHandler({ mastra }: WorkflowContext): Promise<any>;
+
+/**
+ * Get available listeners for an agent
+ */
+export declare function getListenerHandler({ mastra, agentId }: VoiceContext): Promise<{
+    enabled: boolean;
+}>;
+
 export declare function getLiveEvalsByAgentIdHandler({ mastra, runtimeContext, agentId, }: Context & {
     runtimeContext: RuntimeContext;
     agentId: string;
@@ -175,21 +315,35 @@ export declare function getLiveEvalsByAgentIdHandler({ mastra, runtimeContext, a
     evals: EvalRow[];
 }>;
 
-export declare function getLogsByRunIdHandler({ mastra, runId, transportId, }: Pick<LogsContext, 'mastra' | 'runId' | 'transportId'>): Promise<BaseLogMessage[] | undefined>;
+export declare function getLogsByRunIdHandler({ mastra, runId, transportId, params, }: Pick<LogsContext, 'mastra' | 'runId' | 'transportId' | 'params'>): Promise<{
+    logs: BaseLogMessage[];
+    total: number;
+    page: number;
+    perPage: number;
+    hasMore: boolean;
+}>;
 
-export declare function getLogsHandler({ mastra, transportId, }: Pick<LogsContext, 'mastra' | 'transportId'>): Promise<BaseLogMessage[]>;
+export declare function getLogsHandler({ mastra, transportId, params, }: Pick<LogsContext, 'mastra' | 'transportId' | 'params'>): Promise<{
+    logs: BaseLogMessage[];
+    total: number;
+    page: number;
+    perPage: number;
+    hasMore: boolean;
+}>;
 
 export declare function getLogTransports({ mastra }: Pick<LogsContext, 'mastra'>): Promise<{
     transports: string[];
 }>;
 
-export declare function getMemoryStatusHandler({ mastra, agentId }: Pick<MemoryContext, 'mastra' | 'agentId'>): Promise<{
+export declare function getMemoryStatusHandler({ mastra, agentId, networkId, runtimeContext, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'networkId' | 'runtimeContext'>): Promise<{
     result: boolean;
 }>;
 
-export declare function getMessagesHandler({ mastra, agentId, threadId, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId'>): Promise<{
+export declare function getMessagesHandler({ mastra, agentId, threadId, limit, networkId, runtimeContext, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId' | 'networkId' | 'runtimeContext'> & {
+    limit?: number;
+}): Promise<{
     messages: CoreMessage[];
-    uiMessages: Message[];
+    uiMessages: UIMessage[];
 }>;
 
 export declare function getNetworkByIdHandler({ mastra, networkId, runtimeContext, }: Pick<NetworkContext, 'mastra' | 'networkId' | 'runtimeContext'>): Promise<{
@@ -231,45 +385,148 @@ export declare function getSpeakersHandler({ mastra, agentId }: VoiceContext): P
 
 export declare function getTelemetryHandler({ mastra, body }: TelemetryContext): Promise<any[]>;
 
-export declare function getThreadByIdHandler({ mastra, agentId, threadId, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId'>): Promise<StorageThreadType>;
+export declare function getThreadByIdHandler({ mastra, agentId, threadId, networkId, runtimeContext, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId' | 'networkId' | 'runtimeContext'>): Promise<StorageThreadType>;
 
-export declare function getThreadsHandler({ mastra, agentId, resourceId, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'resourceId'>): Promise<StorageThreadType[]>;
+export declare function getThreadsHandler({ mastra, agentId, resourceId, networkId, runtimeContext, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'resourceId' | 'networkId' | 'runtimeContext'>): Promise<StorageThreadType[]>;
 
 export declare function getToolByIdHandler({ tools, toolId }: Pick<ToolsContext, 'tools' | 'toolId'>): Promise<any>;
 
 export declare function getToolsHandler({ tools }: Pick<ToolsContext, 'tools'>): Promise<Record<string, any>>;
 
-export declare function getVNextWorkflowByIdHandler({ mastra, workflowId }: VNextWorkflowContext): Promise<{
-    steps: any;
+export declare function getVNextNetworkByIdHandler({ mastra, networkId, runtimeContext, }: Pick<NetworkContext_2, 'mastra' | 'networkId' | 'runtimeContext'>): Promise<{
+    id: string;
+    name: string;
+    instructions: string;
+    agents: {
+        name: string;
+        provider: string;
+        modelId: string;
+    }[];
+    workflows: {
+        name: string | undefined;
+        description: string | undefined;
+        inputSchema: string | undefined;
+        outputSchema: string | undefined;
+    }[];
+    tools: {
+        id: string;
+        description: string;
+    }[];
+    routingModel: {
+        provider: string;
+        modelId: string;
+    };
+}>;
+
+export declare function getVNextNetworksHandler({ mastra, runtimeContext, }: Pick<NetworkContext_2, 'mastra' | 'runtimeContext'>): Promise<{
+    id: string;
+    name: string;
+    instructions: string;
+    tools: {
+        id: string;
+        description: string;
+    }[];
+    agents: {
+        name: string;
+        provider: string;
+        modelId: string;
+    }[];
+    workflows: {
+        name: string | undefined;
+        description: string | undefined;
+        inputSchema: string | undefined;
+        outputSchema: string | undefined;
+    }[];
+    routingModel: {
+        provider: string;
+        modelId: string;
+    };
+}[]>;
+
+export declare function getWorkflowByIdHandler({ mastra, workflowId }: WorkflowContext_3): Promise<{
+    steps: Record<string, SerializedStep>;
+    allSteps: Record<string, SerializedStep>;
     name: string | undefined;
+    description: string | undefined;
     stepGraph: SerializedStepFlowEntry[];
     inputSchema: string | undefined;
     outputSchema: string | undefined;
 }>;
 
-export declare function getVNextWorkflowRunHandler({ mastra, workflowId, runId, }: Pick<VNextWorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<ReturnType<NewWorkflow['getWorkflowRun']>>;
+export declare function getWorkflowRunByIdHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'>): Promise<ReturnType<Workflow['getWorkflowRunById']>>;
 
-export declare function getVNextWorkflowRunsHandler({ mastra, workflowId }: VNextWorkflowContext): Promise<WorkflowRuns>;
+export declare function getWorkflowRunExecutionResultHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'>): Promise<WatchEvent['payload']['workflowState']>;
 
-export declare function getVNextWorkflowsHandler({ mastra }: VNextWorkflowContext): Promise<any>;
+export declare function getWorkflowRunsHandler({ mastra, workflowId, fromDate, toDate, limit, offset, resourceId, }: WorkflowContext_3 & {
+    fromDate?: Date;
+    toDate?: Date;
+    limit?: number;
+    offset?: number;
+    resourceId?: string;
+}): Promise<WorkflowRuns>;
 
-export declare function getWorkflowByIdHandler({ mastra, workflowId }: WorkflowContext): Promise<{
-    stepGraph: StepGraph;
-    stepSubscriberGraph: Record<string, StepGraph>;
-    serializedStepGraph: StepGraph;
-    serializedStepSubscriberGraph: Record<string, StepGraph>;
-    name: string;
-    triggerSchema: string | undefined;
-    steps: any;
+export declare function getWorkflowsHandler({ mastra }: WorkflowContext_3): Promise<any>;
+
+/**
+ * Handler to get the working memory for a thread (optionally resource-scoped).
+ * @returns workingMemory - the working memory for the thread
+ * @returns source - thread or resource
+ */
+export declare function getWorkingMemoryHandler({ mastra, agentId, threadId, resourceId, networkId, runtimeContext, memoryConfig, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId' | 'networkId' | 'runtimeContext'> & {
+    resourceId?: Parameters<MastraMemory['getWorkingMemory']>[0]['resourceId'];
+    memoryConfig?: Parameters<MastraMemory['getWorkingMemory']>[0]['memoryConfig'];
+}): Promise<{
+    workingMemory: string | null;
+    source: string;
+    workingMemoryTemplate: WorkingMemoryTemplate | null;
+    threadExists: boolean;
 }>;
 
-export declare function getWorkflowRunHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<ReturnType<Workflow['getRun']>>;
+export declare function handleError(error: unknown, defaultMessage: string): never;
 
-export declare function getWorkflowRunsHandler({ mastra, workflowId }: WorkflowContext): Promise<WorkflowRuns>;
+export declare function handleTaskCancel({ requestId, taskStore, agentId, taskId, logger, }: {
+    requestId: string;
+    taskStore: InMemoryTaskStore;
+    agentId: string;
+    taskId: string;
+    logger?: IMastraLogger;
+}): Promise<JSONRPCResponse<Task, unknown>>;
 
-export declare function getWorkflowsHandler({ mastra }: WorkflowContext): Promise<any>;
+export declare function handleTaskGet({ requestId, taskStore, agentId, taskId, }: {
+    requestId: string;
+    taskStore: InMemoryTaskStore;
+    agentId: string;
+    taskId: string;
+}): Promise<JSONRPCResponse<TaskAndHistory, unknown>>;
+
+export declare function handleTaskSend({ requestId, params, taskStore, agent, agentId, logger, runtimeContext, }: {
+    requestId: string;
+    params: TaskSendParams;
+    taskStore: InMemoryTaskStore;
+    agent: Agent;
+    agentId: string;
+    logger?: IMastraLogger;
+    runtimeContext: RuntimeContext;
+}): Promise<JSONRPCResponse<null, unknown> | JSONRPCResponse<Task, unknown>>;
 
-export declare function handleError(error: unknown, defaultMessage: string): never;
+export declare function handleTaskSendSubscribe({ requestId, params, taskStore, agent, agentId, logger, runtimeContext, }: {
+    requestId: string;
+    params: TaskSendParams;
+    taskStore: InMemoryTaskStore;
+    agent: Agent;
+    agentId: string;
+    logger?: IMastraLogger;
+    runtimeContext: RuntimeContext;
+}): AsyncGenerator<JSONRPCResponse<null, unknown> | JSONRPCResponse<Task, unknown> | JSONRPCResponse<    {
+state: string;
+message: {
+role: string;
+parts: {
+type: string;
+text: string;
+}[];
+};
+}, unknown>, void, unknown>;
 
 /**
  * `HTTPException` must be used when a fatal error such as authentication failure occurs.
@@ -319,11 +576,13 @@ export declare class HTTPException extends Error {
  * @property res - Optional response object to use.
  * @property message - Optional custom error message.
  * @property cause - Optional cause of the error.
+ * @property stack - Optional stack trace for the error.
  */
 declare type HTTPExceptionOptions = {
     res?: Response;
     message?: string;
     cause?: unknown;
+    stack?: string;
 };
 
 /**
@@ -332,8 +591,46 @@ declare type HTTPExceptionOptions = {
  */
 declare type InfoStatusCode = 100 | 101 | 102 | 103;
 
+export declare class InMemoryTaskStore {
+    private store;
+    activeCancellations: Set<string>;
+    load({ agentId, taskId }: {
+        agentId: string;
+        taskId: string;
+    }): Promise<TaskAndHistory | null>;
+    save({ agentId, data }: {
+        agentId: string;
+        data: TaskAndHistory;
+    }): Promise<void>;
+}
+
+export declare namespace legacyWorkflows {
+    export {
+        getLegacyWorkflowsHandler,
+        getLegacyWorkflowByIdHandler,
+        startAsyncLegacyWorkflowHandler,
+        getLegacyWorkflowRunHandler,
+        createLegacyWorkflowRunHandler,
+        startLegacyWorkflowRunHandler,
+        watchLegacyWorkflowHandler,
+        resumeAsyncLegacyWorkflowHandler,
+        resumeLegacyWorkflowHandler,
+        getLegacyWorkflowRunsHandler
+    }
+}
+
 export declare function listIndexes({ mastra, vectorName }: Pick<VectorContext, 'mastra' | 'vectorName'>): Promise<string[]>;
 
+export declare function loadOrCreateTaskAndHistory({ agentId, taskId, taskStore, message, sessionId, metadata, logger, }: {
+    agentId: string;
+    taskId: string;
+    taskStore: InMemoryTaskStore;
+    message: Message;
+    sessionId?: string | null;
+    metadata?: Record<string, unknown> | null;
+    logger?: IMastraLogger;
+}): Promise<TaskAndHistory>;
+
 export declare namespace logs {
     export {
         getLogsHandler,
@@ -346,8 +643,72 @@ declare type LogsContext = {
     mastra: Mastra;
     transportId?: string;
     runId?: string;
+    params?: {
+        fromDate?: Date;
+        toDate?: Date;
+        logLevel?: LogLevel;
+        filters?: string | string[];
+        page?: number;
+        perPage?: number;
+    };
 };
 
+export declare function loopStreamVNextNetworkHandler({ mastra, networkId, body, runtimeContext, }: NetworkContext_2 & {
+    runtimeContext: RuntimeContext;
+    body: {
+        message: string;
+        threadId?: string;
+        resourceId?: string;
+        maxIterations?: number;
+    };
+}): Promise<{
+    stream: ReadableStream_3<StreamEvent>;
+    getWorkflowState: () => Promise<WorkflowResult<ZodObject<    {
+    task: ZodString;
+    resourceId: ZodString;
+    resourceType: ZodEnum<["agent", "workflow", "none", "tool", "none"]>;
+    prompt: ZodString;
+    result: ZodString;
+    isComplete: ZodOptional<ZodBoolean>;
+    completionReason: ZodOptional<ZodString>;
+    iteration: ZodNumber;
+    }, "strip", ZodTypeAny, {
+    prompt: string;
+    resourceId: string;
+    result: string;
+    task: string;
+    resourceType: "none" | "tool" | "workflow" | "agent";
+    iteration: number;
+    isComplete?: boolean | undefined;
+    completionReason?: string | undefined;
+    }, {
+    prompt: string;
+    resourceId: string;
+    result: string;
+    task: string;
+    resourceType: "none" | "tool" | "workflow" | "agent";
+    iteration: number;
+    isComplete?: boolean | undefined;
+    completionReason?: string | undefined;
+    }>, Step<string, any, any, any, any, DefaultEngineType>[]>>;
+}>;
+
+export declare function loopVNextNetworkHandler({ mastra, networkId, body, runtimeContext, }: NetworkContext_2 & {
+    runtimeContext: RuntimeContext;
+    body: {
+        message: string;
+    };
+}): Promise<{
+    status: "success";
+    result: {
+        text: string;
+        iteration: number;
+    };
+    steps: {
+        [x: string]: StepResult<any, any, any, any> | StepResult<unknown, unknown, unknown, unknown>;
+    };
+}>;
+
 export declare namespace memory {
     export {
         getMemoryStatusHandler,
@@ -357,7 +718,9 @@ export declare namespace memory {
         createThreadHandler,
         updateThreadHandler,
         deleteThreadHandler,
-        getMessagesHandler
+        getMessagesHandler,
+        getWorkingMemoryHandler,
+        updateWorkingMemoryHandler
     }
 }
 
@@ -365,6 +728,8 @@ declare interface MemoryContext extends Context {
     agentId?: string;
     resourceId?: string;
     threadId?: string;
+    networkId?: string;
+    runtimeContext?: RuntimeContext_2;
 }
 
 export declare namespace network {
@@ -381,6 +746,13 @@ declare interface NetworkContext extends Context {
     runtimeContext: RuntimeContext;
 }
 
+declare interface NetworkContext_2 extends Context {
+    networkId?: string;
+    runtimeContext: RuntimeContext;
+}
+
+export declare function normalizeError(error: any, reqId: number | string | null, taskId?: string, logger?: IMastraLogger): JSONRPCResponse<null, unknown>;
+
 declare interface QueryRequest {
     indexName: string;
     queryVector: number[];
@@ -395,23 +767,33 @@ export declare function queryVectors({ mastra, vectorName, query, }: Pick<Vector
 
 declare type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
 
-export declare function resumeAsyncVNextWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: VNextWorkflowContext & {
+export declare function resumeAsyncLegacyWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: WorkflowContext & {
+    body: {
+        stepId: string;
+        context: any;
+    };
+    runtimeContext: RuntimeContext;
+}): Promise<Omit<LegacyWorkflowRunResult<any, LegacyStep<string, any, any, StepExecutionContext<any, WorkflowContext_2<any, LegacyStep<string, any, any, any>[], Record<string, any>>>>[], any>, "runId"> | undefined>;
+
+export declare function resumeAsyncWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: WorkflowContext_3 & {
     body: {
         step: string | string[];
         resumeData?: unknown;
     };
     runtimeContext?: RuntimeContext_2;
-}): Promise<WorkflowResult<ZodType<any, ZodTypeDef, any>, NewStep<string, any, any, any, any>[]>>;
+}): Promise<WorkflowResult<ZodType<any, ZodTypeDef, any>, Step<string, any, any, any, any, any>[]>>;
 
-export declare function resumeAsyncWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: WorkflowContext & {
+export declare function resumeLegacyWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: WorkflowContext & {
     body: {
         stepId: string;
         context: any;
     };
     runtimeContext: RuntimeContext;
-}): Promise<Omit<WorkflowRunResult<any, Step<string, any, any, StepExecutionContext<any, WorkflowContext_2<any, Step<string, any, any, any>[], Record<string, any>>>>[], any>, "runId"> | undefined>;
+}): Promise<{
+    message: string;
+}>;
 
-export declare function resumeVNextWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: VNextWorkflowContext & {
+export declare function resumeWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: WorkflowContext_3 & {
     body: {
         step: string | string[];
         resumeData?: unknown;
@@ -421,44 +803,50 @@ export declare function resumeVNextWorkflowHandler({ mastra, workflowId, runId,
     message: string;
 }>;
 
-export declare function resumeWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: WorkflowContext & {
+export declare function saveMessagesHandler({ mastra, agentId, body, networkId, runtimeContext, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'networkId' | 'runtimeContext'> & {
     body: {
-        stepId: string;
-        context: any;
+        messages: Parameters<MastraMemory['saveMessages']>[0]['messages'];
     };
-    runtimeContext: RuntimeContext;
+}): Promise<MastraMessageV1[]>;
+
+export declare function sendWorkflowRunEventHandler({ mastra, workflowId, runId, event, data, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'> & {
+    event: string;
+    data: unknown;
 }): Promise<{
     message: string;
 }>;
 
-export declare function saveMessagesHandler({ mastra, agentId, body, }: Pick<MemoryContext, 'mastra' | 'agentId'> & {
-    body: {
-        messages: Parameters<MastraMemory['saveMessages']>[0]['messages'];
-    };
-}): Promise<MessageType[]>;
+declare type SerializedStep = {
+    id: string;
+    description: string;
+    inputSchema: string | undefined;
+    outputSchema: string | undefined;
+    resumeSchema: string | undefined;
+    suspendSchema: string | undefined;
+};
 
 declare type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
 
-export declare function startAsyncVNextWorkflowHandler({ mastra, runtimeContext, workflowId, runId, inputData, }: Pick<VNextWorkflowContext, 'mastra' | 'workflowId' | 'runId'> & {
-    inputData?: unknown;
-    runtimeContext?: RuntimeContext_2;
-}): Promise<WorkflowResult<ZodType<any, ZodTypeDef, any>, NewStep<string, any, any, any, any>[]>>;
-
-export declare function startAsyncWorkflowHandler({ mastra, runtimeContext, workflowId, runId, triggerData, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'> & {
+export declare function startAsyncLegacyWorkflowHandler({ mastra, runtimeContext, workflowId, runId, triggerData, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'> & {
     triggerData?: unknown;
     runtimeContext: RuntimeContext;
-}): Promise<WorkflowRunResult<any, Step<string, any, any, StepExecutionContext<any, WorkflowContext_2<any, Step<string, any, any, any>[], Record<string, any>>>>[], any>>;
+}): Promise<LegacyWorkflowRunResult<any, LegacyStep<string, any, any, StepExecutionContext<any, WorkflowContext_2<any, LegacyStep<string, any, any, any>[], Record<string, any>>>>[], any>>;
 
-export declare function startVNextWorkflowRunHandler({ mastra, runtimeContext, workflowId, runId, inputData, }: Pick<VNextWorkflowContext, 'mastra' | 'workflowId' | 'runId'> & {
+export declare function startAsyncWorkflowHandler({ mastra, runtimeContext, workflowId, runId, inputData, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'> & {
     inputData?: unknown;
     runtimeContext?: RuntimeContext_2;
+}): Promise<WorkflowResult<ZodType<any, ZodTypeDef, any>, Step<string, any, any, any, any, any>[]>>;
+
+export declare function startLegacyWorkflowRunHandler({ mastra, runtimeContext, workflowId, runId, triggerData, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'> & {
+    triggerData?: unknown;
+    runtimeContext: RuntimeContext;
 }): Promise<{
     message: string;
 }>;
 
-export declare function startWorkflowRunHandler({ mastra, runtimeContext, workflowId, runId, triggerData, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'> & {
-    triggerData?: unknown;
-    runtimeContext: RuntimeContext;
+export declare function startWorkflowRunHandler({ mastra, runtimeContext, workflowId, runId, inputData, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'> & {
+    inputData?: unknown;
+    runtimeContext?: RuntimeContext_2;
 }): Promise<{
     message: string;
 }>;
@@ -476,18 +864,24 @@ export declare function storeTelemetryHandler({ mastra, body }: Context & {
     status: string;
     message: string;
     error: any;
+} | {
+    status: string;
+    message: string;
+    traceCount?: undefined;
 } | {
     status: string;
     message: string;
     traceCount: number;
 }>;
 
-export declare function streamGenerateHandler({ mastra, runtimeContext, agentId, body, }: Context & {
+export declare function streamGenerateHandler({ mastra, runtimeContext, agentId, body, abortSignal, }: Context & {
     runtimeContext: RuntimeContext;
     agentId: string;
     body: GetBody<'stream'> & {
         resourceid?: string;
+        runtimeContext?: string;
     };
+    abortSignal?: AbortSignal;
 }): Promise<Response | undefined>;
 
 export declare function streamGenerateHandler_alias_1({ mastra, networkId, body, runtimeContext, }: NetworkContext & {
@@ -497,6 +891,62 @@ export declare function streamGenerateHandler_alias_1({ mastra, networkId, body,
     } & Parameters<AgentNetwork['stream']>[1];
 }): Promise<Response>;
 
+export declare function streamGenerateVNextNetworkHandler({ mastra, networkId, body, runtimeContext, }: NetworkContext_2 & {
+    runtimeContext: RuntimeContext;
+    body: {
+        message: string;
+        threadId?: string;
+        resourceId?: string;
+    };
+}): Promise<{
+    stream: ReadableStream_3<StreamEvent>;
+    getWorkflowState: () => Promise<WorkflowResult<ZodObject<    {
+    task: ZodString;
+    resourceId: ZodString;
+    resourceType: ZodEnum<["agent", "workflow", "none", "tool", "none"]>;
+    prompt: ZodString;
+    result: ZodString;
+    isComplete: ZodOptional<ZodBoolean>;
+    completionReason: ZodOptional<ZodString>;
+    iteration: ZodNumber;
+    threadId: ZodOptional<ZodString>;
+    threadResourceId: ZodOptional<ZodString>;
+    isOneOff: ZodBoolean;
+    }, "strip", ZodTypeAny, {
+    prompt: string;
+    resourceId: string;
+    result: string;
+    task: string;
+    resourceType: "none" | "tool" | "workflow" | "agent";
+    iteration: number;
+    isOneOff: boolean;
+    threadId?: string | undefined;
+    threadResourceId?: string | undefined;
+    isComplete?: boolean | undefined;
+    completionReason?: string | undefined;
+    }, {
+    prompt: string;
+    resourceId: string;
+    result: string;
+    task: string;
+    resourceType: "none" | "tool" | "workflow" | "agent";
+    iteration: number;
+    isOneOff: boolean;
+    threadId?: string | undefined;
+    threadResourceId?: string | undefined;
+    isComplete?: boolean | undefined;
+    completionReason?: string | undefined;
+    }>, Step<string, any, any, any, any, DefaultEngineType>[]>>;
+}>;
+
+export declare function streamWorkflowHandler({ mastra, runtimeContext, workflowId, runId, inputData, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'> & {
+    inputData?: unknown;
+    runtimeContext?: RuntimeContext_2;
+}): Promise<{
+    stream: ReadableStream_2<StreamEvent>;
+    getWorkflowState: () => Promise<WorkflowResult<ZodType<any, ZodTypeDef, any>, Step<string, any, any, any, any, any>[]>>;
+}>;
+
 declare type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
 
 export declare namespace telemetry {
@@ -513,6 +963,8 @@ declare interface TelemetryContext extends Context {
         page?: number;
         perPage?: number;
         attribute?: string | string[];
+        fromDate?: Date;
+        toDate?: Date;
     };
 }
 
@@ -561,10 +1013,21 @@ export declare type UnOfficalStatusCode = UnofficialStatusCode;
  */
 export declare type UnofficialStatusCode = -1;
 
-export declare function updateThreadHandler({ mastra, agentId, threadId, body, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId'> & {
+export declare function updateThreadHandler({ mastra, agentId, threadId, body, networkId, runtimeContext, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId' | 'networkId' | 'runtimeContext'> & {
     body?: Parameters<MastraMemory['saveThread']>[0]['thread'];
 }): Promise<StorageThreadType>;
 
+/**
+ * Handler to update the working memory for a thread (optionally resource-scoped).
+ * @param threadId - the thread id
+ * @param body - the body containing the working memory to update and the resource id (optional)
+ */
+export declare function updateWorkingMemoryHandler({ mastra, agentId, threadId, body, networkId, runtimeContext, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId' | 'networkId' | 'runtimeContext'> & {
+    body: Omit<Parameters<MastraMemory['updateWorkingMemory']>[0], 'threadId'>;
+}): Promise<{
+    success: boolean;
+}>;
+
 declare interface UpsertRequest {
     indexName: string;
     vectors: number[][];
@@ -595,31 +1058,12 @@ declare interface VectorContext extends Context {
     vectorName?: string;
 }
 
-declare interface VNextWorkflowContext extends Context {
-    workflowId?: string;
-    runId?: string;
-}
-
-export declare namespace vNextWorkflows {
-    export {
-        getVNextWorkflowsHandler,
-        getVNextWorkflowByIdHandler,
-        getVNextWorkflowRunHandler,
-        createVNextWorkflowRunHandler,
-        startAsyncVNextWorkflowHandler,
-        startVNextWorkflowRunHandler,
-        watchVNextWorkflowHandler,
-        resumeAsyncVNextWorkflowHandler,
-        resumeVNextWorkflowHandler,
-        getVNextWorkflowRunsHandler
-    }
-}
-
 export declare namespace voice {
     export {
         getSpeakersHandler,
         generateSpeechHandler,
-        transcribeSpeechHandler
+        transcribeSpeechHandler,
+        getListenerHandler
     }
 }
 
@@ -627,27 +1071,36 @@ declare interface VoiceContext extends Context {
     agentId?: string;
 }
 
-export declare function watchVNextWorkflowHandler({ mastra, workflowId, runId, }: Pick<VNextWorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<ReadableStream_2<string>>;
+export declare function watchLegacyWorkflowHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<ReadableStream_2<string>>;
 
-export declare function watchWorkflowHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<ReadableStream_2<string>>;
+export declare function watchWorkflowHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'>): Promise<ReadableStream_2<string>>;
 
 declare interface WorkflowContext extends Context {
     workflowId?: string;
     runId?: string;
 }
 
+declare interface WorkflowContext_3 extends Context {
+    workflowId?: string;
+    runId?: string;
+}
+
 export declare namespace workflows {
     export {
         getWorkflowsHandler,
         getWorkflowByIdHandler,
+        getWorkflowRunByIdHandler,
+        getWorkflowRunExecutionResultHandler,
+        createWorkflowRunHandler,
         startAsyncWorkflowHandler,
-        getWorkflowRunHandler,
-        createRunHandler,
         startWorkflowRunHandler,
         watchWorkflowHandler,
+        streamWorkflowHandler,
         resumeAsyncWorkflowHandler,
         resumeWorkflowHandler,
-        getWorkflowRunsHandler
+        getWorkflowRunsHandler,
+        cancelWorkflowRunHandler,
+        sendWorkflowRunEventHandler
     }
 }