@mastra/server 0.0.0-bundle-dynamic-imports-20250424001248 → 0.0.0-bundle-studio-cloud-20251222034739

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

@@ -0,0 +1,289 @@
+/**
+ * GET /api/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").ZodNumber>>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+} & {
+    orderBy: import("zod").ZodOptional<import("zod").ZodObject<{
+        field: import("zod").ZodOptional<import("zod").ZodEnum<["createdAt", "updatedAt"]>>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<["ASC", "DESC"]>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        field?: "createdAt" | "updatedAt" | undefined;
+        direction?: "ASC" | "DESC" | undefined;
+    }, {
+        field?: "createdAt" | "updatedAt" | undefined;
+        direction?: "ASC" | "DESC" | undefined;
+    }>>;
+}, "strip", import("zod").ZodTypeAny, {
+    page: number;
+    perPage: number;
+    orderBy?: {
+        field?: "createdAt" | "updatedAt" | undefined;
+        direction?: "ASC" | "DESC" | undefined;
+    } | undefined;
+}, {
+    page?: number | undefined;
+    perPage?: number | undefined;
+    orderBy?: {
+        field?: "createdAt" | "updatedAt" | undefined;
+        direction?: "ASC" | "DESC" | undefined;
+    } | undefined;
+}> | import("zod").ZodObject<{
+    perPage: import("zod").ZodOptional<import("zod").ZodNumber>;
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+} & {
+    orderBy: import("zod").ZodOptional<import("zod").ZodObject<{
+        field: import("zod").ZodOptional<import("zod").ZodEnum<["createdAt", "updatedAt"]>>;
+        direction: import("zod").ZodOptional<import("zod").ZodEnum<["ASC", "DESC"]>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        field?: "createdAt" | "updatedAt" | undefined;
+        direction?: "ASC" | "DESC" | undefined;
+    }, {
+        field?: "createdAt" | "updatedAt" | undefined;
+        direction?: "ASC" | "DESC" | undefined;
+    }>>;
+}, "strip", import("zod").ZodTypeAny, {
+    page: number;
+    perPage?: number | undefined;
+    orderBy?: {
+        field?: "createdAt" | "updatedAt" | undefined;
+        direction?: "ASC" | "DESC" | undefined;
+    } | undefined;
+}, {
+    page?: number | undefined;
+    perPage?: number | undefined;
+    orderBy?: {
+        field?: "createdAt" | "updatedAt" | undefined;
+        direction?: "ASC" | "DESC" | undefined;
+    } | undefined;
+}>, undefined>, {
+    total: number;
+    page: number;
+    perPage: number | false;
+    hasMore: boolean;
+    agents: {
+        name: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        model: Record<string, unknown>;
+        instructions: string;
+        metadata?: Record<string, unknown> | undefined;
+        description?: string | undefined;
+        tools?: string[] | undefined;
+        agents?: string[] | undefined;
+        workflows?: string[] | undefined;
+        inputProcessors?: Record<string, unknown>[] | undefined;
+        outputProcessors?: Record<string, unknown>[] | undefined;
+        defaultOptions?: Record<string, unknown> | undefined;
+        memory?: string | undefined;
+        scorers?: Record<string, {
+            sampling?: {
+                type: "count" | "ratio";
+                count?: number | undefined;
+                rate?: number | undefined;
+            } | undefined;
+        }> | undefined;
+    }[];
+}, "json">;
+/**
+ * GET /api/stored/agents/:storedAgentId - Get a stored agent by ID
+ */
+export declare const GET_STORED_AGENT_ROUTE: import("../server-adapter").ServerRoute<{
+    storedAgentId: string;
+}, {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    model: Record<string, unknown>;
+    instructions: string;
+    metadata?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    tools?: string[] | undefined;
+    agents?: string[] | undefined;
+    workflows?: string[] | undefined;
+    inputProcessors?: Record<string, unknown>[] | undefined;
+    outputProcessors?: Record<string, unknown>[] | undefined;
+    defaultOptions?: Record<string, unknown> | undefined;
+    memory?: string | undefined;
+    scorers?: Record<string, {
+        sampling?: {
+            type: "count" | "ratio";
+            count?: number | undefined;
+            rate?: number | undefined;
+        } | undefined;
+    }> | undefined;
+}, "json">;
+/**
+ * POST /api/stored/agents - Create a new stored agent
+ */
+export declare const CREATE_STORED_AGENT_ROUTE: import("../server-adapter").ServerRoute<{
+    name: string;
+    id: string;
+    model: Record<string, unknown>;
+    instructions: string;
+    metadata?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    tools?: string[] | undefined;
+    agents?: string[] | undefined;
+    workflows?: string[] | undefined;
+    inputProcessors?: Record<string, unknown>[] | undefined;
+    outputProcessors?: Record<string, unknown>[] | undefined;
+    defaultOptions?: Record<string, unknown> | undefined;
+    memory?: string | undefined;
+    scorers?: Record<string, {
+        sampling?: {
+            type: "count" | "ratio";
+            count?: number | undefined;
+            rate?: number | undefined;
+        } | undefined;
+    }> | undefined;
+}, {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    model: Record<string, unknown>;
+    instructions: string;
+    metadata?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    tools?: string[] | undefined;
+    agents?: string[] | undefined;
+    workflows?: string[] | undefined;
+    inputProcessors?: Record<string, unknown>[] | undefined;
+    outputProcessors?: Record<string, unknown>[] | undefined;
+    defaultOptions?: Record<string, unknown> | undefined;
+    memory?: string | undefined;
+    scorers?: Record<string, {
+        sampling?: {
+            type: "count" | "ratio";
+            count?: number | undefined;
+            rate?: number | undefined;
+        } | undefined;
+    }> | undefined;
+}, "json">;
+/**
+ * PATCH /api/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;
+}, "strip", import("zod").ZodTypeAny, {
+    storedAgentId: string;
+}, {
+    storedAgentId: string;
+}>, 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, "many">>>;
+    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, "many">>>;
+    agents: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>>;
+    inputProcessors: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>, "many">>>;
+    outputProcessors: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>, "many">>>;
+    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<["ratio", "count"]>;
+            rate: import("zod").ZodOptional<import("zod").ZodNumber>;
+            count: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            type: "count" | "ratio";
+            count?: number | undefined;
+            rate?: number | undefined;
+        }, {
+            type: "count" | "ratio";
+            count?: number | undefined;
+            rate?: number | undefined;
+        }>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        sampling?: {
+            type: "count" | "ratio";
+            count?: number | undefined;
+            rate?: number | undefined;
+        } | undefined;
+    }, {
+        sampling?: {
+            type: "count" | "ratio";
+            count?: number | undefined;
+            rate?: number | undefined;
+        } | undefined;
+    }>>>>;
+    metadata: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+}, "strip", import("zod").ZodTypeAny, {
+    metadata?: Record<string, unknown> | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    model?: Record<string, unknown> | undefined;
+    instructions?: string | undefined;
+    tools?: string[] | undefined;
+    agents?: string[] | undefined;
+    workflows?: string[] | undefined;
+    inputProcessors?: Record<string, unknown>[] | undefined;
+    outputProcessors?: Record<string, unknown>[] | undefined;
+    defaultOptions?: Record<string, unknown> | undefined;
+    memory?: string | undefined;
+    scorers?: Record<string, {
+        sampling?: {
+            type: "count" | "ratio";
+            count?: number | undefined;
+            rate?: number | undefined;
+        } | undefined;
+    }> | undefined;
+}, {
+    metadata?: Record<string, unknown> | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    model?: Record<string, unknown> | undefined;
+    instructions?: string | undefined;
+    tools?: string[] | undefined;
+    agents?: string[] | undefined;
+    workflows?: string[] | undefined;
+    inputProcessors?: Record<string, unknown>[] | undefined;
+    outputProcessors?: Record<string, unknown>[] | undefined;
+    defaultOptions?: Record<string, unknown> | undefined;
+    memory?: string | undefined;
+    scorers?: Record<string, {
+        sampling?: {
+            type: "count" | "ratio";
+            count?: number | undefined;
+            rate?: number | undefined;
+        } | undefined;
+    }> | undefined;
+}>>, {
+    name: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    model: Record<string, unknown>;
+    instructions: string;
+    metadata?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    tools?: string[] | undefined;
+    agents?: string[] | undefined;
+    workflows?: string[] | undefined;
+    inputProcessors?: Record<string, unknown>[] | undefined;
+    outputProcessors?: Record<string, unknown>[] | undefined;
+    defaultOptions?: Record<string, unknown> | undefined;
+    memory?: string | undefined;
+    scorers?: Record<string, {
+        sampling?: {
+            type: "count" | "ratio";
+            count?: number | undefined;
+            rate?: number | undefined;
+        } | undefined;
+    }> | undefined;
+}, "json">;
+/**
+ * DELETE /api/stored/agents/:storedAgentId - Delete a stored agent
+ */
+export declare const DELETE_STORED_AGENT_ROUTE: import("../server-adapter").ServerRoute<{
+    storedAgentId: string;
+}, {
+    message: string;
+    success: boolean;
+}, "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":"AAoBA;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAgCnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;UAgCjC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAsEpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqEpC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;UAkCpC,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-HAJOEDNB.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/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,22 +1,28 @@
 'use strict';
 
-var chunkD3G23FP3_cjs = require('../../chunk-D3G23FP3.cjs');
+var chunkBNGT3NIC_cjs = require('../../chunk-BNGT3NIC.cjs');
 
 
 
-Object.defineProperty(exports, "executeAgentToolHandler", {
+Object.defineProperty(exports, "EXECUTE_AGENT_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkD3G23FP3_cjs.executeAgentToolHandler; }
+  get: function () { return chunkBNGT3NIC_cjs.EXECUTE_AGENT_TOOL_ROUTE; }
 });
-Object.defineProperty(exports, "executeToolHandler", {
+Object.defineProperty(exports, "EXECUTE_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkD3G23FP3_cjs.executeToolHandler; }
+  get: function () { return chunkBNGT3NIC_cjs.EXECUTE_TOOL_ROUTE; }
 });
-Object.defineProperty(exports, "getToolByIdHandler", {
+Object.defineProperty(exports, "GET_AGENT_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkD3G23FP3_cjs.getToolByIdHandler; }
+  get: function () { return chunkBNGT3NIC_cjs.GET_AGENT_TOOL_ROUTE; }
 });
-Object.defineProperty(exports, "getToolsHandler", {
+Object.defineProperty(exports, "GET_TOOL_BY_ID_ROUTE", {
   enumerable: true,
-  get: function () { return chunkD3G23FP3_cjs.getToolsHandler; }
+  get: function () { return chunkBNGT3NIC_cjs.GET_TOOL_BY_ID_ROUTE; }
 });
+Object.defineProperty(exports, "LIST_TOOLS_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkBNGT3NIC_cjs.LIST_TOOLS_ROUTE; }
+});
+//# sourceMappingURL=tools.cjs.map
+//# sourceMappingURL=tools.cjs.map

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

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

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

@@ -1,4 +1,71 @@
-export { getToolsHandler } from '../../_tsup-dts-rollup.js';
-export { getToolByIdHandler } from '../../_tsup-dts-rollup.js';
-export { executeToolHandler } from '../../_tsup-dts-rollup.js';
-export { executeAgentToolHandler } from '../../_tsup-dts-rollup.js';
+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;
+}, "strip", import("zod").ZodTypeAny, {
+    toolId: string;
+}, {
+    toolId: string;
+}>, 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>;
+} & {
+    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">;
+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;
+}, "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>;
+} & {
+    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">;
+//# sourceMappingURL=tools.d.ts.map

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

@@ -0,0 +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"}

package/dist/server/handlers/tools.js

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

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

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

package/dist/server/handlers/utils.cjs

@@ -1,10 +1,24 @@
 'use strict';
 
-var chunkQN4KF3BH_cjs = require('../../chunk-QN4KF3BH.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 chunk5W4RPVTK_cjs.sanitizeBody; }
+});
 Object.defineProperty(exports, "validateBody", {
   enumerable: true,
-  get: function () { return chunkQN4KF3BH_cjs.validateBody; }
+  get: function () { return chunk5W4RPVTK_cjs.validateBody; }
 });
+//# sourceMappingURL=utils.cjs.map
+//# sourceMappingURL=utils.cjs.map

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

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

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

@@ -1 +1,13 @@
-export { validateBody } from '../../_tsup-dts-rollup.js';
+export declare function validateBody(body: Record<string, unknown>): void;
+/**
+ * sanitizes the body by removing disallowed keys.
+ * @param body body to sanitize
+ * @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

@@ -0,0 +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;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 +1,3 @@
-export { validateBody } from '../../chunk-L7XE5QTW.js';
+export { parseFilters, parsePerPage, sanitizeBody, validateBody } from '../../chunk-XWGAT2DA.js';
+//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=utils.js.map

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

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

package/dist/server/handlers/vector.cjs

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

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

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