@mastra/server 0.0.0-sidebar-window-undefined-fix-20251029233656 → 0.0.0-standard-schema-20260123120255

package/dist/server/handlers/stored-agents.d.ts

@@ -0,0 +1,214 @@
+/**
+ * GET /stored/agents - List all stored agents
+ */
+export declare const LIST_STORED_AGENTS_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<undefined, import("zod").ZodObject<{
+    perPage: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    orderBy: import("zod").ZodOptional<import("zod").ZodObject<{
+        field: import("zod").ZodOptional<import("zod").ZodEnum<{
+            createdAt: "createdAt";
+            updatedAt: "updatedAt";
+        }>>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+    ownerId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip> | import("zod").ZodObject<{
+    perPage: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    orderBy: import("zod").ZodOptional<import("zod").ZodObject<{
+        field: import("zod").ZodOptional<import("zod").ZodEnum<{
+            createdAt: "createdAt";
+            updatedAt: "updatedAt";
+        }>>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+    ownerId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip>, undefined>, {
+    total: number;
+    page: number;
+    perPage: number | false;
+    hasMore: boolean;
+    agents: {
+        name: string;
+        instructions: string;
+        model: Record<string, unknown>;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        description?: string | undefined;
+        tools?: string[] | undefined;
+        defaultOptions?: Record<string, unknown> | undefined;
+        workflows?: string[] | undefined;
+        agents?: string[] | undefined;
+        integrationTools?: string[] | undefined;
+        inputProcessors?: Record<string, unknown>[] | undefined;
+        outputProcessors?: Record<string, unknown>[] | undefined;
+        memory?: string | undefined;
+        scorers?: Record<string, {
+            sampling?: {
+                type: "count" | "ratio";
+                rate?: number | undefined;
+                count?: number | undefined;
+            } | undefined;
+        }> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        ownerId?: string | undefined;
+    }[];
+}, "json">;
+/**
+ * GET /stored/agents/:storedAgentId - Get a stored agent by ID
+ */
+export declare const GET_STORED_AGENT_ROUTE: import("../server-adapter").ServerRoute<{
+    storedAgentId: string;
+}, {
+    name: string;
+    instructions: string;
+    model: Record<string, unknown>;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    description?: string | undefined;
+    tools?: string[] | undefined;
+    defaultOptions?: Record<string, unknown> | undefined;
+    workflows?: string[] | undefined;
+    agents?: string[] | undefined;
+    integrationTools?: string[] | undefined;
+    inputProcessors?: Record<string, unknown>[] | undefined;
+    outputProcessors?: Record<string, unknown>[] | undefined;
+    memory?: string | undefined;
+    scorers?: Record<string, {
+        sampling?: {
+            type: "count" | "ratio";
+            rate?: number | undefined;
+            count?: number | undefined;
+        } | undefined;
+    }> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    ownerId?: string | undefined;
+}, "json">;
+/**
+ * POST /stored/agents - Create a new stored agent
+ */
+export declare const CREATE_STORED_AGENT_ROUTE: import("../server-adapter").ServerRoute<{
+    name: string;
+    instructions: string;
+    model: Record<string, unknown>;
+    id: string;
+    description?: string | undefined;
+    tools?: string[] | undefined;
+    defaultOptions?: Record<string, unknown> | undefined;
+    workflows?: string[] | undefined;
+    agents?: string[] | undefined;
+    integrationTools?: string[] | undefined;
+    inputProcessors?: Record<string, unknown>[] | undefined;
+    outputProcessors?: Record<string, unknown>[] | undefined;
+    memory?: string | undefined;
+    scorers?: Record<string, {
+        sampling?: {
+            type: "count" | "ratio";
+            rate?: number | undefined;
+            count?: number | undefined;
+        } | undefined;
+    }> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    ownerId?: string | undefined;
+}, {
+    name: string;
+    instructions: string;
+    model: Record<string, unknown>;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    description?: string | undefined;
+    tools?: string[] | undefined;
+    defaultOptions?: Record<string, unknown> | undefined;
+    workflows?: string[] | undefined;
+    agents?: string[] | undefined;
+    integrationTools?: string[] | undefined;
+    inputProcessors?: Record<string, unknown>[] | undefined;
+    outputProcessors?: Record<string, unknown>[] | undefined;
+    memory?: string | undefined;
+    scorers?: Record<string, {
+        sampling?: {
+            type: "count" | "ratio";
+            rate?: number | undefined;
+            count?: number | undefined;
+        } | undefined;
+    }> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    ownerId?: string | undefined;
+}, "json">;
+/**
+ * PATCH /stored/agents/:storedAgentId - Update a stored agent
+ */
+export declare const UPDATE_STORED_AGENT_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
+    storedAgentId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodString>>;
+    instructions: import("zod").ZodOptional<import("zod").ZodString>;
+    model: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    tools: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>>;
+    defaultOptions: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    workflows: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>>;
+    agents: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>>;
+    integrationTools: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>>;
+    inputProcessors: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>>;
+    outputProcessors: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>>;
+    memory: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodString>>;
+    scorers: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        sampling: import("zod").ZodOptional<import("zod").ZodObject<{
+            type: import("zod").ZodEnum<{
+                count: "count";
+                ratio: "ratio";
+            }>;
+            rate: import("zod").ZodOptional<import("zod").ZodNumber>;
+            count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>>>;
+    metadata: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    ownerId: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>>, {
+    name: string;
+    instructions: string;
+    model: Record<string, unknown>;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    description?: string | undefined;
+    tools?: string[] | undefined;
+    defaultOptions?: Record<string, unknown> | undefined;
+    workflows?: string[] | undefined;
+    agents?: string[] | undefined;
+    integrationTools?: string[] | undefined;
+    inputProcessors?: Record<string, unknown>[] | undefined;
+    outputProcessors?: Record<string, unknown>[] | undefined;
+    memory?: string | undefined;
+    scorers?: Record<string, {
+        sampling?: {
+            type: "count" | "ratio";
+            rate?: number | undefined;
+            count?: number | undefined;
+        } | undefined;
+    }> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    ownerId?: string | undefined;
+}, "json">;
+/**
+ * DELETE /stored/agents/:storedAgentId - Delete a stored agent
+ */
+export declare const DELETE_STORED_AGENT_ROUTE: import("../server-adapter").ServerRoute<{
+    storedAgentId: string;
+}, {
+    success: boolean;
+    message: string;
+}, "json">;
+//# sourceMappingURL=stored-agents.d.ts.map

package/dist/server/handlers/stored-agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored-agents.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/stored-agents.ts"],"names":[],"mappings":"AAqBA;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAoCnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmCjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA6EpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmFpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;UAuCpC,CAAC"}

package/dist/server/handlers/stored-agents.js

@@ -0,0 +1,3 @@
+export { CREATE_STORED_AGENT_ROUTE, DELETE_STORED_AGENT_ROUTE, GET_STORED_AGENT_ROUTE, LIST_STORED_AGENTS_ROUTE, UPDATE_STORED_AGENT_ROUTE } from '../../chunk-IROUDQSO.js';
+//# sourceMappingURL=stored-agents.js.map
+//# sourceMappingURL=stored-agents.js.map

package/dist/server/handlers/stored-agents.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"stored-agents.js"}

package/dist/server/handlers/system.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunkCRCXQW5R_cjs = require('../../chunk-CRCXQW5R.cjs');
+
+
+
+Object.defineProperty(exports, "GET_SYSTEM_PACKAGES_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkCRCXQW5R_cjs.GET_SYSTEM_PACKAGES_ROUTE; }
+});
+//# sourceMappingURL=system.cjs.map
+//# sourceMappingURL=system.cjs.map

package/dist/server/handlers/system.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"system.cjs"}

package/dist/server/handlers/system.d.ts

@@ -0,0 +1,7 @@
+export declare const GET_SYSTEM_PACKAGES_ROUTE: import("../server-adapter").ServerRoute<{}, {
+    packages: {
+        name: string;
+        version: string;
+    }[];
+}, "json">;
+//# sourceMappingURL=system.d.ts.map

package/dist/server/handlers/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/system.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,yBAAyB;;;;;UA6BpC,CAAC"}

package/dist/server/handlers/system.js

@@ -0,0 +1,3 @@
+export { GET_SYSTEM_PACKAGES_ROUTE } from '../../chunk-6OFKRQQL.js';
+//# sourceMappingURL=system.js.map
+//# sourceMappingURL=system.js.map

package/dist/server/handlers/system.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"system.js"}

package/dist/server/handlers/test-utils.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var requestContext = require('@mastra/core/request-context');
+
+function createTestServerContext({ mastra }) {
+  return {
+    mastra,
+    requestContext: new requestContext.RequestContext(),
+    abortSignal: new AbortController().signal
+  };
+}
+
+exports.createTestServerContext = createTestServerContext;
+//# sourceMappingURL=test-utils.cjs.map
+//# sourceMappingURL=test-utils.cjs.map

package/dist/server/handlers/test-utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/handlers/test-utils.ts"],"names":["RequestContext"],"mappings":";;;;AAIO,SAAS,uBAAA,CAAwB,EAAE,MAAA,EAAO,EAAsC;AACrF,EAAA,OAAO;AAAA,IACL,MAAA;AAAA,IACA,cAAA,EAAgB,IAAIA,6BAAA,EAAe;AAAA,IACnC,WAAA,EAAa,IAAI,eAAA,EAAgB,CAAE;AAAA,GACrC;AACF","file":"test-utils.cjs","sourcesContent":["import type { Mastra } from '@mastra/core';\nimport { RequestContext } from '@mastra/core/request-context';\nimport type { ServerContext } from '../server-adapter';\n\nexport function createTestServerContext({ mastra }: { mastra: Mastra }): ServerContext {\n  return {\n    mastra,\n    requestContext: new RequestContext(),\n    abortSignal: new AbortController().signal,\n  };\n}\n"]}

package/dist/server/handlers/test-utils.d.ts

@@ -0,0 +1,6 @@
+import type { Mastra } from '@mastra/core';
+import type { ServerContext } from '../server-adapter/index.js';
+export declare function createTestServerContext({ mastra }: {
+    mastra: Mastra;
+}): ServerContext;
+//# sourceMappingURL=test-utils.d.ts.map

package/dist/server/handlers/test-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,wBAAgB,uBAAuB,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,aAAa,CAMrF"}

package/dist/server/handlers/test-utils.js

@@ -0,0 +1,13 @@
+import { RequestContext } from '@mastra/core/request-context';
+
+function createTestServerContext({ mastra }) {
+  return {
+    mastra,
+    requestContext: new RequestContext(),
+    abortSignal: new AbortController().signal
+  };
+}
+
+export { createTestServerContext };
+//# sourceMappingURL=test-utils.js.map
+//# sourceMappingURL=test-utils.js.map

package/dist/server/handlers/test-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/handlers/test-utils.ts"],"names":[],"mappings":";;AAIO,SAAS,uBAAA,CAAwB,EAAE,MAAA,EAAO,EAAsC;AACrF,EAAA,OAAO;AAAA,IACL,MAAA;AAAA,IACA,cAAA,EAAgB,IAAI,cAAA,EAAe;AAAA,IACnC,WAAA,EAAa,IAAI,eAAA,EAAgB,CAAE;AAAA,GACrC;AACF","file":"test-utils.js","sourcesContent":["import type { Mastra } from '@mastra/core';\nimport { RequestContext } from '@mastra/core/request-context';\nimport type { ServerContext } from '../server-adapter';\n\nexport function createTestServerContext({ mastra }: { mastra: Mastra }): ServerContext {\n  return {\n    mastra,\n    requestContext: new RequestContext(),\n    abortSignal: new AbortController().signal,\n  };\n}\n"]}

package/dist/server/handlers/tools.cjs

@@ -1,28 +1,28 @@
 'use strict';
 
-var chunkTRGAMKHX_cjs = require('../../chunk-TRGAMKHX.cjs');
+var chunk6NLJ5YC3_cjs = require('../../chunk-6NLJ5YC3.cjs');
 
 
 
-Object.defineProperty(exports, "executeAgentToolHandler", {
+Object.defineProperty(exports, "EXECUTE_AGENT_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkTRGAMKHX_cjs.executeAgentToolHandler; }
+  get: function () { return chunk6NLJ5YC3_cjs.EXECUTE_AGENT_TOOL_ROUTE; }
 });
-Object.defineProperty(exports, "executeToolHandler", {
+Object.defineProperty(exports, "EXECUTE_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkTRGAMKHX_cjs.executeToolHandler; }
+  get: function () { return chunk6NLJ5YC3_cjs.EXECUTE_TOOL_ROUTE; }
 });
-Object.defineProperty(exports, "getAgentToolHandler", {
+Object.defineProperty(exports, "GET_AGENT_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkTRGAMKHX_cjs.getAgentToolHandler; }
+  get: function () { return chunk6NLJ5YC3_cjs.GET_AGENT_TOOL_ROUTE; }
 });
-Object.defineProperty(exports, "getToolByIdHandler", {
+Object.defineProperty(exports, "GET_TOOL_BY_ID_ROUTE", {
   enumerable: true,
-  get: function () { return chunkTRGAMKHX_cjs.getToolByIdHandler; }
+  get: function () { return chunk6NLJ5YC3_cjs.GET_TOOL_BY_ID_ROUTE; }
 });
-Object.defineProperty(exports, "getToolsHandler", {
+Object.defineProperty(exports, "LIST_TOOLS_ROUTE", {
   enumerable: true,
-  get: function () { return chunkTRGAMKHX_cjs.getToolsHandler; }
+  get: function () { return chunk6NLJ5YC3_cjs.LIST_TOOLS_ROUTE; }
 });
 //# sourceMappingURL=tools.cjs.map
 //# sourceMappingURL=tools.cjs.map

package/dist/server/handlers/tools.d.ts

@@ -1,25 +1,42 @@
-import type { RuntimeContext } from '@mastra/core/di';
-import type { ToolAction, VercelTool } from '@mastra/core/tools';
-import type { Context } from '../types.js';
-interface ToolsContext extends Context {
-    tools?: Record<string, ToolAction | VercelTool>;
-    toolId?: string;
-    runId?: string;
-}
-export declare function getToolsHandler({ tools }: Pick<ToolsContext, 'tools'>): Promise<Record<string, any>>;
-export declare function getToolByIdHandler({ tools, toolId }: Pick<ToolsContext, 'tools' | 'toolId'>): Promise<any>;
-export declare function executeToolHandler(tools: ToolsContext['tools']): ({ mastra, runId, toolId, data, runtimeContext, }: Pick<ToolsContext, "mastra" | "toolId" | "runId"> & {
-    data?: unknown;
-    runtimeContext: RuntimeContext;
-}) => Promise<any>;
-export declare function getAgentToolHandler({ mastra, agentId, toolId, runtimeContext, }: Pick<ToolsContext, 'mastra' | 'toolId'> & {
-    agentId?: string;
-    runtimeContext: RuntimeContext;
-}): Promise<any>;
-export declare function executeAgentToolHandler({ mastra, agentId, toolId, data, runtimeContext, }: Pick<ToolsContext, 'mastra' | 'toolId'> & {
-    agentId?: string;
-    data: any;
-    runtimeContext: RuntimeContext;
-}): Promise<any>;
-export {};
+export declare const LIST_TOOLS_ROUTE: import("../server-adapter").ServerRoute<{}, Record<string, {
+    id: string;
+    description?: string | undefined;
+    inputSchema?: string | undefined;
+    outputSchema?: string | undefined;
+    requireApproval?: boolean | undefined;
+}>, "json">;
+export declare const GET_TOOL_BY_ID_ROUTE: import("../server-adapter").ServerRoute<{
+    toolId: string;
+}, {
+    id: string;
+    description?: string | undefined;
+    inputSchema?: string | undefined;
+    outputSchema?: string | undefined;
+    requireApproval?: boolean | undefined;
+}, "json">;
+export declare const EXECUTE_TOOL_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
+    toolId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    runId: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    data: import("zod").ZodCustom<unknown, unknown>;
+    requestContext: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+}, import("zod/v4/core").$strip>>, any, "json">;
+export declare const GET_AGENT_TOOL_ROUTE: import("../server-adapter").ServerRoute<{
+    agentId: string;
+    toolId: string;
+}, {
+    id: string;
+    description?: string | undefined;
+    inputSchema?: string | undefined;
+    outputSchema?: string | undefined;
+    requireApproval?: boolean | undefined;
+}, "json">;
+export declare const EXECUTE_AGENT_TOOL_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
+    agentId: import("zod").ZodString;
+    toolId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    data: import("zod").ZodCustom<unknown, unknown>;
+    requestContext: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+}, import("zod/v4/core").$strip>>, any, "json">;
 //# sourceMappingURL=tools.d.ts.map

package/dist/server/handlers/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAKjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAKxC,UAAU,YAAa,SAAQ,OAAO;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC,CAAC;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAGD,wBAAsB,eAAe,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,gCAuB3E;AAED,wBAAsB,kBAAkB,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,GAAG,QAAQ,CAAC,gBAkBjG;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,IAC/C,kDAMX,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC,GAAG;IACrD,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,cAAc,EAAE,cAAc,CAAC;CAChC,kBAqCF;AAED,wBAAsB,mBAAmB,CAAC,EACxC,MAAM,EACN,OAAO,EACP,MAAM,EACN,cAAc,GACf,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,QAAQ,CAAC,GAAG;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,cAAc,CAAC;CAChC,gBAyBA;AAED,wBAAsB,uBAAuB,CAAC,EAC5C,MAAM,EACN,OAAO,EACP,MAAM,EACN,IAAI,EACJ,cAAc,GACf,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,QAAQ,CAAC,GAAG;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,GAAG,CAAC;IACV,cAAc,EAAE,cAAc,CAAC;CAChC,gBAsCA"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/tools.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,gBAAgB;;;;;;WA+B3B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;UAoC/B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;+CA+D7B,CAAC;AAMH,eAAO,MAAM,oBAAoB;;;;;;;;;UAoC/B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;+CA0CnC,CAAC"}

package/dist/server/handlers/tools.js

@@ -1,3 +1,3 @@
-export { executeAgentToolHandler, executeToolHandler, getAgentToolHandler, getToolByIdHandler, getToolsHandler } from '../../chunk-AHB4JCIQ.js';
+export { EXECUTE_AGENT_TOOL_ROUTE, EXECUTE_TOOL_ROUTE, GET_AGENT_TOOL_ROUTE, GET_TOOL_BY_ID_ROUTE, LIST_TOOLS_ROUTE } from '../../chunk-UVE6SV6I.js';
 //# sourceMappingURL=tools.js.map
 //# sourceMappingURL=tools.js.map

package/dist/server/handlers/utils.cjs

@@ -1,16 +1,24 @@
 'use strict';
 
-var chunkG4PUALCE_cjs = require('../../chunk-G4PUALCE.cjs');
+var chunk5W4RPVTK_cjs = require('../../chunk-5W4RPVTK.cjs');
 
 
 
+Object.defineProperty(exports, "parseFilters", {
+  enumerable: true,
+  get: function () { return chunk5W4RPVTK_cjs.parseFilters; }
+});
+Object.defineProperty(exports, "parsePerPage", {
+  enumerable: true,
+  get: function () { return chunk5W4RPVTK_cjs.parsePerPage; }
+});
 Object.defineProperty(exports, "sanitizeBody", {
   enumerable: true,
-  get: function () { return chunkG4PUALCE_cjs.sanitizeBody; }
+  get: function () { return chunk5W4RPVTK_cjs.sanitizeBody; }
 });
 Object.defineProperty(exports, "validateBody", {
   enumerable: true,
-  get: function () { return chunkG4PUALCE_cjs.validateBody; }
+  get: function () { return chunk5W4RPVTK_cjs.validateBody; }
 });
 //# sourceMappingURL=utils.cjs.map
 //# sourceMappingURL=utils.cjs.map

package/dist/server/handlers/utils.d.ts

@@ -5,4 +5,9 @@ export declare function validateBody(body: Record<string, unknown>): void;
  * @param disallowedKeys keys to remove from the body
  */
 export declare function sanitizeBody(body: Record<string, unknown>, disallowedKeys: string[]): void;
+export declare function parsePerPage(value: string | undefined, defaultValue?: number, max?: number): number | false;
+/**
+ * Parses filter query parameters into a key-value object.
+ */
+export declare function parseFilters(filters: string | string[] | undefined): Record<string, string> | undefined;
 //# sourceMappingURL=utils.d.ts.map

package/dist/server/handlers/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/utils.ts"],"names":[],"mappings":"AAGA,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAWzD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,EAAE,MAAM,EAAE,QAMnF"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/utils.ts"],"names":[],"mappings":"AAGA,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QAWzD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,EAAE,MAAM,EAAE,QAMnF;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,YAAY,GAAE,MAAY,EAC1B,GAAG,GAAE,MAAa,GACjB,MAAM,GAAG,KAAK,CAShB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAUvG"}

package/dist/server/handlers/utils.js

@@ -1,3 +1,3 @@
-export { sanitizeBody, validateBody } from '../../chunk-4QCXUEAT.js';
+export { parseFilters, parsePerPage, sanitizeBody, validateBody } from '../../chunk-XWGAT2DA.js';
 //# sourceMappingURL=utils.js.map
 //# sourceMappingURL=utils.js.map

package/dist/server/handlers/vector.cjs

@@ -1,32 +1,56 @@
 'use strict';
 
-var chunkEP3JQDPD_cjs = require('../../chunk-EP3JQDPD.cjs');
+var chunkGGAV65A7_cjs = require('../../chunk-GGAV65A7.cjs');
 
 
 
+Object.defineProperty(exports, "CREATE_INDEX_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkGGAV65A7_cjs.CREATE_INDEX_ROUTE; }
+});
+Object.defineProperty(exports, "DELETE_INDEX_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkGGAV65A7_cjs.DELETE_INDEX_ROUTE; }
+});
+Object.defineProperty(exports, "DESCRIBE_INDEX_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkGGAV65A7_cjs.DESCRIBE_INDEX_ROUTE; }
+});
+Object.defineProperty(exports, "LIST_INDEXES_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkGGAV65A7_cjs.LIST_INDEXES_ROUTE; }
+});
+Object.defineProperty(exports, "QUERY_VECTORS_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkGGAV65A7_cjs.QUERY_VECTORS_ROUTE; }
+});
+Object.defineProperty(exports, "UPSERT_VECTORS_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkGGAV65A7_cjs.UPSERT_VECTORS_ROUTE; }
+});
 Object.defineProperty(exports, "createIndex", {
   enumerable: true,
-  get: function () { return chunkEP3JQDPD_cjs.createIndex; }
+  get: function () { return chunkGGAV65A7_cjs.createIndex; }
 });
 Object.defineProperty(exports, "deleteIndex", {
   enumerable: true,
-  get: function () { return chunkEP3JQDPD_cjs.deleteIndex; }
+  get: function () { return chunkGGAV65A7_cjs.deleteIndex; }
 });
 Object.defineProperty(exports, "describeIndex", {
   enumerable: true,
-  get: function () { return chunkEP3JQDPD_cjs.describeIndex; }
+  get: function () { return chunkGGAV65A7_cjs.describeIndex; }
 });
 Object.defineProperty(exports, "listIndexes", {
   enumerable: true,
-  get: function () { return chunkEP3JQDPD_cjs.listIndexes; }
+  get: function () { return chunkGGAV65A7_cjs.listIndexes; }
 });
 Object.defineProperty(exports, "queryVectors", {
   enumerable: true,
-  get: function () { return chunkEP3JQDPD_cjs.queryVectors; }
+  get: function () { return chunkGGAV65A7_cjs.queryVectors; }
 });
 Object.defineProperty(exports, "upsertVectors", {
   enumerable: true,
-  get: function () { return chunkEP3JQDPD_cjs.upsertVectors; }
+  get: function () { return chunkGGAV65A7_cjs.upsertVectors; }
 });
 //# sourceMappingURL=vector.cjs.map
 //# sourceMappingURL=vector.cjs.map

package/dist/server/handlers/vector.d.ts

@@ -21,19 +21,13 @@ interface QueryRequest {
     filter?: Record<string, any>;
     includeVector?: boolean;
 }
-export declare function upsertVectors({ mastra, vectorName, index }: VectorContext & {
-    index: UpsertRequest;
-}): Promise<{
+export declare function upsertVectors({ mastra, vectorName, indexName, vectors, metadata, ids, }: VectorContext & UpsertRequest): Promise<{
     ids: string[];
 }>;
-export declare function createIndex({ mastra, vectorName, index, }: Pick<VectorContext, 'mastra' | 'vectorName'> & {
-    index: CreateIndexRequest;
-}): Promise<{
+export declare function createIndex({ mastra, vectorName, indexName, dimension, metric, }: Pick<VectorContext, 'mastra' | 'vectorName'> & CreateIndexRequest): Promise<{
     success: boolean;
 }>;
-export declare function queryVectors({ mastra, vectorName, query, }: Pick<VectorContext, 'mastra' | 'vectorName'> & {
-    query: QueryRequest;
-}): Promise<QueryResult[]>;
+export declare function queryVectors({ mastra, vectorName, indexName, queryVector, topK, filter, includeVector, }: Pick<VectorContext, 'mastra' | 'vectorName'> & QueryRequest): Promise<QueryResult[]>;
 export declare function listIndexes({ mastra, vectorName }: Pick<VectorContext, 'mastra' | 'vectorName'>): Promise<string[]>;
 export declare function describeIndex({ mastra, vectorName, indexName, }: Pick<VectorContext, 'mastra' | 'vectorName'> & {
     indexName?: string;
@@ -47,5 +41,54 @@ export declare function deleteIndex({ mastra, vectorName, indexName, }: Pick<Vec
 }): Promise<{
     success: boolean;
 }>;
+export declare const UPSERT_VECTORS_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
+    vectorName: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    indexName: import("zod").ZodString;
+    vectors: import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodNumber>>;
+    metadata: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>>;
+    ids: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>>, {
+    ids: string[];
+}, "json">;
+export declare const CREATE_INDEX_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
+    vectorName: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    indexName: import("zod").ZodString;
+    dimension: import("zod").ZodNumber;
+    metric: import("zod").ZodOptional<import("zod").ZodEnum<{
+        cosine: "cosine";
+        euclidean: "euclidean";
+        dotproduct: "dotproduct";
+    }>>;
+}, import("zod/v4/core").$strip>>, {
+    success: boolean;
+}, "json">;
+export declare const QUERY_VECTORS_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
+    vectorName: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    indexName: import("zod").ZodString;
+    queryVector: import("zod").ZodArray<import("zod").ZodNumber>;
+    topK: import("zod").ZodOptional<import("zod").ZodNumber>;
+    filter: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+    includeVector: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>>, unknown[], "json">;
+export declare const LIST_INDEXES_ROUTE: import("../server-adapter").ServerRoute<{
+    vectorName: string;
+}, string[], "json">;
+export declare const DESCRIBE_INDEX_ROUTE: import("../server-adapter").ServerRoute<{
+    vectorName: string;
+    indexName: string;
+}, {
+    dimension: number;
+    count: number;
+    metric?: string | undefined;
+}, "json">;
+export declare const DELETE_INDEX_ROUTE: import("../server-adapter").ServerRoute<{
+    vectorName: string;
+    indexName: string;
+}, {
+    success: boolean;
+}, "json">;
 export {};
 //# sourceMappingURL=vector.d.ts.map