@mastra/server 0.0.0-fix-backport-setserver-20251201151948 → 0.0.0-fix-request-context-as-query-key-20251209130646

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 createTestRuntimeContext({ mastra }) {
+  return {
+    mastra,
+    requestContext: new requestContext.RequestContext(),
+    abortSignal: new AbortController().signal
+  };
+}
+
+exports.createTestRuntimeContext = createTestRuntimeContext;
+//# 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,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"]}

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

@@ -0,0 +1,6 @@
+import type { Mastra } from '@mastra/core';
+import type { RuntimeContext } from '../server-adapter/index.js';
+export declare function createTestRuntimeContext({ mastra }: {
+    mastra: Mastra;
+}): RuntimeContext;
+//# 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,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,wBAAgB,wBAAwB,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,cAAc,CAMvF"}

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

@@ -0,0 +1,13 @@
+import { RequestContext } from '@mastra/core/request-context';
+
+function createTestRuntimeContext({ mastra }) {
+  return {
+    mastra,
+    requestContext: new RequestContext(),
+    abortSignal: new AbortController().signal
+  };
+}
+
+export { createTestRuntimeContext };
+//# 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,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"]}

package/dist/server/handlers/tools.cjs

@@ -1,28 +1,28 @@
 'use strict';
 
-var chunkTRGAMKHX_cjs = require('../../chunk-TRGAMKHX.cjs');
+var chunkDHWPHLGF_cjs = require('../../chunk-DHWPHLGF.cjs');
 
 
 
-Object.defineProperty(exports, "executeAgentToolHandler", {
+Object.defineProperty(exports, "EXECUTE_AGENT_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkTRGAMKHX_cjs.executeAgentToolHandler; }
+  get: function () { return chunkDHWPHLGF_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 chunkDHWPHLGF_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 chunkDHWPHLGF_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 chunkDHWPHLGF_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 chunkDHWPHLGF_cjs.LIST_TOOLS_ROUTE; }
 });
 //# sourceMappingURL=tools.cjs.map
 //# sourceMappingURL=tools.cjs.map

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

@@ -1,25 +1,71 @@
-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"> & {
+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;
-    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 {};
+}, {
+    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

@@ -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;;;;;;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,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-QNVYGEJ4.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 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 chunkEP3JQDPD_cjs.createIndex; }
+  get: function () { return chunkX43DWDXB_cjs.createIndex; }
 });
 Object.defineProperty(exports, "deleteIndex", {
   enumerable: true,
-  get: function () { return chunkEP3JQDPD_cjs.deleteIndex; }
+  get: function () { return chunkX43DWDXB_cjs.deleteIndex; }
 });
 Object.defineProperty(exports, "describeIndex", {
   enumerable: true,
-  get: function () { return chunkEP3JQDPD_cjs.describeIndex; }
+  get: function () { return chunkX43DWDXB_cjs.describeIndex; }
 });
 Object.defineProperty(exports, "listIndexes", {
   enumerable: true,
-  get: function () { return chunkEP3JQDPD_cjs.listIndexes; }
+  get: function () { return chunkX43DWDXB_cjs.listIndexes; }
 });
 Object.defineProperty(exports, "queryVectors", {
   enumerable: true,
-  get: function () { return chunkEP3JQDPD_cjs.queryVectors; }
+  get: function () { return chunkX43DWDXB_cjs.queryVectors; }
 });
 Object.defineProperty(exports, "upsertVectors", {
   enumerable: true,
-  get: function () { return chunkEP3JQDPD_cjs.upsertVectors; }
+  get: function () { return chunkX43DWDXB_cjs.upsertVectors; }
 });
 //# sourceMappingURL=vector.cjs.map
 //# sourceMappingURL=vector.cjs.map