@mastra/server 1.0.4-alpha.2 → 1.1.0-alpha.0

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

@@ -0,0 +1,317 @@
+/**
+ * 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").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;
+    }>>;
+    ownerId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, "strip", import("zod").ZodTypeAny, {
+    page: number;
+    perPage: number;
+    metadata?: Record<string, unknown> | undefined;
+    orderBy?: {
+        field?: "createdAt" | "updatedAt" | undefined;
+        direction?: "ASC" | "DESC" | undefined;
+    } | undefined;
+    ownerId?: string | undefined;
+}, {
+    page?: number | undefined;
+    perPage?: number | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    orderBy?: {
+        field?: "createdAt" | "updatedAt" | undefined;
+        direction?: "ASC" | "DESC" | undefined;
+    } | undefined;
+    ownerId?: string | 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;
+    }>>;
+    ownerId: import("zod").ZodOptional<import("zod").ZodString>;
+    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, "strip", import("zod").ZodTypeAny, {
+    page: number;
+    perPage?: number | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    orderBy?: {
+        field?: "createdAt" | "updatedAt" | undefined;
+        direction?: "ASC" | "DESC" | undefined;
+    } | undefined;
+    ownerId?: string | undefined;
+}, {
+    page?: number | undefined;
+    perPage?: number | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    orderBy?: {
+        field?: "createdAt" | "updatedAt" | undefined;
+        direction?: "ASC" | "DESC" | undefined;
+    } | undefined;
+    ownerId?: string | 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;
+        ownerId?: string | undefined;
+        integrationTools?: 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;
+    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;
+    ownerId?: string | undefined;
+    integrationTools?: string[] | undefined;
+}, "json">;
+/**
+ * POST /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;
+    ownerId?: string | undefined;
+    integrationTools?: string[] | 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;
+    ownerId?: string | undefined;
+    integrationTools?: 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;
+}, "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">>>;
+    integrationTools: 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>>>;
+    ownerId: import("zod").ZodOptional<import("zod").ZodOptional<import("zod").ZodString>>;
+}, "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;
+    ownerId?: string | undefined;
+    integrationTools?: string[] | 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;
+    ownerId?: string | undefined;
+    integrationTools?: string[] | 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;
+    ownerId?: string | undefined;
+    integrationTools?: string[] | undefined;
+}, "json">;
+/**
+ * DELETE /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":"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-RW66MHXI.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 chunkT5KH32UA_cjs = require('../../chunk-T5KH32UA.cjs');
+
+
+
+Object.defineProperty(exports, "GET_SYSTEM_PACKAGES_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkT5KH32UA_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-EV5H2JQU.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,22 +1,28 @@
 'use strict';
 
-var chunkPDC4ZBQW_cjs = require('../../chunk-PDC4ZBQW.cjs');
+var chunkVNHOYZ56_cjs = require('../../chunk-VNHOYZ56.cjs');
 
 
 
-Object.defineProperty(exports, "executeAgentToolHandler", {
+Object.defineProperty(exports, "EXECUTE_AGENT_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkPDC4ZBQW_cjs.executeAgentToolHandler; }
+  get: function () { return chunkVNHOYZ56_cjs.EXECUTE_AGENT_TOOL_ROUTE; }
 });
-Object.defineProperty(exports, "executeToolHandler", {
+Object.defineProperty(exports, "EXECUTE_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkPDC4ZBQW_cjs.executeToolHandler; }
+  get: function () { return chunkVNHOYZ56_cjs.EXECUTE_TOOL_ROUTE; }
 });
-Object.defineProperty(exports, "getToolByIdHandler", {
+Object.defineProperty(exports, "GET_AGENT_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkPDC4ZBQW_cjs.getToolByIdHandler; }
+  get: function () { return chunkVNHOYZ56_cjs.GET_AGENT_TOOL_ROUTE; }
 });
-Object.defineProperty(exports, "getToolsHandler", {
+Object.defineProperty(exports, "GET_TOOL_BY_ID_ROUTE", {
   enumerable: true,
-  get: function () { return chunkPDC4ZBQW_cjs.getToolsHandler; }
+  get: function () { return chunkVNHOYZ56_cjs.GET_TOOL_BY_ID_ROUTE; }
 });
+Object.defineProperty(exports, "LIST_TOOLS_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkVNHOYZ56_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;
+    requireApproval?: boolean | undefined;
+    description?: string | undefined;
+    inputSchema?: string | undefined;
+    outputSchema?: string | undefined;
+}>, "json">;
+export declare const GET_TOOL_BY_ID_ROUTE: import("../server-adapter").ServerRoute<{
+    toolId: string;
+}, {
+    id: string;
+    requireApproval?: boolean | undefined;
+    description?: string | undefined;
+    inputSchema?: string | undefined;
+    outputSchema?: string | 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;
+    requireApproval?: boolean | undefined;
+    description?: string | undefined;
+    inputSchema?: string | undefined;
+    outputSchema?: string | 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":"AAwBA,eAAO,MAAM,gBAAgB;;;;;;WAoC3B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;UAuC/B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;iBA+D7B,CAAC;AAMH,eAAO,MAAM,oBAAoB;;;;;;;;;UAuC/B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;iBA0CnC,CAAC"}

package/dist/server/handlers/tools.js

@@ -1 +1,3 @@
-export { executeAgentToolHandler, executeToolHandler, getToolByIdHandler, getToolsHandler } from '../../chunk-UV4WTEH4.js';
+export { EXECUTE_AGENT_TOOL_ROUTE, EXECUTE_TOOL_ROUTE, GET_AGENT_TOOL_ROUTE, GET_TOOL_BY_ID_ROUTE, LIST_TOOLS_ROUTE } from '../../chunk-FQX5SQO7.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,40 @@
 'use strict';
 
-var chunkQN4KF3BH_cjs = require('../../chunk-QN4KF3BH.cjs');
+var chunkZKMVCV4G_cjs = require('../../chunk-ZKMVCV4G.cjs');
 
 
 
+Object.defineProperty(exports, "getEffectiveResourceId", {
+  enumerable: true,
+  get: function () { return chunkZKMVCV4G_cjs.getEffectiveResourceId; }
+});
+Object.defineProperty(exports, "getEffectiveThreadId", {
+  enumerable: true,
+  get: function () { return chunkZKMVCV4G_cjs.getEffectiveThreadId; }
+});
+Object.defineProperty(exports, "parseFilters", {
+  enumerable: true,
+  get: function () { return chunkZKMVCV4G_cjs.parseFilters; }
+});
+Object.defineProperty(exports, "parsePerPage", {
+  enumerable: true,
+  get: function () { return chunkZKMVCV4G_cjs.parsePerPage; }
+});
+Object.defineProperty(exports, "sanitizeBody", {
+  enumerable: true,
+  get: function () { return chunkZKMVCV4G_cjs.sanitizeBody; }
+});
 Object.defineProperty(exports, "validateBody", {
   enumerable: true,
-  get: function () { return chunkQN4KF3BH_cjs.validateBody; }
+  get: function () { return chunkZKMVCV4G_cjs.validateBody; }
+});
+Object.defineProperty(exports, "validateRunOwnership", {
+  enumerable: true,
+  get: function () { return chunkZKMVCV4G_cjs.validateRunOwnership; }
+});
+Object.defineProperty(exports, "validateThreadOwnership", {
+  enumerable: true,
+  get: function () { return chunkZKMVCV4G_cjs.validateThreadOwnership; }
 });
+//# 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,39 @@
-export { validateBody } from '../../_tsup-dts-rollup.js';
+import type { RequestContext } from '@mastra/core/di';
+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;
+/**
+ * Gets the effective resourceId, preferring the reserved key from requestContext
+ * over client-provided values for security.
+ */
+export declare function getEffectiveResourceId(requestContext: RequestContext | undefined, clientResourceId: string | undefined): string | undefined;
+/**
+ * Gets the effective threadId, preferring the reserved key from requestContext
+ * over client-provided values for security.
+ */
+export declare function getEffectiveThreadId(requestContext: RequestContext | undefined, clientThreadId: string | undefined): string | undefined;
+/**
+ * Validates that a thread belongs to the specified resourceId.
+ * Throws 403 if the thread exists but belongs to a different resource.
+ * Threads with no resourceId are accessible to all (shared threads).
+ */
+export declare function validateThreadOwnership(thread: {
+    resourceId?: string | null;
+} | null | undefined, effectiveResourceId: string | undefined): Promise<void>;
+/**
+ * Validates that a workflow run belongs to the specified resourceId.
+ * Throws 403 if the run exists but belongs to a different resource.
+ */
+export declare function validateRunOwnership(run: {
+    resourceId?: string | null;
+} | null | undefined, effectiveResourceId: string | undefined): Promise<void>;
+//# 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":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAKtD,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;AAMD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,gBAAgB,EAAE,MAAM,GAAG,SAAS,GACnC,MAAM,GAAG,SAAS,CAGpB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,cAAc,EAAE,MAAM,GAAG,SAAS,GACjC,MAAM,GAAG,SAAS,CAGpB;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EACzD,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,OAAO,CAAC,IAAI,CAAC,CAIf;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,GAAG,SAAS,EACtD,mBAAmB,EAAE,MAAM,GAAG,SAAS,GACtC,OAAO,CAAC,IAAI,CAAC,CAIf"}

package/dist/server/handlers/utils.js

@@ -1 +1,3 @@
-export { validateBody } from '../../chunk-L7XE5QTW.js';
+export { getEffectiveResourceId, getEffectiveThreadId, parseFilters, parsePerPage, sanitizeBody, validateBody, validateRunOwnership, validateThreadOwnership } from '../../chunk-USR6JK77.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"}