@mastra/server 0.0.0-span-scorring-test-20251124132129 → 0.0.0-standard-schema-20260126101119

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

@@ -0,0 +1,28 @@
+'use strict';
+
+var chunkQHJ75L3U_cjs = require('../../chunk-QHJ75L3U.cjs');
+
+
+
+Object.defineProperty(exports, "CREATE_STORED_AGENT_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkQHJ75L3U_cjs.CREATE_STORED_AGENT_ROUTE; }
+});
+Object.defineProperty(exports, "DELETE_STORED_AGENT_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkQHJ75L3U_cjs.DELETE_STORED_AGENT_ROUTE; }
+});
+Object.defineProperty(exports, "GET_STORED_AGENT_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkQHJ75L3U_cjs.GET_STORED_AGENT_ROUTE; }
+});
+Object.defineProperty(exports, "LIST_STORED_AGENTS_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkQHJ75L3U_cjs.LIST_STORED_AGENTS_ROUTE; }
+});
+Object.defineProperty(exports, "UPDATE_STORED_AGENT_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkQHJ75L3U_cjs.UPDATE_STORED_AGENT_ROUTE; }
+});
+//# sourceMappingURL=stored-agents.cjs.map
+//# sourceMappingURL=stored-agents.cjs.map

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

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

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-JW2MKBAS.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 chunkCK632IRI_cjs = require('../../chunk-CK632IRI.cjs');
+
+
+
+Object.defineProperty(exports, "GET_SYSTEM_PACKAGES_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkCK632IRI_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-G2F73L4P.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

@@ -2,7 +2,7 @@
 
 var requestContext = require('@mastra/core/request-context');
 
-function createTestRuntimeContext({ mastra }) {
+function createTestServerContext({ mastra }) {
   return {
     mastra,
     requestContext: new requestContext.RequestContext(),
@@ -10,6 +10,6 @@ function createTestRuntimeContext({ mastra }) {
   };
 }
 
-exports.createTestRuntimeContext = createTestRuntimeContext;
+exports.createTestServerContext = createTestServerContext;
 //# sourceMappingURL=test-utils.cjs.map
 //# sourceMappingURL=test-utils.cjs.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/server/handlers/test-utils.ts"],"names":["RequestContext"],"mappings":";;;;AAIO,SAAS,wBAAA,CAAyB,EAAE,MAAA,EAAO,EAAuC;AACvF,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 { RuntimeContext } from '../server-adapter';\n\nexport function createTestRuntimeContext({ mastra }: { mastra: Mastra }): RuntimeContext {\n  return {\n    mastra,\n    requestContext: new RequestContext(),\n    abortSignal: new AbortController().signal,\n  };\n}\n"]}
+{"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

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

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

@@ -1 +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,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,wBAAgB,wBAAwB,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,cAAc,CAMvF"}
+{"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

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

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/server/handlers/test-utils.ts"],"names":[],"mappings":";;AAIO,SAAS,wBAAA,CAAyB,EAAE,MAAA,EAAO,EAAuC;AACvF,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 { RuntimeContext } from '../server-adapter';\n\nexport function createTestRuntimeContext({ mastra }: { mastra: Mastra }): RuntimeContext {\n  return {\n    mastra,\n    requestContext: new RequestContext(),\n    abortSignal: new AbortController().signal,\n  };\n}\n"]}
+{"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 chunkKB5NSROG_cjs = require('../../chunk-KB5NSROG.cjs');
+var chunkHKK5WZO5_cjs = require('../../chunk-HKK5WZO5.cjs');
 
 
 
 Object.defineProperty(exports, "EXECUTE_AGENT_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkKB5NSROG_cjs.EXECUTE_AGENT_TOOL_ROUTE; }
+  get: function () { return chunkHKK5WZO5_cjs.EXECUTE_AGENT_TOOL_ROUTE; }
 });
 Object.defineProperty(exports, "EXECUTE_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkKB5NSROG_cjs.EXECUTE_TOOL_ROUTE; }
+  get: function () { return chunkHKK5WZO5_cjs.EXECUTE_TOOL_ROUTE; }
 });
 Object.defineProperty(exports, "GET_AGENT_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkKB5NSROG_cjs.GET_AGENT_TOOL_ROUTE; }
+  get: function () { return chunkHKK5WZO5_cjs.GET_AGENT_TOOL_ROUTE; }
 });
 Object.defineProperty(exports, "GET_TOOL_BY_ID_ROUTE", {
   enumerable: true,
-  get: function () { return chunkKB5NSROG_cjs.GET_TOOL_BY_ID_ROUTE; }
+  get: function () { return chunkHKK5WZO5_cjs.GET_TOOL_BY_ID_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_TOOLS_ROUTE", {
   enumerable: true,
-  get: function () { return chunkKB5NSROG_cjs.LIST_TOOLS_ROUTE; }
+  get: function () { return chunkHKK5WZO5_cjs.LIST_TOOLS_ROUTE; }
 });
 //# sourceMappingURL=tools.cjs.map
 //# sourceMappingURL=tools.cjs.map

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

@@ -16,27 +16,12 @@ export declare const GET_TOOL_BY_ID_ROUTE: import("../server-adapter").ServerRou
 }, "json">;
 export declare const EXECUTE_TOOL_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
     toolId: import("zod").ZodString;
-}, "strip", import("zod").ZodTypeAny, {
-    toolId: string;
-}, {
-    toolId: string;
-}>, import("zod").ZodObject<{
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     runId: import("zod").ZodOptional<import("zod").ZodString>;
-}, "strip", import("zod").ZodTypeAny, {
-    runId?: string | undefined;
-}, {
-    runId?: string | undefined;
-}>, import("zod").ZodObject<{
-    data: import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>;
-} & {
+}, 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>>;
-}, "strip", import("zod").ZodTypeAny, {
-    requestContext?: Record<string, any> | undefined;
-    data?: unknown;
-}, {
-    requestContext?: Record<string, any> | undefined;
-    data?: unknown;
-}>>, any, "json">;
+}, import("zod/v4/core").$strip>>, any, "json">;
 export declare const GET_AGENT_TOOL_ROUTE: import("../server-adapter").ServerRoute<{
     agentId: string;
     toolId: string;
@@ -49,23 +34,9 @@ export declare const GET_AGENT_TOOL_ROUTE: import("../server-adapter").ServerRou
 }, "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;
-}, "strip", import("zod").ZodTypeAny, {
-    agentId: string;
-    toolId: string;
-}, {
-    agentId: string;
-    toolId: string;
-}>, undefined, import("zod").ZodObject<{
-    data: import("zod").ZodType<unknown, import("zod").ZodTypeDef, unknown>;
-} & {
+}, 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>>;
-}, "strip", import("zod").ZodTypeAny, {
-    requestContext?: Record<string, any> | undefined;
-    data?: unknown;
-}, {
-    requestContext?: Record<string, any> | undefined;
-    data?: unknown;
-}>>, any, "json">;
+}, 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":"AAuBA,eAAO,MAAM,gBAAgB;;;;;;WA8B3B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;UAmC/B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;iBA8D7B,CAAC;AAMH,eAAO,MAAM,oBAAoB;;;;;;;;;UAmC/B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;iBAyCnC,CAAC"}
+{"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 { EXECUTE_AGENT_TOOL_ROUTE, EXECUTE_TOOL_ROUTE, GET_AGENT_TOOL_ROUTE, GET_TOOL_BY_ID_ROUTE, LIST_TOOLS_ROUTE } from '../../chunk-ICANWSEW.js';
+export { EXECUTE_AGENT_TOOL_ROUTE, EXECUTE_TOOL_ROUTE, GET_AGENT_TOOL_ROUTE, GET_TOOL_BY_ID_ROUTE, LIST_TOOLS_ROUTE } from '../../chunk-OJWVANX3.js';
 //# sourceMappingURL=tools.js.map
 //# sourceMappingURL=tools.js.map

package/dist/server/handlers/vector.cjs

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

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

@@ -43,77 +43,36 @@ export declare function deleteIndex({ mastra, vectorName, indexName, }: Pick<Vec
 }>;
 export declare const UPSERT_VECTORS_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
     vectorName: import("zod").ZodString;
-}, "strip", import("zod").ZodTypeAny, {
-    vectorName: string;
-}, {
-    vectorName: string;
-}>, undefined, import("zod").ZodObject<{
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
     indexName: import("zod").ZodString;
-} & {
-    vectors: import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodNumber, "many">, "many">;
-    metadata: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>, "many">>;
-    ids: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
-}, "strip", import("zod").ZodTypeAny, {
-    indexName: string;
-    vectors: number[][];
-    metadata?: Record<string, any>[] | undefined;
-    ids?: string[] | undefined;
-}, {
-    indexName: string;
-    vectors: number[][];
-    metadata?: Record<string, any>[] | undefined;
-    ids?: string[] | undefined;
-}>>, {
+    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;
-}, "strip", import("zod").ZodTypeAny, {
-    vectorName: string;
-}, {
-    vectorName: string;
-}>, undefined, import("zod").ZodObject<{
+}, 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", "euclidean", "dotproduct"]>>;
-}, "strip", import("zod").ZodTypeAny, {
-    indexName: string;
-    dimension: number;
-    metric?: "cosine" | "euclidean" | "dotproduct" | undefined;
-}, {
-    indexName: string;
-    dimension: number;
-    metric?: "cosine" | "euclidean" | "dotproduct" | undefined;
-}>>, {
+    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;
-}, "strip", import("zod").ZodTypeAny, {
-    vectorName: string;
-}, {
-    vectorName: string;
-}>, undefined, import("zod").ZodObject<{
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
     indexName: import("zod").ZodString;
-} & {
-    queryVector: import("zod").ZodArray<import("zod").ZodNumber, "many">;
+    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>;
-}, "strip", import("zod").ZodTypeAny, {
-    indexName: string;
-    queryVector: number[];
-    filter?: Record<string, any> | undefined;
-    topK?: number | undefined;
-    includeVector?: boolean | undefined;
-}, {
-    indexName: string;
-    queryVector: number[];
-    filter?: Record<string, any> | undefined;
-    topK?: number | undefined;
-    includeVector?: boolean | undefined;
-}>>, unknown[], "json">;
+}, import("zod/v4/core").$strip>>, unknown[], "json">;
 export declare const LIST_INDEXES_ROUTE: import("../server-adapter").ServerRoute<{
     vectorName: string;
 }, string[], "json">;
@@ -121,8 +80,8 @@ export declare const DESCRIBE_INDEX_ROUTE: import("../server-adapter").ServerRou
     vectorName: string;
     indexName: string;
 }, {
-    count: number;
     dimension: number;
+    count: number;
     metric?: string | undefined;
 }, "json">;
 export declare const DELETE_INDEX_ROUTE: import("../server-adapter").ServerRoute<{