@mastra/server 0.0.0-taofeeqInngest-20250603090617 → 0.0.0-tool-call-parts-20250630193309

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

@@ -5,6 +5,7 @@ import type { Artifact } from '@mastra/core/a2a';
 import type { BaseLogMessage } from '@mastra/core/logger';
 import { CoreMessage } from 'ai';
 import type { CoreMessage as CoreMessage_2 } from '@mastra/core/llm';
+import { DefaultEngineType } from '@mastra/core/workflows';
 import { EvalRow } from '@mastra/core/storage';
 import { GenerateObjectResult } from 'ai';
 import { GenerateTextResult } from 'ai';
@@ -15,19 +16,23 @@ 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 { MastraMemory } from '@mastra/core/memory';
 import { MastraMessageV1 } from '@mastra/core/memory';
 import type { Message } from '@mastra/core/a2a';
 import type { QueryResult } from '@mastra/core/vector';
 import { ReadableStream as ReadableStream_2 } from 'node:stream/web';
+import { ReadableStream as ReadableStream_3 } from 'stream/web';
 import { RuntimeContext } from '@mastra/core/runtime-context';
-import { RuntimeContext as RuntimeContext_2 } from '@mastra/core/di';
+import type { RuntimeContext as RuntimeContext_2 } from '@mastra/core/di';
 import type { SerializedStepFlowEntry } from '@mastra/core/workflows';
 import { Step } from '@mastra/core/workflows';
 import { StepExecutionContext } from '@mastra/core/workflows/legacy';
 import { StepGraph } from '@mastra/core/workflows/legacy';
+import { StepResult } from '@mastra/core/workflows';
 import { StorageThreadType } from '@mastra/core/memory';
+import { StreamEvent } from '@mastra/core/workflows';
 import { Task } from '@mastra/core/a2a';
 import { TaskAndHistory } from '@mastra/core/a2a';
 import type { TaskContext } from '@mastra/core/a2a';
@@ -38,12 +43,19 @@ 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 { WatchEvent } from '@mastra/core/workflows';
+import type { WatchEvent } from '@mastra/core/workflows';
 import type { Workflow } from '@mastra/core/workflows';
 import { WorkflowContext as WorkflowContext_2 } from '@mastra/core/workflows/legacy';
 import { WorkflowResult } from '@mastra/core/workflows';
 import type { WorkflowRuns } from '@mastra/core/storage';
+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 {
@@ -110,7 +122,7 @@ export declare function createTaskContext({ task, userMessage, history, activeCa
     activeCancellations: Set<string>;
 }): TaskContext;
 
-export declare function createThreadHandler({ mastra, agentId, body, }: Pick<MemoryContext, 'mastra' | 'agentId'> & {
+export declare function createThreadHandler({ mastra, agentId, body, networkId, runtimeContext, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'networkId' | 'runtimeContext'> & {
     body?: Omit<Parameters<MastraMemory['createThread']>[0], 'resourceId'> & {
         resourceId?: string;
     };
@@ -126,7 +138,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;
 }>;
 
@@ -140,27 +152,26 @@ export declare function describeIndex({ mastra, vectorName, indexName, }: Pick<V
     metric: string | undefined;
 }>;
 
-export declare function executeAgentToolHandler({ mastra, agentId, toolId, data, runtimeContext, runtimeContextFromRequest, }: Pick<ToolsContext, 'mastra' | 'toolId'> & {
+export declare function executeAgentToolHandler({ mastra, agentId, toolId, data, runtimeContext, }: Pick<ToolsContext, 'mastra' | 'toolId'> & {
     agentId?: string;
     data: any;
     runtimeContext: RuntimeContext_2;
-    runtimeContextFromRequest: Record<string, unknown>;
 }): Promise<any>;
 
-export declare function executeToolHandler(tools: ToolsContext['tools']): ({ mastra, runId, toolId, data, runtimeContext, runtimeContextFromRequest, }: Pick<ToolsContext, "mastra" | "toolId" | "runId"> & {
+export declare function executeToolHandler(tools: ToolsContext['tools']): ({ mastra, runId, toolId, data, runtimeContext, }: Pick<ToolsContext, "mastra" | "toolId" | "runId"> & {
     data?: unknown;
     runtimeContext: RuntimeContext_2;
-    runtimeContextFromRequest: Record<string, unknown>;
 }) => 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;
@@ -179,7 +190,22 @@ 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<{
@@ -216,7 +242,17 @@ export declare function getAgentExecutionHandler({ requestId, mastra, agentId, r
 
 export declare function getAgentsHandler({ mastra, runtimeContext }: Context & {
     runtimeContext: RuntimeContext;
-}): Promise<any>;
+}): 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;
@@ -273,19 +309,31 @@ export declare function getLiveEvalsByAgentIdHandler({ mastra, runtimeContext, a
     evals: EvalRow[];
 }>;
 
-export declare function getLogsByRunIdHandler({ mastra, runId, transportId, }: Pick<LogsContext, 'mastra' | 'runId' | 'transportId'>): Promise<any[]>;
+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, limit, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId'> & {
+export declare function getMessagesHandler({ mastra, agentId, threadId, limit, networkId, runtimeContext, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId' | 'networkId' | 'runtimeContext'> & {
     limit?: number;
 }): Promise<{
     messages: CoreMessage[];
@@ -331,14 +379,64 @@ 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 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: SerializedStep[];
     name: string | undefined;
@@ -350,6 +448,8 @@ export declare function getWorkflowByIdHandler({ mastra, workflowId }: WorkflowC
 
 export declare function getWorkflowRunByIdHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'>): Promise<ReturnType<Workflow['getWorkflowRunById']>>;
 
+export declare function getWorkflowRunExecutionResultHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'>): Promise<WatchEvent['payload']['workflowState']>;
+
 export declare function getWorkflowRunsHandler({ mastra, workflowId, fromDate, toDate, limit, offset, resourceId, }: WorkflowContext_3 & {
     fromDate?: Date;
     toDate?: Date;
@@ -519,8 +619,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,
@@ -538,6 +702,8 @@ declare interface MemoryContext extends Context {
     agentId?: string;
     resourceId?: string;
     threadId?: string;
+    networkId?: string;
+    runtimeContext?: RuntimeContext_2;
 }
 
 export declare namespace network {
@@ -554,6 +720,11 @@ 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 {
@@ -578,14 +749,13 @@ export declare function resumeAsyncLegacyWorkflowHandler({ mastra, workflowId, r
     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, runtimeContextFromRequest, }: WorkflowContext_3 & {
+export declare function resumeAsyncWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: WorkflowContext_3 & {
     body: {
         step: string | string[];
         resumeData?: unknown;
     };
     runtimeContext?: RuntimeContext_2;
-    runtimeContextFromRequest?: Record<string, unknown>;
-}): Promise<WorkflowResult<ZodType<any, ZodTypeDef, any>, Step<string, any, any, any, any>[]>>;
+}): Promise<WorkflowResult<ZodType<any, ZodTypeDef, any>, Step<string, any, any, any, any, any>[]>>;
 
 export declare function resumeLegacyWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: WorkflowContext & {
     body: {
@@ -607,7 +777,7 @@ export declare function resumeWorkflowHandler({ mastra, workflowId, runId, body,
     message: string;
 }>;
 
-export declare function saveMessagesHandler({ mastra, agentId, body, }: Pick<MemoryContext, 'mastra' | 'agentId'> & {
+export declare function saveMessagesHandler({ mastra, agentId, body, networkId, runtimeContext, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'networkId' | 'runtimeContext'> & {
     body: {
         messages: Parameters<MastraMemory['saveMessages']>[0]['messages'];
     };
@@ -629,11 +799,10 @@ export declare function startAsyncLegacyWorkflowHandler({ mastra, runtimeContext
     runtimeContext: RuntimeContext;
 }): Promise<LegacyWorkflowRunResult<any, LegacyStep<string, any, any, StepExecutionContext<any, WorkflowContext_2<any, LegacyStep<string, any, any, any>[], Record<string, any>>>>[], any>>;
 
-export declare function startAsyncWorkflowHandler({ mastra, runtimeContext, workflowId, runId, inputData, runtimeContextFromRequest, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'> & {
+export declare function startAsyncWorkflowHandler({ mastra, runtimeContext, workflowId, runId, inputData, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'> & {
     inputData?: unknown;
     runtimeContext?: RuntimeContext_2;
-    runtimeContextFromRequest?: Record<string, unknown>;
-}): Promise<WorkflowResult<ZodType<any, ZodTypeDef, any>, Step<string, any, any, any, any>[]>>;
+}): 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;
@@ -642,10 +811,9 @@ export declare function startLegacyWorkflowRunHandler({ mastra, runtimeContext,
     message: string;
 }>;
 
-export declare function startWorkflowRunHandler({ mastra, runtimeContext, workflowId, runId, inputData, runtimeContextFromRequest, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'> & {
+export declare function startWorkflowRunHandler({ mastra, runtimeContext, workflowId, runId, inputData, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'> & {
     inputData?: unknown;
     runtimeContext?: RuntimeContext_2;
-    runtimeContextFromRequest?: Record<string, unknown>;
 }): Promise<{
     message: string;
 }>;
@@ -673,13 +841,14 @@ export declare function storeTelemetryHandler({ mastra, body }: Context & {
     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 & {
@@ -689,14 +858,61 @@ export declare function streamGenerateHandler_alias_1({ mastra, networkId, body,
     } & Parameters<AgentNetwork['stream']>[1];
 }): Promise<Response>;
 
-export declare function streamWorkflowHandler({ mastra, runtimeContext, workflowId, runId, inputData, runtimeContextFromRequest, }: Pick<WorkflowContext_3, 'mastra' | 'workflowId' | 'runId'> & {
+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;
-    runtimeContextFromRequest?: Record<string, unknown>;
-}): {
-    stream: globalThis.ReadableStream<WatchEvent>;
-    getWorkflowState: () => Promise<WorkflowResult<ZodType<any, ZodTypeDef, any>, Step<string, any, any, any, any>[]>>;
-};
+}): 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;
 
@@ -764,7 +980,7 @@ 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>;
 
@@ -830,6 +1046,7 @@ export declare namespace workflows {
         getWorkflowsHandler,
         getWorkflowByIdHandler,
         getWorkflowRunByIdHandler,
+        getWorkflowRunExecutionResultHandler,
         createWorkflowRunHandler,
         startAsyncWorkflowHandler,
         startWorkflowRunHandler,