@mastra/server 0.0.0-sidebar-window-undefined-fix-20251029233656 → 0.0.0-standard-schema-20260123120255

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

@@ -1,49 +1,139 @@
-import type { AITracesPaginatedArg, StoragePagination } from '@mastra/core';
-import type { Context } from '../types.js';
-interface ObservabilityContext extends Context {
-    traceId?: string;
-    body?: AITracesPaginatedArg;
-}
-interface ScoreTracesContext extends Context {
-    body?: {
-        scorerName: string;
-        targets: Array<{
-            traceId: string;
-            spanId?: string;
-        }>;
+import { z } from 'zod';
+export declare const LIST_TRACES_ROUTE: import("../server-adapter").ServerRoute<Record<string, unknown>, {
+    pagination: {
+        total: number;
+        page: number;
+        perPage: number | false;
+        hasMore: boolean;
     };
-}
-/**
- * Get a complete AI trace by trace ID
- * Returns all spans in the trace with their parent-child relationships
- */
-export declare function getAITraceHandler({ mastra, traceId }: ObservabilityContext & {
+    spans: {
+        createdAt: Date;
+        updatedAt: Date | null;
+        name: string;
+        spanType: import("@mastra/core/observability").SpanType;
+        isEvent: boolean;
+        startedAt: Date;
+        traceId: string;
+        spanId: string;
+        attributes?: Record<string, unknown> | null | undefined;
+        links?: unknown[] | null | undefined;
+        input?: unknown;
+        output?: unknown;
+        error?: unknown;
+        endedAt?: Date | null | undefined;
+        entityType?: import("@mastra/core/observability").EntityType | null | undefined;
+        entityId?: string | null | undefined;
+        entityName?: string | null | undefined;
+        userId?: string | null | undefined;
+        organizationId?: string | null | undefined;
+        resourceId?: string | null | undefined;
+        runId?: string | null | undefined;
+        sessionId?: string | null | undefined;
+        threadId?: string | null | undefined;
+        requestId?: string | null | undefined;
+        environment?: string | null | undefined;
+        source?: string | null | undefined;
+        serviceName?: string | null | undefined;
+        scope?: Record<string, unknown> | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+        tags?: string[] | null | undefined;
+        parentSpanId?: string | null | undefined;
+    }[];
+}, "json">;
+export declare const GET_TRACE_ROUTE: import("../server-adapter").ServerRoute<{
     traceId: string;
-}): Promise<import("@mastra/core").AITraceRecord>;
-/**
- * Get paginated AI traces with filtering and pagination
- * Returns only root spans (parent spans) for pagination, not child spans
- */
-export declare function getAITracesPaginatedHandler({ mastra, body }: ObservabilityContext): Promise<{
-    pagination: import("@mastra/core").PaginationInfo;
-    spans: import("@mastra/core").AISpanRecord[];
-}>;
-/**
- * Score traces using a specified scorer
- * Fire-and-forget approach - returns immediately while scoring runs in background
- */
-export declare function scoreTracesHandler({ mastra, body }: ScoreTracesContext): Promise<{
+}, {
+    traceId: string;
+    spans: {
+        createdAt: Date;
+        updatedAt: Date | null;
+        name: string;
+        spanType: import("@mastra/core/observability").SpanType;
+        isEvent: boolean;
+        startedAt: Date;
+        traceId: string;
+        spanId: string;
+        attributes?: Record<string, unknown> | null | undefined;
+        links?: unknown[] | null | undefined;
+        input?: unknown;
+        output?: unknown;
+        error?: unknown;
+        endedAt?: Date | null | undefined;
+        entityType?: import("@mastra/core/observability").EntityType | null | undefined;
+        entityId?: string | null | undefined;
+        entityName?: string | null | undefined;
+        userId?: string | null | undefined;
+        organizationId?: string | null | undefined;
+        resourceId?: string | null | undefined;
+        runId?: string | null | undefined;
+        sessionId?: string | null | undefined;
+        threadId?: string | null | undefined;
+        requestId?: string | null | undefined;
+        environment?: string | null | undefined;
+        source?: string | null | undefined;
+        serviceName?: string | null | undefined;
+        scope?: Record<string, unknown> | null | undefined;
+        metadata?: Record<string, unknown> | null | undefined;
+        tags?: string[] | null | undefined;
+        parentSpanId?: string | null | undefined;
+    }[];
+}, "json">;
+export declare const SCORE_TRACES_ROUTE: import("../server-adapter").ServerRoute<{
+    scorerName: string;
+    targets: {
+        traceId: string;
+        spanId?: string | undefined;
+    }[];
+}, {
     status: string;
     message: string;
     traceCount: number;
-}>;
-export declare function getScoresBySpan({ mastra, traceId, spanId, pagination, }: Context & {
-    traceId: string;
-    spanId: string;
-    pagination: StoragePagination;
-}): Promise<{
-    pagination: import("@mastra/core").PaginationInfo;
-    scores: import("@mastra/core/scores").ScoreRowData[];
-}>;
-export {};
+}, "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;
+}, z.core.$strip>, z.ZodObject<{
+    page: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+    perPage: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>, undefined>, {
+    pagination: {
+        total: number;
+        page: number;
+        perPage: number | false;
+        hasMore: boolean;
+    };
+    scores: {
+        createdAt: Date;
+        updatedAt: Date | null;
+        id: string;
+        scorerId: string;
+        entityId: string;
+        runId: string;
+        output: unknown;
+        score: number;
+        scorer: Record<string, unknown>;
+        source: "LIVE" | "TEST";
+        entity: Record<string, unknown>;
+        input?: unknown;
+        additionalContext?: Record<string, unknown> | undefined;
+        requestContext?: Record<string, unknown> | undefined;
+        extractStepResult?: Record<string, unknown> | undefined;
+        extractPrompt?: string | undefined;
+        analyzeStepResult?: Record<string, unknown> | undefined;
+        analyzePrompt?: string | undefined;
+        reason?: string | undefined;
+        reasonPrompt?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        entityType?: string | undefined;
+        structuredOutput?: boolean | undefined;
+        traceId?: string | undefined;
+        spanId?: string | undefined;
+        resourceId?: string | undefined;
+        threadId?: string | undefined;
+        preprocessStepResult?: Record<string, unknown> | undefined;
+        preprocessPrompt?: string | undefined;
+        generateScorePrompt?: string | undefined;
+        generateReasonPrompt?: string | undefined;
+    }[];
+}, "json">;
 //# sourceMappingURL=observability.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"observability.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/observability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAG5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAGxC,UAAU,oBAAqB,SAAQ,OAAO;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B;AAED,UAAU,kBAAmB,SAAQ,OAAO;IAC1C,IAAI,CAAC,EAAE;QACL,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,KAAK,CAAC;YACb,OAAO,EAAE,MAAM,CAAC;YAChB,MAAM,CAAC,EAAE,MAAM,CAAC;SACjB,CAAC,CAAC;KACJ,CAAC;CACH;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,oBAAoB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,iDAqBtG;AAED;;;GAGG;AACH,wBAAsB,2BAA2B,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,oBAAoB;;;GAwCvF;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,kBAAkB;;;;GA4C5E;AAED,wBAAsB,eAAe,CAAC,EACpC,MAAM,EACN,OAAO,EACP,MAAM,EACN,UAAU,GACX,EAAE,OAAO,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,iBAAiB,CAAA;CAAE;;;GAe9E"}
+{"version":3,"file":"observability.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/observability.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4FxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+B5B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAwB1B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;UAwC7B,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA0BpC,CAAC"}

package/dist/server/handlers/observability.js

@@ -1,3 +1,3 @@
-export { getAITraceHandler, getAITracesPaginatedHandler, getScoresBySpan, scoreTracesHandler } from '../../chunk-BATEJLED.js';
+export { GET_TRACE_ROUTE, LIST_SCORES_BY_SPAN_ROUTE, LIST_TRACES_ROUTE, SCORE_TRACES_ROUTE } from '../../chunk-2UHOWYFV.js';
 //# sourceMappingURL=observability.js.map
 //# sourceMappingURL=observability.js.map

package/dist/server/handlers/processors.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var chunkL7LB66KK_cjs = require('../../chunk-L7LB66KK.cjs');
+
+
+
+Object.defineProperty(exports, "EXECUTE_PROCESSOR_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkL7LB66KK_cjs.EXECUTE_PROCESSOR_ROUTE; }
+});
+Object.defineProperty(exports, "GET_PROCESSOR_BY_ID_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkL7LB66KK_cjs.GET_PROCESSOR_BY_ID_ROUTE; }
+});
+Object.defineProperty(exports, "LIST_PROCESSORS_ROUTE", {
+  enumerable: true,
+  get: function () { return chunkL7LB66KK_cjs.LIST_PROCESSORS_ROUTE; }
+});
+//# sourceMappingURL=processors.cjs.map
+//# sourceMappingURL=processors.cjs.map

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

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

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

@@ -0,0 +1,90 @@
+export declare const LIST_PROCESSORS_ROUTE: import("../server-adapter").ServerRoute<{}, Record<string, {
+    id: string;
+    phases: ("input" | "inputStep" | "outputStream" | "outputResult" | "outputStep")[];
+    agentIds: string[];
+    configurations: {
+        agentId: string;
+        type: "input" | "output";
+    }[];
+    isWorkflow: boolean;
+    name?: string | undefined;
+    description?: string | undefined;
+}>, "json">;
+export declare const GET_PROCESSOR_BY_ID_ROUTE: import("../server-adapter").ServerRoute<{
+    processorId: string;
+}, {
+    id: string;
+    phases: ("input" | "inputStep" | "outputStream" | "outputResult" | "outputStep")[];
+    configurations: {
+        agentId: string;
+        agentName: string;
+        type: "input" | "output";
+    }[];
+    isWorkflow: boolean;
+    name?: string | undefined;
+    description?: string | undefined;
+}, "json">;
+export declare const EXECUTE_PROCESSOR_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<import("zod").ZodObject<{
+    processorId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    phase: import("zod").ZodEnum<{
+        input: "input";
+        inputStep: "inputStep";
+        outputStream: "outputStream";
+        outputResult: "outputResult";
+        outputStep: "outputStep";
+    }>;
+    messages: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        role: import("zod").ZodEnum<{
+            tool: "tool";
+            system: "system";
+            user: "user";
+            assistant: "assistant";
+        }>;
+        createdAt: import("zod").ZodOptional<import("zod").ZodCoercedDate<unknown>>;
+        content: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            format: import("zod").ZodOptional<import("zod").ZodLiteral<2>>;
+            parts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodAny>>;
+            content: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$loose>, import("zod").ZodString]>;
+    }, import("zod/v4/core").$loose>>;
+    agentId: import("zod").ZodOptional<import("zod").ZodString>;
+    requestContext: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+}, import("zod/v4/core").$strip>>, {
+    success: boolean;
+    phase: string;
+    messages?: {
+        [x: string]: unknown;
+        id: string;
+        role: "tool" | "system" | "user" | "assistant";
+        content: string | {
+            [x: string]: unknown;
+            format?: 2 | undefined;
+            parts?: any[] | undefined;
+            content?: string | undefined;
+        };
+        createdAt?: Date | undefined;
+    }[] | undefined;
+    messageList?: {
+        messages: {
+            [x: string]: unknown;
+            id: string;
+            role: "tool" | "system" | "user" | "assistant";
+            content: string | {
+                [x: string]: unknown;
+                format?: 2 | undefined;
+                parts?: any[] | undefined;
+                content?: string | undefined;
+            };
+            createdAt?: Date | undefined;
+        }[];
+    } | undefined;
+    tripwire?: {
+        triggered: boolean;
+        reason?: string | undefined;
+        metadata?: any;
+    } | undefined;
+    error?: string | undefined;
+}, "json">;
+//# sourceMappingURL=processors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"processors.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/processors.ts"],"names":[],"mappings":"AA0EA,eAAO,MAAM,qBAAqB;;;;;;;;;;;WA0DhC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;UAqDpC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAwSlC,CAAC"}

package/dist/server/handlers/processors.js

@@ -0,0 +1,3 @@
+export { EXECUTE_PROCESSOR_ROUTE, GET_PROCESSOR_BY_ID_ROUTE, LIST_PROCESSORS_ROUTE } from '../../chunk-BLCHLNBT.js';
+//# sourceMappingURL=processors.js.map
+//# sourceMappingURL=processors.js.map

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

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

package/dist/server/handlers/scores.cjs

@@ -1,32 +1,32 @@
 'use strict';
 
-var chunkSPRRK3P7_cjs = require('../../chunk-SPRRK3P7.cjs');
+var chunkL2U75ERO_cjs = require('../../chunk-L2U75ERO.cjs');
 
 
 
-Object.defineProperty(exports, "getScorerHandler", {
+Object.defineProperty(exports, "GET_SCORER_ROUTE", {
   enumerable: true,
-  get: function () { return chunkSPRRK3P7_cjs.getScorerHandler; }
+  get: function () { return chunkL2U75ERO_cjs.GET_SCORER_ROUTE; }
 });
-Object.defineProperty(exports, "getScorersHandler", {
+Object.defineProperty(exports, "LIST_SCORERS_ROUTE", {
   enumerable: true,
-  get: function () { return chunkSPRRK3P7_cjs.getScorersHandler; }
+  get: function () { return chunkL2U75ERO_cjs.LIST_SCORERS_ROUTE; }
 });
-Object.defineProperty(exports, "getScoresByEntityIdHandler", {
+Object.defineProperty(exports, "LIST_SCORES_BY_ENTITY_ID_ROUTE", {
   enumerable: true,
-  get: function () { return chunkSPRRK3P7_cjs.getScoresByEntityIdHandler; }
+  get: function () { return chunkL2U75ERO_cjs.LIST_SCORES_BY_ENTITY_ID_ROUTE; }
 });
-Object.defineProperty(exports, "getScoresByRunIdHandler", {
+Object.defineProperty(exports, "LIST_SCORES_BY_RUN_ID_ROUTE", {
   enumerable: true,
-  get: function () { return chunkSPRRK3P7_cjs.getScoresByRunIdHandler; }
+  get: function () { return chunkL2U75ERO_cjs.LIST_SCORES_BY_RUN_ID_ROUTE; }
 });
-Object.defineProperty(exports, "getScoresByScorerIdHandler", {
+Object.defineProperty(exports, "LIST_SCORES_BY_SCORER_ID_ROUTE", {
   enumerable: true,
-  get: function () { return chunkSPRRK3P7_cjs.getScoresByScorerIdHandler; }
+  get: function () { return chunkL2U75ERO_cjs.LIST_SCORES_BY_SCORER_ID_ROUTE; }
 });
-Object.defineProperty(exports, "saveScoreHandler", {
+Object.defineProperty(exports, "SAVE_SCORE_ROUTE", {
   enumerable: true,
-  get: function () { return chunkSPRRK3P7_cjs.saveScoreHandler; }
+  get: function () { return chunkL2U75ERO_cjs.SAVE_SCORE_ROUTE; }
 });
 //# sourceMappingURL=scores.cjs.map
 //# sourceMappingURL=scores.cjs.map

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

@@ -1,152 +1,85 @@
-import type { RuntimeContext } from '@mastra/core/runtime-context';
-import type { MastraScorerEntry, ScoreRowData } from '@mastra/core/scores';
-import type { StoragePagination } from '@mastra/core/storage';
-import type { Context } from '../types.js';
-export declare function getScorersHandler({ mastra, runtimeContext }: Context & {
-    runtimeContext: RuntimeContext;
-}): Promise<{
-    [k: string]: MastraScorerEntry & {
-        agentIds: string[];
-        agentNames: string[];
-        workflowIds: string[];
-        isRegistered: boolean;
+export declare const LIST_SCORERS_ROUTE: import("../server-adapter").ServerRoute<{}, Record<string, {
+    scorer: {
+        config: {
+            id: string;
+            description: string;
+            name?: string | undefined;
+            type?: unknown;
+            judge?: unknown;
+        };
     };
-}>;
-export declare function getScorerHandler({ mastra, scorerId, runtimeContext, }: Context & {
-    scorerId: string;
-    runtimeContext: RuntimeContext;
-}): Promise<(MastraScorerEntry & {
     agentIds: string[];
     agentNames: string[];
     workflowIds: string[];
     isRegistered: boolean;
-}) | null>;
-export declare function getScoresByRunIdHandler({ mastra, runId, pagination, }: Context & {
-    runId: string;
-    pagination: StoragePagination;
-}): Promise<{
-    pagination: import("@mastra/core").PaginationInfo;
-    scores: {
-        spanId?: string;
-        traceId?: string;
-        runId: string;
-        input: any;
-        output: any;
-        additionalContext?: Record<string, any>;
-        runtimeContext?: Record<string, any>;
-        tracingContext?: import("@mastra/core/ai-tracing").TracingContext;
-        extractStepResult?: any;
-        extractPrompt?: string;
-        score: number;
-        analyzeStepResult?: any;
-        analyzePrompt?: string;
-        reason?: string;
-        reasonPrompt?: string;
-        scorer: Record<string, any>;
-        metadata?: Record<string, any>;
-        source: import("@mastra/core/scores").ScoringSource;
-        entity: Record<string, any>;
-        entityType: import("@mastra/core/scores").ScoringEntityType;
-        structuredOutput?: boolean;
-        resourceId?: string;
-        threadId?: string;
-        id: string;
-        entityId: string;
-        scorerId: string;
-        createdAt: Date;
-        updatedAt: Date;
-        preprocessStepResult?: Record<string, any>;
-        preprocessPrompt?: string;
-        generateScorePrompt?: string;
-        generateReasonPrompt?: string;
-    }[];
-}>;
-export declare function getScoresByScorerIdHandler({ mastra, scorerId, pagination, entityId, entityType, }: Context & {
+    sampling?: Record<string, never> | undefined;
+}>, "json">;
+export declare const GET_SCORER_ROUTE: import("../server-adapter").ServerRoute<{
     scorerId: string;
-    pagination: StoragePagination;
-    entityId?: string;
-    entityType?: string;
-}): Promise<{
-    pagination: import("@mastra/core").PaginationInfo;
-    scores: {
-        spanId?: string;
-        traceId?: string;
-        runId: string;
-        input: any;
-        output: any;
-        additionalContext?: Record<string, any>;
-        runtimeContext?: Record<string, any>;
-        tracingContext?: import("@mastra/core/ai-tracing").TracingContext;
-        extractStepResult?: any;
-        extractPrompt?: string;
-        score: number;
-        analyzeStepResult?: any;
-        analyzePrompt?: string;
-        reason?: string;
-        reasonPrompt?: string;
-        scorer: Record<string, any>;
-        metadata?: Record<string, any>;
-        source: import("@mastra/core/scores").ScoringSource;
-        entity: Record<string, any>;
-        entityType: import("@mastra/core/scores").ScoringEntityType;
-        structuredOutput?: boolean;
-        resourceId?: string;
-        threadId?: string;
-        id: string;
-        entityId: string;
-        scorerId: string;
-        createdAt: Date;
-        updatedAt: Date;
-        preprocessStepResult?: Record<string, any>;
-        preprocessPrompt?: string;
-        generateScorePrompt?: string;
-        generateReasonPrompt?: string;
-    }[];
-}>;
-export declare function getScoresByEntityIdHandler({ mastra, entityId, entityType, pagination, }: Context & {
-    entityId: string;
-    entityType: string;
-    pagination: StoragePagination;
-}): Promise<{
-    pagination: import("@mastra/core").PaginationInfo;
-    scores: {
-        spanId?: string;
-        traceId?: string;
-        runId: string;
-        input: any;
-        output: any;
-        additionalContext?: Record<string, any>;
-        runtimeContext?: Record<string, any>;
-        tracingContext?: import("@mastra/core/ai-tracing").TracingContext;
-        extractStepResult?: any;
-        extractPrompt?: string;
-        score: number;
-        analyzeStepResult?: any;
-        analyzePrompt?: string;
-        reason?: string;
-        reasonPrompt?: string;
-        scorer: Record<string, any>;
-        metadata?: Record<string, any>;
-        source: import("@mastra/core/scores").ScoringSource;
-        entity: Record<string, any>;
-        entityType: import("@mastra/core/scores").ScoringEntityType;
-        structuredOutput?: boolean;
-        resourceId?: string;
-        threadId?: string;
-        id: string;
-        entityId: string;
-        scorerId: string;
-        createdAt: Date;
-        updatedAt: Date;
-        preprocessStepResult?: Record<string, any>;
-        preprocessPrompt?: string;
-        generateScorePrompt?: string;
-        generateReasonPrompt?: string;
-    }[];
-}>;
-export declare function saveScoreHandler({ mastra, score }: Context & {
-    score: ScoreRowData;
-}): Promise<never[] | {
-    score: ScoreRowData;
-}>;
+}, {
+    scorer: {
+        config: {
+            id: string;
+            description: string;
+            name?: string | undefined;
+            type?: unknown;
+            judge?: unknown;
+        };
+    };
+    agentIds: string[];
+    agentNames: string[];
+    workflowIds: string[];
+    isRegistered: boolean;
+    sampling?: Record<string, never> | 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;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    perPage: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+}, import("zod/v4/core").$strip>, 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;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    perPage: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    entityId: import("zod").ZodOptional<import("zod").ZodString>;
+    entityType: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, 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;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+    perPage: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>>;
+}, import("zod/v4/core").$strip>, 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

@@ -1 +1 @@
-{"version":3,"file":"scores.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/scores.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAqFxC,wBAAsB,iBAAiB,CAAC,EAAE,MAAM,EAAE,cAAc,EAAE,EAAE,OAAO,GAAG;IAAE,cAAc,EAAE,cAAc,CAAA;CAAE;;kBAvE5E,MAAM,EAAE;oBAAc,MAAM,EAAE;qBAAe,MAAM,EAAE;sBAAgB,OAAO;;GA8E/G;AAED,wBAAsB,gBAAgB,CAAC,EACrC,MAAM,EACN,QAAQ,EACR,cAAc,GACf,EAAE,OAAO,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,cAAc,CAAA;CAAE;cApF7B,MAAM,EAAE;gBAAc,MAAM,EAAE;iBAAe,MAAM,EAAE;kBAAgB,OAAO;WAiG/G;AAED,wBAAsB,uBAAuB,CAAC,EAC5C,MAAM,EACN,KAAK,EACL,UAAU,GACX,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,iBAAiB,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAa5D;AAED,wBAAsB,0BAA0B,CAAC,EAC/C,MAAM,EACN,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,UAAU,GACX,EAAE,OAAO,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,iBAAiB,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAevG;AAED,wBAAsB,0BAA0B,CAAC,EAC/C,MAAM,EACN,QAAQ,EACR,UAAU,EACV,UAAU,GACX,EAAE,OAAO,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,iBAAiB,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyBnF;AAgBD,wBAAsB,gBAAgB,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,YAAY,CAAA;CAAE;;GAO1F"}
+{"version":3,"file":"scores.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/scores.ts"],"names":[],"mappings":"AA+IA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;WAgB7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;iBAwB3B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;UA+BtC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;UA6BzC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;UA4CzC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;UAuB3B,CAAC"}

package/dist/server/handlers/scores.js

@@ -1,3 +1,3 @@
-export { getScorerHandler, getScorersHandler, getScoresByEntityIdHandler, getScoresByRunIdHandler, getScoresByScorerIdHandler, saveScoreHandler } from '../../chunk-AW5BU3RQ.js';
+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-CQUWREB2.js';
 //# sourceMappingURL=scores.js.map
 //# sourceMappingURL=scores.js.map

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

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

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

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