@mastra/server 0.0.0-a2a-20250421213654

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

@@ -0,0 +1,897 @@
+import { Agent } from '@mastra/core/agent';
+import type { AgentConfig } from '@mastra/core/agent';
+import type { AgentNetwork } from '@mastra/core/network';
+import type { BaseLogMessage } from '@mastra/core/logger';
+import type { Container } from '@mastra/core/di';
+import { CoreMessage } from 'ai';
+import { EvalRow } from '@mastra/core/storage';
+import { GenerateObjectResult } from 'ai';
+import { GenerateTextResult } from 'ai';
+import type { Mastra } from '@mastra/core/mastra';
+import type { MastraMemory } from '@mastra/core/memory';
+import { Message as Message_2 } from 'ai';
+import { MessageType } from '@mastra/core/memory';
+import type { QueryResult } from '@mastra/core/vector';
+import { ReadableStream as ReadableStream_2 } from 'node:stream/web';
+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 { ToolAction } from '@mastra/core/tools';
+import type { VercelTool } from '@mastra/core/tools';
+import type { Workflow } from '@mastra/core/workflows';
+import { WorkflowContext as WorkflowContext_2 } from '@mastra/core/workflows';
+import { WorkflowRunResult } from '@mastra/core/workflows';
+import type { WorkflowRuns } from '@mastra/core/storage';
+
+export declare namespace a2a {
+    export {
+        handleSendTask,
+        handleGetTask,
+        handleCancelTask,
+        handlePushNotification,
+        handleA2ARequest,
+        generateAgentCard,
+        handleAgentCardRequest
+    }
+}
+
+export declare type A2ARequest = SendTaskRequest | GetTaskRequest | CancelTaskRequest | SetTaskPushNotificationRequest | GetTaskPushNotificationRequest | TaskResubscriptionRequest;
+
+export declare type AgentAuthentication = {
+    schemes: string[];
+    credentials?: string | null;
+};
+
+export declare type AgentCapabilities = {
+    streaming?: boolean;
+    pushNotifications?: boolean;
+    stateTransitionHistory?: boolean;
+};
+
+export declare type AgentCard = {
+    name: string;
+    description?: string | null;
+    url: string;
+    provider?: AgentProvider | null;
+    version: string;
+    documentationUrl?: string | null;
+    capabilities: AgentCapabilities;
+    authentication?: AgentAuthentication | null;
+    defaultInputModes?: string[];
+    defaultOutputModes?: string[];
+    skills: AgentSkill[];
+};
+
+export declare type AgentProvider = {
+    organization: string;
+    url?: string | null;
+};
+
+export declare namespace agents {
+    export {
+        getAgentsHandler,
+        getAgentByIdHandler,
+        getEvalsByAgentIdHandler,
+        getLiveEvalsByAgentIdHandler,
+        generateHandler,
+        streamGenerateHandler
+    }
+}
+
+export declare type AgentSkill = {
+    id: string;
+    name: string;
+    description?: string | null;
+    tags?: string[] | null;
+    examples?: string[] | null;
+    inputModes?: string[] | null;
+    outputModes?: string[] | null;
+};
+
+export declare interface ApiError extends Error {
+    message: string;
+    status?: number;
+}
+
+export declare type Artifact = {
+    name?: string | null;
+    description?: string | null;
+    parts: Part[];
+    index?: number;
+    append?: boolean | null;
+    lastChunk?: boolean | null;
+    metadata?: Record<string, any> | null;
+};
+
+export declare type AuthenticationInfo = {
+    schemes: string[];
+    credentials?: string | null;
+} & Record<string, any>;
+
+export declare type CancelTaskRequest = JSONRPCRequest & {
+    method: 'tasks/cancel';
+    params: TaskIdParams;
+};
+
+export declare type CancelTaskResponse = JSONRPCResponse & {
+    result?: Task | null;
+};
+
+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 createIndex({ mastra, vectorName, index, }: Pick<VectorContext, 'mastra' | 'vectorName'> & {
+    index: CreateIndexRequest;
+}): Promise<{
+    success: boolean;
+}>;
+
+declare interface CreateIndexRequest {
+    indexName: string;
+    dimension: number;
+    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+
+export declare function createRunHandler({ mastra, workflowId, runId: prevRunId, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<{
+    runId: string;
+}>;
+
+export declare function createThreadHandler({ mastra, agentId, body, }: Pick<MemoryContext, 'mastra' | 'agentId'> & {
+    body?: Omit<Parameters<MastraMemory['createThread']>[0], 'resourceId'> & {
+        resourceId?: string;
+    };
+}): Promise<StorageThreadType>;
+
+export declare type DataPart = {
+    type: 'data';
+    data: Record<string, any>;
+    metadata?: Record<string, any> | null;
+};
+
+export declare function deleteIndex({ mastra, vectorName, indexName, }: Pick<VectorContext, 'mastra' | 'vectorName'> & {
+    indexName?: string;
+}): Promise<{
+    success: boolean;
+}>;
+
+export declare function deleteThreadHandler({ mastra, agentId, threadId, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId'>): Promise<{
+    result: string;
+}>;
+
+declare type DeprecatedStatusCode = 305 | 306;
+
+export declare function describeIndex({ mastra, vectorName, indexName, }: Pick<VectorContext, 'mastra' | 'vectorName'> & {
+    indexName?: string;
+}): Promise<{
+    dimension: number;
+    count: number;
+    metric: string | undefined;
+}>;
+
+export declare enum ErrorCode {
+    PARSE_ERROR = -32700,
+    INVALID_REQUEST = -32600,
+    METHOD_NOT_FOUND = -32601,
+    INVALID_PARAMS = -32602,
+    INTERNAL_ERROR = -32603,
+    TASK_NOT_FOUND = -32001,
+    TASK_NOT_CANCELABLE = -32002,
+    PUSH_NOTIFICATION_NOT_SUPPORTED = -32003,
+    UNSUPPORTED_OPERATION = -32004
+}
+
+export declare function executeAgentToolHandler({ mastra, agentId, toolId, data, container, }: Pick<ToolsContext, 'mastra' | 'toolId'> & {
+    agentId?: string;
+    data: any;
+    container: Container;
+}): Promise<any>;
+
+export declare function executeToolHandler(tools: ToolsContext['tools']): ({ mastra, runId, toolId, data, container, }: Pick<ToolsContext, "mastra" | "toolId" | "runId"> & {
+    data?: unknown;
+    container: Container;
+}) => Promise<any>;
+
+export declare type FileContent = {
+    name?: string | null;
+    mimeType?: string | null;
+    bytes?: string | null;
+    uri?: string | null;
+};
+
+export declare type FilePart = {
+    type: 'file';
+    file: FileContent;
+    metadata?: Record<string, any> | null;
+};
+
+/**
+ * Generate an agent card for the A2A protocol
+ */
+export declare function generateAgentCard({ agent, baseUrl }: {
+    agent: Agent;
+    baseUrl: string;
+}): AgentCard;
+
+export declare function generateHandler({ mastra, container, agentId, body, }: Context & {
+    container: Container;
+    agentId: string;
+    body: GetBody<'generate'> & {
+        resourceid?: string;
+    };
+}): Promise<GenerateTextResult<any, any>>;
+
+export declare function generateHandler_alias_1({ mastra, container, networkId, body, }: NetworkContext & {
+    container: Container;
+    body: {
+        messages?: Parameters<AgentNetwork['generate']>[0];
+    } & Parameters<AgentNetwork['generate']>[1];
+}): Promise<GenerateObjectResult<any>>;
+
+/**
+ * Generate speech from text
+ */
+export declare function generateSpeechHandler({ mastra, agentId, body, }: VoiceContext & {
+    body?: {
+        text?: string;
+        speakerId?: string;
+    };
+}): Promise<{
+    audioData: Buffer<ArrayBuffer>;
+}>;
+
+export declare function getAgentByIdHandler({ mastra, agentId }: Context & {
+    agentId: string;
+}): Promise<{
+    name: any;
+    instructions: string;
+    tools: any;
+    provider: string;
+    modelId: string;
+}>;
+
+export declare function getAgentsHandler({ mastra }: Context): Promise<any>;
+
+declare type GetBody<T extends keyof Agent & {
+    [K in keyof Agent]: Agent[K] extends (...args: any) => any ? K : never;
+}[keyof Agent]> = {
+    messages: Parameters<Agent[T]>[0];
+} & Parameters<Agent[T]>[1];
+
+export declare function getEvalsByAgentIdHandler({ mastra, agentId }: Context & {
+    agentId: string;
+}): Promise<{
+    id: string;
+    name: any;
+    instructions: string;
+    evals: EvalRow[];
+}>;
+
+export declare function getLiveEvalsByAgentIdHandler({ mastra, agentId }: Context & {
+    agentId: string;
+}): Promise<{
+    id: string;
+    name: any;
+    instructions: string;
+    evals: EvalRow[];
+}>;
+
+export declare function getLogsByRunIdHandler({ mastra, runId, transportId, }: Pick<LogsContext, 'mastra' | 'runId' | 'transportId'>): Promise<BaseLogMessage[] | undefined>;
+
+export declare function getLogsHandler({ mastra, transportId, }: Pick<LogsContext, 'mastra' | 'transportId'>): Promise<BaseLogMessage[]>;
+
+export declare function getLogTransports({ mastra }: Pick<LogsContext, 'mastra'>): Promise<{
+    transports: string[];
+}>;
+
+export declare function getMemoryStatusHandler({ mastra, agentId }: Pick<MemoryContext, 'mastra' | 'agentId'>): Promise<{
+    result: boolean;
+}>;
+
+export declare function getMessagesHandler({ mastra, agentId, threadId, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId'>): Promise<{
+    messages: CoreMessage[];
+    uiMessages: Message_2[];
+}>;
+
+export declare function getNetworkByIdHandler({ mastra, networkId }: Pick<NetworkContext, 'mastra' | 'networkId'>): Promise<{
+    id: string;
+    name: string;
+    instructions: string;
+    agents: {
+        name: string;
+        provider: string;
+        modelId: string;
+    }[];
+    routingModel: {
+        provider: string;
+        modelId: string;
+    };
+}>;
+
+export declare function getNetworksHandler({ mastra }: Pick<NetworkContext, 'mastra'>): Promise<{
+    id: string;
+    name: string;
+    instructions: string;
+    agents: {
+        name: string;
+        provider: string;
+        modelId: string;
+    }[];
+    routingModel: {
+        provider: string;
+        modelId: string;
+    };
+}[]>;
+
+/**
+ * Get available speakers for an agent
+ */
+export declare function getSpeakersHandler({ mastra, agentId }: VoiceContext): Promise<{
+    voiceId: string;
+}[]>;
+
+export declare type GetTaskPushNotificationRequest = JSONRPCRequest & {
+    method: 'tasks/pushNotification/get';
+    params: TaskIdParams;
+};
+
+export declare type GetTaskPushNotificationResponse = JSONRPCResponse & {
+    result?: TaskPushNotificationConfig | null;
+};
+
+export declare type GetTaskRequest = JSONRPCRequest & {
+    method: 'tasks/get';
+    params: TaskQueryParams;
+};
+
+export declare type GetTaskResponse = JSONRPCResponse & {
+    result?: Task | null;
+};
+
+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 getThreadsHandler({ mastra, agentId, resourceId, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'resourceId'>): 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 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 getWorkflowRunHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<ReturnType<Workflow['getRun']>>;
+
+export declare function getWorkflowRunsHandler({ mastra, workflowId }: WorkflowContext): Promise<WorkflowRuns>;
+
+export declare function getWorkflowsHandler({ mastra }: WorkflowContext): Promise<any>;
+
+/**
+ * Handle a JSON-RPC request for the A2A protocol
+ */
+export declare function handleA2ARequest({ request, agent, }: {
+    request: A2ARequest;
+    agent: Agent;
+}): Promise<JSONRPCResponse>;
+
+/**
+ * Handle a request for the agent card
+ */
+export declare function handleAgentCardRequest({ agent, baseUrl }: {
+    agent: Agent;
+    baseUrl: string;
+}): AgentCard;
+
+/**
+ * Handle a tasks/cancel request
+ */
+export declare function handleCancelTask({ request }: {
+    request: CancelTaskRequest;
+}): Promise<JSONRPCResponse>;
+
+export declare function handleError(error: unknown, defaultMessage: string): never;
+
+/**
+ * Handle a tasks/get request
+ */
+export declare function handleGetTask({ request }: {
+    request: GetTaskRequest;
+}): Promise<JSONRPCResponse>;
+
+/**
+ * Handle push notification requests
+ */
+export declare function handlePushNotification(): JSONRPCResponse;
+
+/**
+ * Handle a tasks/send request
+ */
+export declare function handleSendTask({ request, agent, }: {
+    request: SendTaskRequest;
+    agent: Agent;
+}): Promise<JSONRPCResponse>;
+
+/**
+ * `HTTPException` must be used when a fatal error such as authentication failure occurs.
+ *
+ * @see {@link https://hono.dev/docs/api/exception}
+ *
+ * @param {StatusCode} status - status code of HTTPException
+ * @param {HTTPExceptionOptions} options - options of HTTPException
+ * @param {HTTPExceptionOptions["res"]} options.res - response of options of HTTPException
+ * @param {HTTPExceptionOptions["message"]} options.message - message of options of HTTPException
+ * @param {HTTPExceptionOptions["cause"]} options.cause - cause of options of HTTPException
+ *
+ * @example
+ * ```ts
+ * import { HTTPException } from 'hono/http-exception'
+ *
+ * // ...
+ *
+ * app.post('/auth', async (c, next) => {
+ *   // authentication
+ *   if (authorized === false) {
+ *     throw new HTTPException(401, { message: 'Custom error message' })
+ *   }
+ *   await next()
+ * })
+ * ```
+ */
+export declare class HTTPException extends Error {
+    readonly res?: Response;
+    readonly status: StatusCode;
+    /**
+     * Creates an instance of `HTTPException`.
+     * @param status - HTTP status code for the exception. Defaults to 500.
+     * @param options - Additional options for the exception.
+     */
+    constructor(status?: StatusCode, options?: HTTPExceptionOptions);
+    /**
+     * Returns the response object associated with the exception.
+     * If a response object is not provided, a new response is created with the error message and status code.
+     * @returns The response object.
+     */
+    getResponse(): Response;
+}
+
+/**
+ * Options for creating an `HTTPException`.
+ * @property res - Optional response object to use.
+ * @property message - Optional custom error message.
+ * @property cause - Optional cause of the error.
+ */
+declare type HTTPExceptionOptions = {
+    res?: Response;
+    message?: string;
+    cause?: unknown;
+};
+
+/**
+ * @module
+ * This module provides the `HTTPException` class.
+ */
+declare type InfoStatusCode = 100 | 101 | 102 | 103;
+
+export declare type JSONRPCError = {
+    code: number;
+    message: string;
+    data?: Record<string, any> | null;
+};
+
+/**
+ * A2A Protocol Types
+ * Based on the A2A Protocol Schema
+ */
+export declare type JSONRPCMessage = {
+    jsonrpc: '2.0';
+    id?: string | number | null;
+};
+
+export declare type JSONRPCRequest = JSONRPCMessage & {
+    method: string;
+    params?: Record<string, any> | null;
+};
+
+export declare type JSONRPCResponse = JSONRPCMessage & {
+    result?: any | null;
+    error?: JSONRPCError | null;
+};
+
+export declare function listIndexes({ mastra, vectorName }: Pick<VectorContext, 'mastra' | 'vectorName'>): Promise<string[]>;
+
+export declare namespace logs {
+    export {
+        getLogsHandler,
+        getLogsByRunIdHandler,
+        getLogTransports
+    }
+}
+
+declare type LogsContext = {
+    mastra: Mastra;
+    transportId?: string;
+    runId?: string;
+};
+
+export declare namespace memory {
+    export {
+        getMemoryStatusHandler,
+        getThreadsHandler,
+        getThreadByIdHandler,
+        saveMessagesHandler,
+        createThreadHandler,
+        updateThreadHandler,
+        deleteThreadHandler,
+        getMessagesHandler
+    }
+}
+
+declare interface MemoryContext extends Context {
+    agentId?: string;
+    resourceId?: string;
+    threadId?: string;
+}
+
+export declare type Message = {
+    role: 'user' | 'agent';
+    parts: Part[];
+    metadata?: Record<string, any> | null;
+};
+
+export declare class MockAgent extends Agent {
+    constructor(config: AgentConfig);
+    run(_args: any): Promise<string>;
+}
+
+export declare namespace network {
+    export {
+        getNetworksHandler,
+        getNetworkByIdHandler,
+        generateHandler_alias_1 as generateHandler,
+        streamGenerateHandler_alias_1 as streamGenerateHandler
+    }
+}
+
+declare interface NetworkContext extends Context {
+    networkId?: string;
+}
+
+export declare type Part = TextPart | FilePart | DataPart;
+
+export declare type PushNotificationConfig = {
+    url: string;
+    token?: string | null;
+    authentication?: AuthenticationInfo | null;
+};
+
+declare interface QueryRequest {
+    indexName: string;
+    queryVector: number[];
+    topK?: number;
+    filter?: Record<string, any>;
+    includeVector?: boolean;
+}
+
+export declare function queryVectors({ mastra, vectorName, query, }: Pick<VectorContext, 'mastra' | 'vectorName'> & {
+    query: QueryRequest;
+}): Promise<QueryResult[]>;
+
+declare type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
+
+export declare function resumeAsyncWorkflowHandler({ mastra, workflowId, runId, body, container, }: WorkflowContext & {
+    body: {
+        stepId: string;
+        context: any;
+    };
+    container: Container;
+}): Promise<Omit<WorkflowRunResult<any, Step<string, any, any, StepExecutionContext<any, WorkflowContext_2<any, Step<string, any, any, any>[], Record<string, any>>>>[], any>, "runId"> | undefined>;
+
+export declare function resumeWorkflowHandler({ mastra, workflowId, runId, body, container, }: WorkflowContext & {
+    body: {
+        stepId: string;
+        context: any;
+    };
+    container: Container;
+}): Promise<{
+    message: string;
+}>;
+
+export declare function saveMessagesHandler({ mastra, agentId, body, }: Pick<MemoryContext, 'mastra' | 'agentId'> & {
+    body: {
+        messages: Parameters<MastraMemory['saveMessages']>[0]['messages'];
+    };
+}): Promise<MessageType[]>;
+
+export declare type SendTaskRequest = JSONRPCRequest & {
+    method: 'tasks/send';
+    params: TaskSendParams;
+};
+
+export declare type SendTaskResponse = JSONRPCResponse & {
+    result?: Task | null;
+};
+
+export declare type SendTaskStreamingRequest = JSONRPCRequest & {
+    method: 'tasks/sendSubscribe';
+    params: TaskSendParams;
+};
+
+export declare type SendTaskStreamingResponse = JSONRPCResponse & {
+    result?: TaskStatusUpdateEvent | TaskArtifactUpdateEvent | null;
+};
+
+declare type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+
+export declare type SetTaskPushNotificationRequest = JSONRPCRequest & {
+    method: 'tasks/pushNotification/set';
+    params: TaskPushNotificationConfig;
+};
+
+export declare type SetTaskPushNotificationResponse = JSONRPCResponse & {
+    result?: TaskPushNotificationConfig | null;
+};
+
+export declare function startAsyncWorkflowHandler({ mastra, container, workflowId, runId, triggerData, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'> & {
+    triggerData?: unknown;
+    container: Container;
+}): Promise<WorkflowRunResult<any, Step<string, any, any, StepExecutionContext<any, WorkflowContext_2<any, Step<string, any, any, any>[], Record<string, any>>>>[], any>>;
+
+export declare function startWorkflowRunHandler({ mastra, container, workflowId, runId, triggerData, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'> & {
+    triggerData?: unknown;
+    container: Container;
+}): Promise<{
+    message: string;
+}>;
+
+/**
+ * If you want to use an unofficial status, use `UnofficialStatusCode`.
+ */
+export declare type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode | UnofficialStatusCode;
+
+export declare function storeTelemetryHandler({ mastra, body }: Context & {
+    body: {
+        resourceSpans: any[];
+    };
+}): Promise<{
+    status: string;
+    message: string;
+    error: any;
+} | {
+    status: string;
+    message: string;
+    traceCount: number;
+}>;
+
+export declare function streamGenerateHandler({ mastra, container, agentId, body, }: Context & {
+    container: Container;
+    agentId: string;
+    body: GetBody<'stream'> & {
+        resourceid?: string;
+    };
+}): Promise<Response | undefined>;
+
+export declare function streamGenerateHandler_alias_1({ mastra, networkId, body, container, }: NetworkContext & {
+    container: Container;
+    body: {
+        messages?: Parameters<AgentNetwork['stream']>[0];
+    } & Parameters<AgentNetwork['stream']>[1];
+}): Promise<Response>;
+
+declare type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+
+export declare type Task = {
+    id: string;
+    sessionId?: string | null;
+    status: TaskStatus;
+    artifacts?: Artifact[] | null;
+    history?: Message[] | null;
+    metadata?: Record<string, any> | null;
+};
+
+export declare type TaskArtifactUpdateEvent = {
+    id: string;
+    artifact: Artifact;
+    metadata?: Record<string, any> | null;
+};
+
+export declare type TaskIdParams = {
+    id: string;
+    metadata?: Record<string, any> | null;
+};
+
+export declare type TaskPushNotificationConfig = {
+    id: string;
+    pushNotificationConfig: PushNotificationConfig;
+};
+
+export declare type TaskQueryParams = {
+    id: string;
+    historyLength?: number | null;
+    metadata?: Record<string, any> | null;
+};
+
+export declare type TaskResubscriptionRequest = JSONRPCRequest & {
+    method: 'tasks/resubscribe';
+    params: TaskQueryParams;
+};
+
+export declare type TaskSendParams = {
+    id: string;
+    sessionId?: string;
+    message: Message;
+    pushNotification?: PushNotificationConfig | null;
+    historyLength?: number | null;
+    metadata?: Record<string, any> | null;
+};
+
+export declare enum TaskState {
+    SUBMITTED = "submitted",
+    WORKING = "working",
+    INPUT_REQUIRED = "input-required",
+    COMPLETED = "completed",
+    CANCELED = "canceled",
+    FAILED = "failed",
+    UNKNOWN = "unknown"
+}
+
+export declare type TaskStatus = {
+    state: TaskState;
+    message?: Message | null;
+    timestamp?: string;
+};
+
+export declare type TaskStatusUpdateEvent = {
+    id: string;
+    status: TaskStatus;
+    final?: boolean;
+    metadata?: Record<string, any> | null;
+};
+
+export declare namespace telemetry {
+    export {
+        getTelemetryHandler,
+        storeTelemetryHandler
+    }
+}
+
+declare interface TelemetryContext extends Context {
+    body?: {
+        name?: string;
+        scope?: string;
+        page?: number;
+        perPage?: number;
+        attribute?: string | string[];
+    };
+}
+
+export declare type TextPart = {
+    type: 'text';
+    text: string;
+    metadata?: Record<string, any> | null;
+};
+
+export declare namespace tools {
+    export {
+        getToolsHandler,
+        getToolByIdHandler,
+        executeToolHandler,
+        executeAgentToolHandler
+    }
+}
+
+declare interface ToolsContext extends Context {
+    tools?: Record<string, ToolAction | VercelTool>;
+    toolId?: string;
+    runId?: string;
+}
+
+/**
+ * Transcribe speech to text
+ */
+export declare function transcribeSpeechHandler({ mastra, agentId, body, }: VoiceContext & {
+    body?: {
+        audioData?: Buffer;
+        options?: Parameters<NonNullable<Agent['voice']>['listen']>[1];
+    };
+}): Promise<{
+    text: string | void | NodeJS.ReadableStream;
+}>;
+
+/**
+ * @deprecated
+ * Use `UnofficialStatusCode` instead.
+ */
+export declare type UnOfficalStatusCode = UnofficialStatusCode;
+
+/**
+ * `UnofficialStatusCode` can be used to specify an unofficial status code.
+ * @example
+ *
+ * ```ts
+ * app.get('/unknown', (c) => {
+ *   return c.text("Unknown Error", 520 as UnofficialStatusCode)
+ * })
+ * ```
+ */
+export declare type UnofficialStatusCode = -1;
+
+export declare function updateThreadHandler({ mastra, agentId, threadId, body, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId'> & {
+    body?: Parameters<MastraMemory['saveThread']>[0]['thread'];
+}): Promise<StorageThreadType>;
+
+declare interface UpsertRequest {
+    indexName: string;
+    vectors: number[][];
+    metadata?: Record<string, any>[];
+    ids?: string[];
+}
+
+export declare function upsertVectors({ mastra, vectorName, index }: VectorContext & {
+    index: UpsertRequest;
+}): Promise<{
+    ids: string[];
+}>;
+
+export declare function validateBody(body: Record<string, unknown>): void;
+
+export declare namespace vector {
+    export {
+        upsertVectors,
+        createIndex,
+        queryVectors,
+        listIndexes,
+        describeIndex,
+        deleteIndex
+    }
+}
+
+declare interface VectorContext extends Context {
+    vectorName?: string;
+}
+
+export declare namespace voice {
+    export {
+        getSpeakersHandler,
+        generateSpeechHandler,
+        transcribeSpeechHandler
+    }
+}
+
+declare interface VoiceContext extends Context {
+    agentId?: string;
+}
+
+export declare function watchWorkflowHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<ReadableStream_2<string>>;
+
+declare interface WorkflowContext extends Context {
+    workflowId?: string;
+    runId?: string;
+}
+
+export declare namespace workflows {
+    export {
+        getWorkflowsHandler,
+        getWorkflowByIdHandler,
+        startAsyncWorkflowHandler,
+        getWorkflowRunHandler,
+        createRunHandler,
+        startWorkflowRunHandler,
+        watchWorkflowHandler,
+        resumeAsyncWorkflowHandler,
+        resumeWorkflowHandler,
+        getWorkflowRunsHandler
+    }
+}
+
+export { }