@mastra/server 0.0.0-bundle-dynamic-imports-20250424001248 → 0.0.0-cloud-transporter-20250513033346

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

@@ -1,27 +1,59 @@
 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 type { CoreMessage as CoreMessage_2 } from '@mastra/core/llm';
 import { EvalRow } from '@mastra/core/storage';
 import { GenerateObjectResult } from 'ai';
 import { GenerateTextResult } from 'ai';
+import type { JSONRPCError } from '@mastra/core/a2a';
+import { JSONRPCResponse } from '@mastra/core/a2a';
+import type { Logger } from '@mastra/core/logger';
 import type { Mastra } from '@mastra/core/mastra';
 import type { MastraMemory } from '@mastra/core/memory';
 import { Message } from 'ai';
+import type { Message as Message_2 } from '@mastra/core/a2a';
 import { MessageType } from '@mastra/core/memory';
+import { NewStep } from '@mastra/core/workflows/vNext';
+import type { NewWorkflow } from '@mastra/core/workflows/vNext';
 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 { RuntimeContext } from '@mastra/core/runtime-context';
+import { RuntimeContext as RuntimeContext_2 } from '@mastra/core/di';
+import type { 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 { 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 type { VercelTool } from '@mastra/core/tools';
 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 type { WorkflowRuns } from '@mastra/core/storage';
+import { ZodType } from 'zod';
+import { ZodTypeDef } from 'zod';
+
+export declare namespace a2a {
+    export {
+        getAgentCardByIdHandler,
+        handleTaskSend,
+        handleTaskGet,
+        handleTaskSendSubscribe,
+        handleTaskCancel,
+        getAgentExecutionHandler
+    }
+}
 
 export declare namespace agents {
     export {
@@ -39,12 +71,18 @@ export declare interface ApiError extends Error {
     status?: number;
 }
 
+export declare function applyUpdateToTaskAndHistory(current: TaskAndHistory, update: Omit<TaskStatus, 'timestamp'> | Artifact): TaskAndHistory;
+
 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_2): 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<{
@@ -61,12 +99,25 @@ export declare function createRunHandler({ mastra, workflowId, runId: prevRunId,
     runId: string;
 }>;
 
+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_2;
+    history: Message_2[];
+    activeCancellations: Set<string>;
+}): TaskContext;
+
 export declare function createThreadHandler({ mastra, agentId, body, }: Pick<MemoryContext, 'mastra' | 'agentId'> & {
     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<{
+    runId: string;
+}>;
+
 export declare function deleteIndex({ mastra, vectorName, indexName, }: Pick<VectorContext, 'mastra' | 'vectorName'> & {
     indexName?: string;
 }): Promise<{
@@ -87,15 +138,17 @@ export declare function describeIndex({ mastra, vectorName, indexName, }: Pick<V
     metric: string | undefined;
 }>;
 
-export declare function executeAgentToolHandler({ mastra, agentId, toolId, data, runtimeContext, }: Pick<ToolsContext, 'mastra' | 'toolId'> & {
+export declare function executeAgentToolHandler({ mastra, agentId, toolId, data, runtimeContext, runtimeContextFromRequest, }: Pick<ToolsContext, 'mastra' | 'toolId'> & {
     agentId?: string;
     data: any;
-    runtimeContext: RuntimeContext;
+    runtimeContext: RuntimeContext_2;
+    runtimeContextFromRequest: Record<string, unknown>;
 }): Promise<any>;
 
-export declare function executeToolHandler(tools: ToolsContext['tools']): ({ mastra, runId, toolId, data, runtimeContext, }: Pick<ToolsContext, "mastra" | "toolId" | "runId"> & {
+export declare function executeToolHandler(tools: ToolsContext['tools']): ({ mastra, runId, toolId, data, runtimeContext, runtimeContextFromRequest, }: Pick<ToolsContext, "mastra" | "toolId" | "runId"> & {
     data?: unknown;
-    runtimeContext: RuntimeContext;
+    runtimeContext: RuntimeContext_2;
+    runtimeContextFromRequest: Record<string, unknown>;
 }) => Promise<any>;
 
 export declare function generateHandler({ mastra, runtimeContext, agentId, body, }: Context & {
@@ -103,6 +156,7 @@ export declare function generateHandler({ mastra, runtimeContext, agentId, body,
     agentId: string;
     body: GetBody<'generate'> & {
         resourceid?: string;
+        runtimeContext?: Record<string, unknown>;
     };
 }): Promise<GenerateTextResult<any, any>>;
 
@@ -123,17 +177,42 @@ export declare function generateSpeechHandler({ mastra, agentId, body, }: VoiceC
     };
 }): Promise<NodeJS.ReadableStream>;
 
-export declare function getAgentByIdHandler({ mastra, agentId }: Context & {
+export declare function getAgentByIdHandler({ mastra, runtimeContext, agentId, }: Context & {
+    runtimeContext: RuntimeContext;
     agentId: string;
 }): Promise<{
     name: any;
     instructions: string;
     tools: any;
+    workflows: {};
     provider: string;
     modelId: string;
 }>;
 
-export declare function getAgentsHandler({ mastra }: Context): Promise<any>;
+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?: Logger;
+}): Promise<any>;
+
+export declare function getAgentsHandler({ mastra, runtimeContext }: Context & {
+    runtimeContext: RuntimeContext;
+}): Promise<any>;
 
 declare type GetBody<T extends keyof Agent & {
     [K in keyof Agent]: Agent[K] extends (...args: any) => any ? K : never;
@@ -141,7 +220,8 @@ declare type GetBody<T extends keyof Agent & {
     messages: Parameters<Agent[T]>[0];
 } & Parameters<Agent[T]>[1];
 
-export declare function getEvalsByAgentIdHandler({ mastra, agentId }: Context & {
+export declare function getEvalsByAgentIdHandler({ mastra, runtimeContext, agentId, }: Context & {
+    runtimeContext: RuntimeContext;
     agentId: string;
 }): Promise<{
     id: string;
@@ -150,7 +230,8 @@ export declare function getEvalsByAgentIdHandler({ mastra, agentId }: Context &
     evals: EvalRow[];
 }>;
 
-export declare function getLiveEvalsByAgentIdHandler({ mastra, agentId }: Context & {
+export declare function getLiveEvalsByAgentIdHandler({ mastra, runtimeContext, agentId, }: Context & {
+    runtimeContext: RuntimeContext;
     agentId: string;
 }): Promise<{
     id: string;
@@ -171,12 +252,14 @@ export declare function getMemoryStatusHandler({ mastra, agentId }: Pick<MemoryC
     result: boolean;
 }>;
 
-export declare function getMessagesHandler({ mastra, agentId, threadId, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId'>): Promise<{
+export declare function getMessagesHandler({ mastra, agentId, threadId, limit, }: Pick<MemoryContext, 'mastra' | 'agentId' | 'threadId'> & {
+    limit?: number;
+}): Promise<{
     messages: CoreMessage[];
     uiMessages: Message[];
 }>;
 
-export declare function getNetworkByIdHandler({ mastra, networkId }: Pick<NetworkContext, 'mastra' | 'networkId'>): Promise<{
+export declare function getNetworkByIdHandler({ mastra, networkId, runtimeContext, }: Pick<NetworkContext, 'mastra' | 'networkId' | 'runtimeContext'>): Promise<{
     id: string;
     name: string;
     instructions: string;
@@ -191,7 +274,7 @@ export declare function getNetworkByIdHandler({ mastra, networkId }: Pick<Networ
     };
 }>;
 
-export declare function getNetworksHandler({ mastra }: Pick<NetworkContext, 'mastra'>): Promise<{
+export declare function getNetworksHandler({ mastra, runtimeContext, }: Pick<NetworkContext, 'mastra' | 'runtimeContext'>): Promise<{
     id: string;
     name: string;
     instructions: string;
@@ -223,6 +306,26 @@ export declare function getToolByIdHandler({ tools, toolId }: Pick<ToolsContext,
 
 export declare function getToolsHandler({ tools }: Pick<ToolsContext, 'tools'>): Promise<Record<string, any>>;
 
+export declare function getVNextWorkflowByIdHandler({ mastra, workflowId }: VNextWorkflowContext): Promise<{
+    steps: SerializedStep[];
+    name: string | undefined;
+    stepGraph: SerializedStepFlowEntry[];
+    inputSchema: string | undefined;
+    outputSchema: string | undefined;
+}>;
+
+export declare function getVNextWorkflowRunByIdHandler({ mastra, workflowId, runId, }: Pick<VNextWorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<ReturnType<NewWorkflow['getWorkflowRunById']>>;
+
+export declare function getVNextWorkflowRunsHandler({ mastra, workflowId, fromDate, toDate, limit, offset, resourceId, }: VNextWorkflowContext & {
+    fromDate?: Date;
+    toDate?: Date;
+    limit?: number;
+    offset?: number;
+    resourceId?: string;
+}): Promise<WorkflowRuns>;
+
+export declare function getVNextWorkflowsHandler({ mastra }: VNextWorkflowContext): Promise<any>;
+
 export declare function getWorkflowByIdHandler({ mastra, workflowId }: WorkflowContext): Promise<{
     stepGraph: StepGraph;
     stepSubscriberGraph: Record<string, StepGraph>;
@@ -235,12 +338,60 @@ export declare function getWorkflowByIdHandler({ mastra, workflowId }: WorkflowC
 
 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 getWorkflowRunsHandler({ mastra, workflowId, fromDate, toDate, limit, offset, resourceId, }: WorkflowContext & {
+    fromDate?: Date;
+    toDate?: Date;
+    limit?: number;
+    offset?: number;
+    resourceId?: string;
+}): Promise<WorkflowRuns>;
 
 export declare function getWorkflowsHandler({ mastra }: WorkflowContext): Promise<any>;
 
 export declare function handleError(error: unknown, defaultMessage: string): never;
 
+export declare function handleTaskCancel({ requestId, taskStore, agentId, taskId, logger, }: {
+    requestId: string;
+    taskStore: InMemoryTaskStore;
+    agentId: string;
+    taskId: string;
+    logger?: Logger;
+}): Promise<JSONRPCResponse<Task, unknown>>;
+
+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, logger, runtimeContext, }: {
+    requestId: string;
+    params: TaskSendParams;
+    taskStore: InMemoryTaskStore;
+    agent: Agent;
+    logger?: Logger;
+    runtimeContext: RuntimeContext;
+}): Promise<JSONRPCResponse<null, unknown> | JSONRPCResponse<Task, unknown>>;
+
+export declare function handleTaskSendSubscribe({ requestId, params, taskStore, agent, logger, runtimeContext, }: {
+    requestId: string;
+    params: TaskSendParams;
+    taskStore: InMemoryTaskStore;
+    agent: Agent;
+    logger?: Logger;
+    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.
  *
@@ -302,8 +453,31 @@ 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 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_2;
+    sessionId?: string | null;
+    metadata?: Record<string, unknown> | null;
+    logger?: Logger;
+}): Promise<TaskAndHistory>;
+
 export declare namespace logs {
     export {
         getLogsHandler,
@@ -348,8 +522,11 @@ export declare namespace network {
 
 declare interface NetworkContext extends Context {
     networkId?: string;
+    runtimeContext: RuntimeContext;
 }
 
+export declare function normalizeError(error: any, reqId: number | string | null, taskId?: string, logger?: Logger): JSONRPCResponse<null, unknown>;
+
 declare interface QueryRequest {
     indexName: string;
     queryVector: number[];
@@ -364,6 +541,15 @@ 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, runtimeContextFromRequest, }: VNextWorkflowContext & {
+    body: {
+        step: string | string[];
+        resumeData?: unknown;
+    };
+    runtimeContext?: RuntimeContext_2;
+    runtimeContextFromRequest?: Record<string, unknown>;
+}): Promise<WorkflowResult<ZodType<any, ZodTypeDef, any>, NewStep<string, any, any, any, any>[]>>;
+
 export declare function resumeAsyncWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: WorkflowContext & {
     body: {
         stepId: string;
@@ -372,6 +558,16 @@ export declare function resumeAsyncWorkflowHandler({ mastra, workflowId, runId,
     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>;
 
+export declare function resumeVNextWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: VNextWorkflowContext & {
+    body: {
+        step: string | string[];
+        resumeData?: unknown;
+    };
+    runtimeContext?: RuntimeContext_2;
+}): Promise<{
+    message: string;
+}>;
+
 export declare function resumeWorkflowHandler({ mastra, workflowId, runId, body, runtimeContext, }: WorkflowContext & {
     body: {
         stepId: string;
@@ -388,13 +584,36 @@ export declare function saveMessagesHandler({ mastra, agentId, body, }: Pick<Mem
     };
 }): 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, runtimeContextFromRequest, }: Pick<VNextWorkflowContext, 'mastra' | 'workflowId' | 'runId'> & {
+    inputData?: unknown;
+    runtimeContext?: RuntimeContext_2;
+    runtimeContextFromRequest?: Record<string, unknown>;
+}): 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'> & {
     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>>;
 
+export declare function startVNextWorkflowRunHandler({ mastra, runtimeContext, workflowId, runId, inputData, runtimeContextFromRequest, }: Pick<VNextWorkflowContext, 'mastra' | 'workflowId' | 'runId'> & {
+    inputData?: unknown;
+    runtimeContext?: RuntimeContext_2;
+    runtimeContextFromRequest?: Record<string, unknown>;
+}): Promise<{
+    message: string;
+}>;
+
 export declare function startWorkflowRunHandler({ mastra, runtimeContext, workflowId, runId, triggerData, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'> & {
     triggerData?: unknown;
     runtimeContext: RuntimeContext;
@@ -426,6 +645,7 @@ export declare function streamGenerateHandler({ mastra, runtimeContext, agentId,
     agentId: string;
     body: GetBody<'stream'> & {
         resourceid?: string;
+        runtimeContext?: string;
     };
 }): Promise<Response | undefined>;
 
@@ -452,6 +672,8 @@ declare interface TelemetryContext extends Context {
         page?: number;
         perPage?: number;
         attribute?: string | string[];
+        fromDate?: Date;
+        toDate?: Date;
     };
 }
 
@@ -534,6 +756,26 @@ declare interface VectorContext extends Context {
     vectorName?: string;
 }
 
+declare interface VNextWorkflowContext extends Context {
+    workflowId?: string;
+    runId?: string;
+}
+
+export declare namespace vNextWorkflows {
+    export {
+        getVNextWorkflowsHandler,
+        getVNextWorkflowByIdHandler,
+        getVNextWorkflowRunByIdHandler,
+        createVNextWorkflowRunHandler,
+        startAsyncVNextWorkflowHandler,
+        startVNextWorkflowRunHandler,
+        watchVNextWorkflowHandler,
+        resumeAsyncVNextWorkflowHandler,
+        resumeVNextWorkflowHandler,
+        getVNextWorkflowRunsHandler
+    }
+}
+
 export declare namespace voice {
     export {
         getSpeakersHandler,
@@ -546,6 +788,8 @@ 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 watchWorkflowHandler({ mastra, workflowId, runId, }: Pick<WorkflowContext, 'mastra' | 'workflowId' | 'runId'>): Promise<ReadableStream_2<string>>;
 
 declare interface WorkflowContext extends Context {

package/dist/{chunk-M56ECCHK.cjs → chunk-4YZ3U35L.cjs}

@@ -1,11 +1,12 @@
 'use strict';
 
-var chunkZLBRQFDD_cjs = require('./chunk-ZLBRQFDD.cjs');
-var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+var chunk64U3UDTH_cjs = require('./chunk-64U3UDTH.cjs');
+var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
+var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
 
 // src/server/handlers/vector.ts
 var vector_exports = {};
-chunkFV45V6WC_cjs.__export(vector_exports, {
+chunk75ZPJI57_cjs.__export(vector_exports, {
   createIndex: () => createIndex,
   deleteIndex: () => deleteIndex,
   describeIndex: () => describeIndex,
@@ -15,24 +16,24 @@ chunkFV45V6WC_cjs.__export(vector_exports, {
 });
 function getVector(mastra, vectorName) {
   if (!vectorName) {
-    throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Vector name is required" });
+    throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Vector name is required" });
   }
   const vector = mastra.getVector(vectorName);
   if (!vector) {
-    throw new chunkFV45V6WC_cjs.HTTPException(404, { message: `Vector store ${vectorName} not found` });
+    throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: `Vector store ${vectorName} not found` });
   }
   return vector;
 }
 async function upsertVectors({ mastra, vectorName, index }) {
   try {
     if (!index?.indexName || !index?.vectors || !Array.isArray(index.vectors)) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Invalid request index. indexName and vectors array are required." });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Invalid request index. indexName and vectors array are required." });
     }
     const vector = getVector(mastra, vectorName);
     const result = await vector.upsert(index);
     return { ids: result };
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error upserting vectors");
+    return chunk64U3UDTH_cjs.handleError(error, "Error upserting vectors");
   }
 }
 async function createIndex({
@@ -43,18 +44,18 @@ async function createIndex({
   try {
     const { indexName, dimension, metric } = index;
     if (!indexName || typeof dimension !== "number" || dimension <= 0) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, {
         message: "Invalid request index, indexName and positive dimension number are required."
       });
     }
     if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Invalid metric. Must be one of: cosine, euclidean, dotproduct" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Invalid metric. Must be one of: cosine, euclidean, dotproduct" });
     }
     const vector = getVector(mastra, vectorName);
     await vector.createIndex({ indexName, dimension, metric });
     return { success: true };
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error creating index");
+    return chunk64U3UDTH_cjs.handleError(error, "Error creating index");
   }
 }
 async function queryVectors({
@@ -64,13 +65,13 @@ async function queryVectors({
 }) {
   try {
     if (!query?.indexName || !query?.queryVector || !Array.isArray(query.queryVector)) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Invalid request query. indexName and queryVector array are required." });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Invalid request query. indexName and queryVector array are required." });
     }
     const vector = getVector(mastra, vectorName);
     const results = await vector.query(query);
     return results;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error querying vectors");
+    return chunk64U3UDTH_cjs.handleError(error, "Error querying vectors");
   }
 }
 async function listIndexes({ mastra, vectorName }) {
@@ -79,7 +80,7 @@ async function listIndexes({ mastra, vectorName }) {
     const indexes = await vector.listIndexes();
     return indexes.filter(Boolean);
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error listing indexes");
+    return chunk64U3UDTH_cjs.handleError(error, "Error listing indexes");
   }
 }
 async function describeIndex({
@@ -89,7 +90,7 @@ async function describeIndex({
 }) {
   try {
     if (!indexName) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Index name is required" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Index name is required" });
     }
     const vector = getVector(mastra, vectorName);
     const stats = await vector.describeIndex(indexName);
@@ -99,7 +100,7 @@ async function describeIndex({
       metric: stats.metric?.toLowerCase()
     };
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error describing index");
+    return chunk64U3UDTH_cjs.handleError(error, "Error describing index");
   }
 }
 async function deleteIndex({
@@ -109,13 +110,13 @@ async function deleteIndex({
 }) {
   try {
     if (!indexName) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Index name is required" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Index name is required" });
     }
     const vector = getVector(mastra, vectorName);
     await vector.deleteIndex(indexName);
     return { success: true };
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error deleting index");
+    return chunk64U3UDTH_cjs.handleError(error, "Error deleting index");
   }
 }
 

package/dist/{chunk-QN4KF3BH.cjs → chunk-57CJTIPW.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
 
 // src/server/handlers/utils.ts
 function validateBody(body) {
@@ -11,7 +11,7 @@ function validateBody(body) {
     return acc;
   }, {});
   if (Object.keys(errorResponse).length > 0) {
-    throw new chunkFV45V6WC_cjs.HTTPException(400, { message: Object.values(errorResponse)[0] });
+    throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: Object.values(errorResponse)[0] });
   }
 }