@mastra/server 0.0.0-share-agent-metadata-with-cloud-20250718123411 → 0.0.0-span-scorring-test-20251124132129

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAoE1D,wBAAgB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,CAS/D;AAkDD,eAAO,MAAM,uBAAuB;;;;UAsBlC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;UAyBlC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8B7B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;UA6BjC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAsD9B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;UAiCnC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;UA8C9B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+B9B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8C9B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;UA8B9B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;UA6BtC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8ChC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;UAwK9B,CAAC;AAGH,eAAO,MAAM,+BAA+B;;;;UAU1C,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAUrC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;UAWzC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAWtC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;UAWtC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAWtC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAYtC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;UAWtC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAWxC,CAAC"}

package/dist/server/handlers/memory.js

@@ -1 +1,3 @@
-export { createThreadHandler, deleteThreadHandler, getMemoryStatusHandler, getMessagesHandler, getThreadByIdHandler, getThreadsHandler, getWorkingMemoryHandler, saveMessagesHandler, updateThreadHandler, updateWorkingMemoryHandler } from '../../chunk-KOHWJYJT.js';
+export { CREATE_THREAD_NETWORK_ROUTE, CREATE_THREAD_ROUTE, DELETE_MESSAGES_NETWORK_ROUTE, DELETE_MESSAGES_ROUTE, DELETE_THREAD_NETWORK_ROUTE, DELETE_THREAD_ROUTE, GET_MEMORY_CONFIG_ROUTE, GET_MEMORY_STATUS_NETWORK_ROUTE, GET_MEMORY_STATUS_ROUTE, GET_THREAD_BY_ID_NETWORK_ROUTE, GET_THREAD_BY_ID_ROUTE, GET_WORKING_MEMORY_ROUTE, LIST_MESSAGES_NETWORK_ROUTE, LIST_MESSAGES_ROUTE, LIST_THREADS_NETWORK_ROUTE, LIST_THREADS_ROUTE, SAVE_MESSAGES_NETWORK_ROUTE, SAVE_MESSAGES_ROUTE, SEARCH_MEMORY_ROUTE, UPDATE_THREAD_NETWORK_ROUTE, UPDATE_THREAD_ROUTE, UPDATE_WORKING_MEMORY_ROUTE, getTextContent } from '../../chunk-UOFV2ZCI.js';
+//# sourceMappingURL=memory.js.map
+//# sourceMappingURL=memory.js.map

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

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

package/dist/server/handlers/observability.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var chunkAEO6IHLK_cjs = require('../../chunk-AEO6IHLK.cjs');
+
+
+
+Object.defineProperty(exports, "GET_TRACES_PAGINATED_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkAEO6IHLK_cjs.GET_TRACES_PAGINATED_ROUTE; }
+});
+Object.defineProperty(exports, "GET_TRACE_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkAEO6IHLK_cjs.GET_TRACE_ROUTE; }
+});
+Object.defineProperty(exports, "LIST_SCORES_BY_SPAN_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkAEO6IHLK_cjs.LIST_SCORES_BY_SPAN_ROUTE; }
+});
+Object.defineProperty(exports, "SCORE_TRACES_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkAEO6IHLK_cjs.SCORE_TRACES_ROUTE; }
+});
+Object.defineProperty(exports, "getTraceHandler", {
+  enumerable: true,
+  get: function () { return chunkAEO6IHLK_cjs.getTraceHandler; }
+});
+Object.defineProperty(exports, "getTracesPaginatedHandler", {
+  enumerable: true,
+  get: function () { return chunkAEO6IHLK_cjs.getTracesPaginatedHandler; }
+});
+Object.defineProperty(exports, "listScoresBySpan", {
+  enumerable: true,
+  get: function () { return chunkAEO6IHLK_cjs.listScoresBySpan; }
+});
+Object.defineProperty(exports, "scoreTracesHandler", {
+  enumerable: true,
+  get: function () { return chunkAEO6IHLK_cjs.scoreTracesHandler; }
+});
+//# sourceMappingURL=observability.cjs.map
+//# sourceMappingURL=observability.cjs.map

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

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

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

@@ -0,0 +1,156 @@
+import type { TracesPaginatedArg, StoragePagination } from '@mastra/core/storage';
+import z from 'zod';
+import type { Context } from '../types.js';
+interface ObservabilityContext extends Context {
+    traceId?: string;
+    pagination?: TracesPaginatedArg['pagination'];
+    filters?: TracesPaginatedArg['filters'];
+}
+interface ScoreTracesContext extends Context {
+    scorerName?: string;
+    targets?: Array<{
+        traceId: string;
+        spanId?: string;
+    }>;
+}
+/**
+ * Get a complete trace by trace ID
+ * Returns all spans in the trace with their parent-child relationships
+ */
+export declare function getTraceHandler({ mastra, traceId }: ObservabilityContext & {
+    traceId: string;
+}): Promise<import("@mastra/core/storage").TraceRecord>;
+/**
+ * Get paginated traces with filtering and pagination
+ * Returns only root spans (parent spans) for pagination, not child spans
+ */
+export declare function getTracesPaginatedHandler({ mastra, pagination, filters }: ObservabilityContext): Promise<{
+    pagination: import("@mastra/core/storage").PaginationInfo;
+    spans: import("@mastra/core/storage").SpanRecord[];
+}>;
+/**
+ * Score traces using a specified scorer
+ * Fire-and-forget approach - returns immediately while scoring runs in background
+ */
+export declare function scoreTracesHandler({ mastra, scorerName, targets }: ScoreTracesContext): Promise<{
+    status: string;
+    message: string;
+    traceCount: number;
+}>;
+export declare function listScoresBySpan({ mastra, traceId, spanId, page, perPage, }: Context & {
+    traceId: string;
+    spanId: string;
+    page: StoragePagination['page'];
+    perPage: StoragePagination['perPage'];
+}): Promise<{
+    pagination: import("@mastra/core/storage").PaginationInfo;
+    scores: import("@mastra/core/evals").ScoreRowData[];
+}>;
+export declare const GET_TRACES_PAGINATED_ROUTE: import("../server-adapter").ServerRoute<{
+    page: number;
+    perPage: number;
+    name?: string | undefined;
+    dateRange?: string | undefined;
+    spanType?: string | undefined;
+    entityId?: string | undefined;
+    entityType?: string | undefined;
+}, {
+    pagination: {
+        total: number;
+        page: number;
+        perPage: number | false;
+        hasMore: boolean;
+    };
+    spans: {
+        metadata: Record<string, any> | null;
+        traceId: string;
+        parentSpanId: string | null;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        endedAt: Date | null;
+        scope: Record<string, any> | null;
+        spanId: string;
+        spanType: "agent_run" | "generic" | "model_generation" | "model_step" | "model_chunk" | "mcp_tool_call" | "processor_run" | "tool_call" | "workflow_run" | "workflow_step" | "workflow_conditional" | "workflow_conditional_eval" | "workflow_parallel" | "workflow_loop" | "workflow_sleep" | "workflow_wait_event";
+        attributes: Record<string, any> | null;
+        startedAt: Date;
+        isEvent: boolean;
+        error?: any;
+        output?: any;
+        input?: any;
+        links?: any;
+    }[];
+}, "json">;
+export declare const GET_TRACE_ROUTE: import("../server-adapter").ServerRoute<{
+    traceId: string;
+}, {
+    spans: {
+        metadata: Record<string, any> | null;
+        traceId: string;
+        parentSpanId: string | null;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        endedAt: Date | null;
+        scope: Record<string, any> | null;
+        spanId: string;
+        spanType: "agent_run" | "generic" | "model_generation" | "model_step" | "model_chunk" | "mcp_tool_call" | "processor_run" | "tool_call" | "workflow_run" | "workflow_step" | "workflow_conditional" | "workflow_conditional_eval" | "workflow_parallel" | "workflow_loop" | "workflow_sleep" | "workflow_wait_event";
+        attributes: Record<string, any> | null;
+        startedAt: Date;
+        isEvent: boolean;
+        error?: any;
+        output?: any;
+        input?: any;
+        links?: any;
+    }[];
+}, "json">;
+export declare const SCORE_TRACES_ROUTE: import("../server-adapter").ServerRoute<{
+    scorerName: string;
+    targets: {
+        traceId: string;
+        spanId?: string | undefined;
+    }[];
+}, {
+    message: string;
+    status: string;
+    traceCount: number;
+}, "json">;
+export declare const LIST_SCORES_BY_SPAN_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
+    traceId: z.ZodString;
+} & {
+    spanId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    traceId: string;
+    spanId: string;
+}, {
+    traceId: string;
+    spanId: string;
+}>, z.ZodObject<{
+    perPage: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    page: number;
+    perPage: number;
+}, {
+    page?: number | undefined;
+    perPage?: number | undefined;
+}> | z.ZodObject<{
+    perPage: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    page: number;
+    perPage?: number | undefined;
+}, {
+    page?: number | undefined;
+    perPage?: number | undefined;
+}>, undefined>, {
+    pagination: {
+        total: number;
+        page: number;
+        perPage: number | false;
+        hasMore: boolean;
+    };
+    scores: unknown[];
+}, "json">;
+export {};
+//# sourceMappingURL=observability.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"observability.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/observability.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAClF,OAAO,CAAC,MAAM,KAAK,CAAC;AAapB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAGxC,UAAU,oBAAqB,SAAQ,OAAO;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,kBAAkB,CAAC,YAAY,CAAC,CAAC;IAC9C,OAAO,CAAC,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;CACzC;AAED,UAAU,kBAAmB,SAAQ,OAAO;IAE1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,KAAK,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;CACJ;AAED;;;GAGG;AACH,wBAAsB,eAAe,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,oBAAoB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,uDAqBpG;AAED;;;GAGG;AACH,wBAAsB,yBAAyB,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,oBAAoB;;;GAkCpG;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,kBAAkB;;;;GAuC3F;AAED,wBAAsB,gBAAgB,CAAC,EACrC,MAAM,EACN,OAAO,EACP,MAAM,EACN,IAAI,EACJ,OAAO,GACR,EAAE,OAAO,GAAG;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAChC,OAAO,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC;CACvC;;;GAeA;AAMD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAqErC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;UA+B1B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;UAkD7B,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+BpC,CAAC"}

package/dist/server/handlers/observability.js

@@ -0,0 +1,3 @@
+export { GET_TRACES_PAGINATED_ROUTE, GET_TRACE_ROUTE, LIST_SCORES_BY_SPAN_ROUTE, SCORE_TRACES_ROUTE, getTraceHandler, getTracesPaginatedHandler, listScoresBySpan, scoreTracesHandler } from '../../chunk-ECIVTQ4E.js';
+//# sourceMappingURL=observability.js.map
+//# sourceMappingURL=observability.js.map

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

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

package/dist/server/handlers/scores.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var chunkZODCSH2W_cjs = require('../../chunk-ZODCSH2W.cjs');
+
+
+
+Object.defineProperty(exports, "GET_SCORER_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkZODCSH2W_cjs.GET_SCORER_ROUTE; }
+});
+Object.defineProperty(exports, "LIST_SCORERS_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkZODCSH2W_cjs.LIST_SCORERS_ROUTE; }
+});
+Object.defineProperty(exports, "LIST_SCORES_BY_ENTITY_ID_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkZODCSH2W_cjs.LIST_SCORES_BY_ENTITY_ID_ROUTE; }
+});
+Object.defineProperty(exports, "LIST_SCORES_BY_RUN_ID_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkZODCSH2W_cjs.LIST_SCORES_BY_RUN_ID_ROUTE; }
+});
+Object.defineProperty(exports, "LIST_SCORES_BY_SCORER_ID_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkZODCSH2W_cjs.LIST_SCORES_BY_SCORER_ID_ROUTE; }
+});
+Object.defineProperty(exports, "SAVE_SCORE_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkZODCSH2W_cjs.SAVE_SCORE_ROUTE; }
+});
+//# sourceMappingURL=scores.cjs.map
+//# sourceMappingURL=scores.cjs.map

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

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

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

@@ -0,0 +1,121 @@
+export declare const LIST_SCORERS_ROUTE: import("../server-adapter").ServerRoute<{}, Record<string, {
+    scorer: {
+        config: {
+            id: string;
+            description: string;
+            type?: unknown;
+            name?: string | undefined;
+            judge?: unknown;
+        };
+    };
+    agentIds: string[];
+    agentNames: string[];
+    workflowIds: string[];
+    isRegistered: boolean;
+    sampling?: {} | undefined;
+}>, "json">;
+export declare const GET_SCORER_ROUTE: import("../server-adapter").ServerRoute<{
+    scorerId: string;
+}, {
+    scorer: {
+        config: {
+            id: string;
+            description: string;
+            type?: unknown;
+            name?: string | undefined;
+            judge?: unknown;
+        };
+    };
+    agentIds: string[];
+    agentNames: string[];
+    workflowIds: string[];
+    isRegistered: boolean;
+    sampling?: {} | undefined;
+} | null, "json">;
+export declare const LIST_SCORES_BY_RUN_ID_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
+    runId: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    runId: string;
+}, {
+    runId: string;
+}>, import("zod").ZodObject<{
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    perPage: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+}, "strip", import("zod").ZodTypeAny, {
+    page: number;
+    perPage: number;
+}, {
+    page?: number | undefined;
+    perPage?: number | undefined;
+}>, undefined>, {
+    pagination: {
+        total: number;
+        page: number;
+        perPage: number | false;
+        hasMore: boolean;
+    };
+    scores: unknown[];
+}, "json">;
+export declare const LIST_SCORES_BY_SCORER_ID_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
+    scorerId: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    scorerId: string;
+}, {
+    scorerId: string;
+}>, import("zod").ZodObject<{
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    perPage: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    entityId: import("zod").ZodOptional<import("zod").ZodString>;
+    entityType: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    page: number;
+    perPage: number;
+    entityId?: string | undefined;
+    entityType?: string | undefined;
+}, {
+    page?: number | undefined;
+    perPage?: number | undefined;
+    entityId?: string | undefined;
+    entityType?: string | undefined;
+}>, undefined>, {
+    pagination: {
+        total: number;
+        page: number;
+        perPage: number | false;
+        hasMore: boolean;
+    };
+    scores: unknown[];
+}, "json">;
+export declare const LIST_SCORES_BY_ENTITY_ID_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
+    entityType: import("zod").ZodString;
+    entityId: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    entityId: string;
+    entityType: string;
+}, {
+    entityId: string;
+    entityType: string;
+}>, import("zod").ZodObject<{
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    perPage: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+}, "strip", import("zod").ZodTypeAny, {
+    page: number;
+    perPage: number;
+}, {
+    page?: number | undefined;
+    perPage?: number | undefined;
+}>, undefined>, {
+    pagination: {
+        total: number;
+        page: number;
+        perPage: number | false;
+        hasMore: boolean;
+    };
+    scores: unknown[];
+}, "json">;
+export declare const SAVE_SCORE_ROUTE: import("../server-adapter").ServerRoute<{
+    score?: unknown;
+}, {
+    score?: unknown;
+}, "json">;
+//# sourceMappingURL=scores.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scores.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/scores.ts"],"names":[],"mappings":"AAyHA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;WAe7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;iBAuB3B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;UA6BtC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2BzC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;UA0CzC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;UAqB3B,CAAC"}

package/dist/server/handlers/scores.js

@@ -0,0 +1,3 @@
+export { GET_SCORER_ROUTE, LIST_SCORERS_ROUTE, LIST_SCORES_BY_ENTITY_ID_ROUTE, LIST_SCORES_BY_RUN_ID_ROUTE, LIST_SCORES_BY_SCORER_ID_ROUTE, SAVE_SCORE_ROUTE } from '../../chunk-ASZUOBKV.js';
+//# sourceMappingURL=scores.js.map
+//# sourceMappingURL=scores.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"scores.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,22 +1,28 @@
 'use strict';
 
-var chunkFRVBFMO2_cjs = require('../../chunk-FRVBFMO2.cjs');
+var chunkKB5NSROG_cjs = require('../../chunk-KB5NSROG.cjs');
 
 
 
-Object.defineProperty(exports, "executeAgentToolHandler", {
+Object.defineProperty(exports, "EXECUTE_AGENT_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkFRVBFMO2_cjs.executeAgentToolHandler; }
+  get: function () { return chunkKB5NSROG_cjs.EXECUTE_AGENT_TOOL_ROUTE; }
 });
-Object.defineProperty(exports, "executeToolHandler", {
+Object.defineProperty(exports, "EXECUTE_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkFRVBFMO2_cjs.executeToolHandler; }
+  get: function () { return chunkKB5NSROG_cjs.EXECUTE_TOOL_ROUTE; }
 });
-Object.defineProperty(exports, "getToolByIdHandler", {
+Object.defineProperty(exports, "GET_AGENT_TOOL_ROUTE", {
   enumerable: true,
-  get: function () { return chunkFRVBFMO2_cjs.getToolByIdHandler; }
+  get: function () { return chunkKB5NSROG_cjs.GET_AGENT_TOOL_ROUTE; }
 });
-Object.defineProperty(exports, "getToolsHandler", {
+Object.defineProperty(exports, "GET_TOOL_BY_ID_ROUTE", {
   enumerable: true,
-  get: function () { return chunkFRVBFMO2_cjs.getToolsHandler; }
+  get: function () { return chunkKB5NSROG_cjs.GET_TOOL_BY_ID_ROUTE; }
 });
+Object.defineProperty(exports, "LIST_TOOLS_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkKB5NSROG_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-LRCAAFUA.js';
+export { EXECUTE_AGENT_TOOL_ROUTE, EXECUTE_TOOL_ROUTE, GET_AGENT_TOOL_ROUTE, GET_TOOL_BY_ID_ROUTE, LIST_TOOLS_ROUTE } from '../../chunk-ICANWSEW.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 chunkCCGRCYWJ_cjs = require('../../chunk-CCGRCYWJ.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 chunkCCGRCYWJ_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-RSEO4XPX.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"}