@mastra/server 1.32.0 → 1.32.1

package/dist/server/handlers/observability-storage-schemas.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var chunk2J4KEVXS_cjs = require('../../chunk-2J4KEVXS.cjs');
+
+
+
+Object.defineProperty(exports, "branchesFilterSchema", {
+  enumerable: true,
+  get: function () { return chunk2J4KEVXS_cjs.branchesFilterSchema; }
+});
+Object.defineProperty(exports, "branchesOrderBySchema", {
+  enumerable: true,
+  get: function () { return chunk2J4KEVXS_cjs.branchesOrderBySchema; }
+});
+Object.defineProperty(exports, "getBranchArgsSchema", {
+  enumerable: true,
+  get: function () { return chunk2J4KEVXS_cjs.getBranchArgsSchema; }
+});
+Object.defineProperty(exports, "getBranchResponseSchema", {
+  enumerable: true,
+  get: function () { return chunk2J4KEVXS_cjs.getBranchResponseSchema; }
+});
+Object.defineProperty(exports, "listBranchesResponseSchema", {
+  enumerable: true,
+  get: function () { return chunk2J4KEVXS_cjs.listBranchesResponseSchema; }
+});
+//# sourceMappingURL=observability-storage-schemas.cjs.map
+//# sourceMappingURL=observability-storage-schemas.cjs.map

package/dist/server/handlers/observability-storage-schemas.cjs.map

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

package/dist/server/handlers/observability-storage-schemas.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Safe re-export of branches-related Zod schemas from `@mastra/core/storage`.
+ *
+ * Why this shim exists:
+ * The `branches*` and `getBranch*` / `listBranches*` schemas (used to define
+ * `/observability/branches` and `/observability/traces/:traceId/branches/:spanId`
+ * routes) were introduced in `@mastra/core@1.32.0`. Earlier versions of
+ * `@mastra/core` ship `@mastra/core/storage` but do not export these names.
+ *
+ * A direct named import (`import { branchesFilterSchema } from
+ * '@mastra/core/storage'`) fails at ESM link time when this version of
+ * `@mastra/server` is paired with `@mastra/core < 1.32.0`, taking the entire
+ * user bundle down before any code runs.
+ *
+ * A namespace import tolerates missing names (`ns.MissingExport` is just
+ * `undefined`, no link-time error). We then fall back to a permissive empty
+ * `z.object({})` so the route definitions can still evaluate at module load
+ * time. On old core the branches routes will register but their handlers
+ * will fail at request time when the storage backend doesn't implement
+ * `listBranches` / `getBranch` — which is the correct degradation, since
+ * those storage methods don't exist on old core either.
+ *
+ * Once the consuming `@mastra/core` is on `1.32.0+` the schemas are real
+ * and behaviour is identical to a direct named import.
+ */
+export declare const branchesFilterSchema: any;
+export declare const branchesOrderBySchema: any;
+export declare const getBranchArgsSchema: any;
+export declare const listBranchesResponseSchema: any;
+export declare const getBranchResponseSchema: any;
+//# sourceMappingURL=observability-storage-schemas.d.ts.map

package/dist/server/handlers/observability-storage-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observability-storage-schemas.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/observability-storage-schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAgCH,eAAO,MAAM,oBAAoB,EAAE,GAAoD,CAAC;AACxF,eAAO,MAAM,qBAAqB,EAAE,GAAqD,CAAC;AAC1F,eAAO,MAAM,mBAAmB,EAAE,GAAkD,CAAC;AACrF,eAAO,MAAM,0BAA0B,EAAE,GAAqD,CAAC;AAC/F,eAAO,MAAM,uBAAuB,EAAE,GAAkD,CAAC"}

package/dist/server/handlers/observability-storage-schemas.js

@@ -0,0 +1,3 @@
+export { branchesFilterSchema, branchesOrderBySchema, getBranchArgsSchema, getBranchResponseSchema, listBranchesResponseSchema } from '../../chunk-NF5SYJHK.js';
+//# sourceMappingURL=observability-storage-schemas.js.map
+//# sourceMappingURL=observability-storage-schemas.js.map

package/dist/server/handlers/observability-storage-schemas.js.map

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

package/dist/server/handlers/observability.cjs

@@ -1,45 +1,45 @@
 'use strict';
 
-var chunkLX3ESTTN_cjs = require('../../chunk-LX3ESTTN.cjs');
+var chunkELU7GCBF_cjs = require('../../chunk-ELU7GCBF.cjs');
 var chunkVIX5OA2V_cjs = require('../../chunk-VIX5OA2V.cjs');
 
 
 
 Object.defineProperty(exports, "GET_BRANCH_ROUTE", {
   enumerable: true,
-  get: function () { return chunkLX3ESTTN_cjs.GET_BRANCH_ROUTE; }
+  get: function () { return chunkELU7GCBF_cjs.GET_BRANCH_ROUTE; }
 });
 Object.defineProperty(exports, "GET_SPAN_ROUTE", {
   enumerable: true,
-  get: function () { return chunkLX3ESTTN_cjs.GET_SPAN_ROUTE; }
+  get: function () { return chunkELU7GCBF_cjs.GET_SPAN_ROUTE; }
 });
 Object.defineProperty(exports, "GET_TRACE_LIGHT_ROUTE", {
   enumerable: true,
-  get: function () { return chunkLX3ESTTN_cjs.GET_TRACE_LIGHT_ROUTE; }
+  get: function () { return chunkELU7GCBF_cjs.GET_TRACE_LIGHT_ROUTE; }
 });
 Object.defineProperty(exports, "GET_TRACE_ROUTE", {
   enumerable: true,
-  get: function () { return chunkLX3ESTTN_cjs.GET_TRACE_ROUTE; }
+  get: function () { return chunkELU7GCBF_cjs.GET_TRACE_ROUTE; }
 });
 Object.defineProperty(exports, "GET_TRACE_TRAJECTORY_ROUTE", {
   enumerable: true,
-  get: function () { return chunkLX3ESTTN_cjs.GET_TRACE_TRAJECTORY_ROUTE; }
+  get: function () { return chunkELU7GCBF_cjs.GET_TRACE_TRAJECTORY_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_BRANCHES_ROUTE", {
   enumerable: true,
-  get: function () { return chunkLX3ESTTN_cjs.LIST_BRANCHES_ROUTE; }
+  get: function () { return chunkELU7GCBF_cjs.LIST_BRANCHES_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_SCORES_BY_SPAN_ROUTE", {
   enumerable: true,
-  get: function () { return chunkLX3ESTTN_cjs.LIST_SCORES_BY_SPAN_ROUTE; }
+  get: function () { return chunkELU7GCBF_cjs.LIST_SCORES_BY_SPAN_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_TRACES_ROUTE", {
   enumerable: true,
-  get: function () { return chunkLX3ESTTN_cjs.LIST_TRACES_ROUTE; }
+  get: function () { return chunkELU7GCBF_cjs.LIST_TRACES_ROUTE; }
 });
 Object.defineProperty(exports, "SCORE_TRACES_ROUTE", {
   enumerable: true,
-  get: function () { return chunkLX3ESTTN_cjs.SCORE_TRACES_ROUTE; }
+  get: function () { return chunkELU7GCBF_cjs.SCORE_TRACES_ROUTE; }
 });
 Object.defineProperty(exports, "CREATE_FEEDBACK", {
   enumerable: true,

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

@@ -109,217 +109,13 @@ export declare const LIST_TRACES_ROUTE: import("../server-adapter").ServerRoute<
     }, z.core.$strip>>;
 }, z.core.$strip>>, "GET", "/observability/traces">;
 /** Route: GET /observability/branches - paginated branch-anchor span listing across all traces. */
-export declare const LIST_BRANCHES_ROUTE: import("../server-adapter").ServerRoute<Record<string, unknown>, {
-    pagination: {
-        total: number;
-        page: number;
-        perPage: number | false;
-        hasMore: boolean;
-    };
-    branches: {
-        createdAt: Date;
-        updatedAt: Date | null;
-        name: string;
-        spanType: import("@mastra/core/observability").SpanType;
-        isEvent: boolean;
-        startedAt: Date;
-        traceId: string;
-        spanId: string;
-        status: import("@mastra/core/storage").TraceStatus;
-        experimentId?: string | null | undefined;
-        attributes?: Record<string, unknown> | null | undefined;
-        links?: unknown[] | null | undefined;
-        input?: unknown;
-        output?: unknown;
-        error?: unknown;
-        endedAt?: Date | null | undefined;
-        requestContext?: Record<string, unknown> | null | undefined;
-        metadata?: Record<string, unknown> | null | undefined;
-        tags?: string[] | null | undefined;
-        source?: string | null | undefined;
-        entityType?: import("@mastra/core/storage").EntityType | null | undefined;
-        entityId?: string | null | undefined;
-        entityName?: string | null | undefined;
-        parentEntityType?: import("@mastra/core/storage").EntityType | null | undefined;
-        parentEntityId?: string | null | undefined;
-        parentEntityName?: string | null | undefined;
-        rootEntityType?: import("@mastra/core/storage").EntityType | null | undefined;
-        rootEntityId?: string | null | undefined;
-        rootEntityName?: 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;
-        serviceName?: string | null | undefined;
-        scope?: Record<string, unknown> | null | undefined;
-        entityVersionId?: string | null | undefined;
-        parentEntityVersionId?: string | null | undefined;
-        rootEntityVersionId?: string | null | undefined;
-        parentSpanId?: string | null | undefined;
-    }[];
-}, "json", import("../server-adapter").RouteSchemas<undefined, z.ZodObject<Readonly<{
+export declare const LIST_BRANCHES_ROUTE: import("../server-adapter").ServerRoute<Record<string, unknown>, any, "json", import("../server-adapter").RouteSchemas<undefined, z.ZodObject<Readonly<{
     [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-}>, z.core.$strip>, undefined, z.ZodObject<{
-    pagination: z.ZodObject<{
-        total: z.ZodNumber;
-        page: z.ZodNumber;
-        perPage: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<false>]>;
-        hasMore: z.ZodBoolean;
-    }, z.core.$strip>;
-    branches: z.ZodArray<z.ZodObject<{
-        createdAt: z.ZodDate;
-        updatedAt: z.ZodNullable<z.ZodDate>;
-        experimentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        attributes: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnknown>>>;
-        input: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
-        output: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
-        error: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
-        endedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
-        requestContext: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        tags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
-        source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        entityType: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof import("@mastra/core/storage").EntityType>>>;
-        entityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        entityName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        parentEntityType: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof import("@mastra/core/storage").EntityType>>>;
-        parentEntityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        parentEntityName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        rootEntityType: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof import("@mastra/core/storage").EntityType>>>;
-        rootEntityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        rootEntityName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        organizationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        runId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        sessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        threadId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        requestId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        environment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        serviceName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        scope: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        entityVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        parentEntityVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        rootEntityVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        name: z.ZodString;
-        spanType: z.ZodEnum<typeof import("@mastra/core/observability").SpanType>;
-        isEvent: z.ZodBoolean;
-        startedAt: z.ZodDate;
-        parentSpanId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        traceId: z.ZodString;
-        spanId: z.ZodString;
-        status: z.ZodEnum<typeof import("@mastra/core/storage").TraceStatus>;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, "GET", "/observability/branches">;
+}>, z.core.$strip>, undefined, any>, "GET", "/observability/branches">;
 /** Route: GET /observability/traces/:traceId/branches/:spanId - retrieve the subtree rooted at a span. */
-export declare const GET_BRANCH_ROUTE: import("../server-adapter").ServerRoute<import("../server-adapter").InferParams<z.ZodObject<{
-    traceId: z.ZodString;
-    spanId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<Readonly<{
+export declare const GET_BRANCH_ROUTE: import("../server-adapter").ServerRoute<any, any, "json", import("../server-adapter").RouteSchemas<any, z.ZodObject<Readonly<{
     [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-}>, z.core.$strip>, undefined>, {
-    traceId: string;
-    spans: {
-        createdAt: Date;
-        updatedAt: Date | null;
-        name: string;
-        spanType: import("@mastra/core/observability").SpanType;
-        isEvent: boolean;
-        startedAt: Date;
-        traceId: string;
-        spanId: string;
-        experimentId?: string | null | undefined;
-        attributes?: Record<string, unknown> | null | undefined;
-        links?: unknown[] | null | undefined;
-        input?: unknown;
-        output?: unknown;
-        error?: unknown;
-        endedAt?: Date | null | undefined;
-        requestContext?: Record<string, unknown> | null | undefined;
-        metadata?: Record<string, unknown> | null | undefined;
-        tags?: string[] | null | undefined;
-        source?: string | null | undefined;
-        entityType?: import("@mastra/core/storage").EntityType | null | undefined;
-        entityId?: string | null | undefined;
-        entityName?: string | null | undefined;
-        parentEntityType?: import("@mastra/core/storage").EntityType | null | undefined;
-        parentEntityId?: string | null | undefined;
-        parentEntityName?: string | null | undefined;
-        rootEntityType?: import("@mastra/core/storage").EntityType | null | undefined;
-        rootEntityId?: string | null | undefined;
-        rootEntityName?: 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;
-        serviceName?: string | null | undefined;
-        scope?: Record<string, unknown> | null | undefined;
-        entityVersionId?: string | null | undefined;
-        parentEntityVersionId?: string | null | undefined;
-        rootEntityVersionId?: string | null | undefined;
-        parentSpanId?: string | null | undefined;
-    }[];
-}, "json", import("../server-adapter").RouteSchemas<z.ZodObject<{
-    traceId: z.ZodString;
-    spanId: z.ZodString;
-}, z.core.$strip>, z.ZodObject<Readonly<{
-    [k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-}>, z.core.$strip>, undefined, z.ZodObject<{
-    traceId: z.ZodString;
-    spans: z.ZodArray<z.ZodObject<{
-        createdAt: z.ZodDate;
-        updatedAt: z.ZodNullable<z.ZodDate>;
-        experimentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        attributes: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        links: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodUnknown>>>;
-        input: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
-        output: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
-        error: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
-        endedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
-        requestContext: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        tags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
-        source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        entityType: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof import("@mastra/core/storage").EntityType>>>;
-        entityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        entityName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        parentEntityType: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof import("@mastra/core/storage").EntityType>>>;
-        parentEntityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        parentEntityName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        rootEntityType: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof import("@mastra/core/storage").EntityType>>>;
-        rootEntityId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        rootEntityName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        organizationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        runId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        sessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        threadId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        requestId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        environment: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        serviceName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        scope: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        entityVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        parentEntityVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        rootEntityVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        name: z.ZodString;
-        spanType: z.ZodEnum<typeof import("@mastra/core/observability").SpanType>;
-        isEvent: z.ZodBoolean;
-        startedAt: z.ZodDate;
-        parentSpanId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        traceId: z.ZodString;
-        spanId: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>>, "GET", "/observability/traces/:traceId/branches/:spanId">;
+}>, z.core.$strip>, undefined, any>, "GET", "/observability/traces/:traceId/branches/:spanId">;
 /** Route: GET /observability/traces/:traceId - retrieve a single trace with all spans. */
 export declare const GET_TRACE_ROUTE: import("../server-adapter").ServerRoute<{
     traceId: string;

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":"AAwBA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAM3B,cAAc,+BAA+B,CAAC;AAwE9C,6FAA6F;AAC7F,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDA+B5B,CAAC;AAEH,mGAAmG;AACnG,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAyB9B,CAAC;AAEH,0GAA0G;AAC1G,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EA0B3B,CAAC;AAEH,0FAA0F;AAC1F,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4DAwB1B,CAAC;AAEH,kGAAkG;AAClG,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAyBhC,CAAC;AAEH,qGAAqG;AACrG,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAwBzB,CAAC;AAEH,8FAA8F;AAC9F,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;uEA8BrC,CAAC;AAEH,yGAAyG;AACzG,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;0DAwC7B,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2EA2BpC,CAAC"}
+{"version":3,"file":"observability.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/observability.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAa3B,cAAc,+BAA+B,CAAC;AAwE9C,6FAA6F;AAC7F,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDA+B5B,CAAC;AAEH,mGAAmG;AACnG,eAAO,MAAM,mBAAmB;;sEAyB9B,CAAC;AAEH,0GAA0G;AAC1G,eAAO,MAAM,gBAAgB;;8FA0B3B,CAAC;AAEH,0FAA0F;AAC1F,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4DAwB1B,CAAC;AAEH,kGAAkG;AAClG,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAyBhC,CAAC;AAEH,qGAAqG;AACrG,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAwBzB,CAAC;AAEH,8FAA8F;AAC9F,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;uEA8BrC,CAAC;AAEH,yGAAyG;AACzG,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;0DAwC7B,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2EA2BpC,CAAC"}

package/dist/server/handlers/observability.js

@@ -1,4 +1,4 @@
-export { GET_BRANCH_ROUTE, GET_SPAN_ROUTE, GET_TRACE_LIGHT_ROUTE, GET_TRACE_ROUTE, GET_TRACE_TRAJECTORY_ROUTE, LIST_BRANCHES_ROUTE, LIST_SCORES_BY_SPAN_ROUTE, LIST_TRACES_ROUTE, SCORE_TRACES_ROUTE } from '../../chunk-L3LU2FSK.js';
+export { GET_BRANCH_ROUTE, GET_SPAN_ROUTE, GET_TRACE_LIGHT_ROUTE, GET_TRACE_ROUTE, GET_TRACE_TRAJECTORY_ROUTE, LIST_BRANCHES_ROUTE, LIST_SCORES_BY_SPAN_ROUTE, LIST_TRACES_ROUTE, SCORE_TRACES_ROUTE } from '../../chunk-V5AXCSSN.js';
 export { CREATE_FEEDBACK, CREATE_SCORE, GET_ENTITY_NAMES, GET_ENTITY_TYPES, GET_ENVIRONMENTS, GET_FEEDBACK_AGGREGATE, GET_FEEDBACK_BREAKDOWN, GET_FEEDBACK_PERCENTILES, GET_FEEDBACK_TIME_SERIES, GET_METRIC_AGGREGATE, GET_METRIC_BREAKDOWN, GET_METRIC_LABEL_KEYS, GET_METRIC_LABEL_VALUES, GET_METRIC_NAMES, GET_METRIC_PERCENTILES, GET_METRIC_TIME_SERIES, GET_SCORE, GET_SCORE_AGGREGATE, GET_SCORE_BREAKDOWN, GET_SCORE_PERCENTILES, GET_SCORE_TIME_SERIES, GET_SERVICE_NAMES, GET_TAGS, LIST_FEEDBACK, LIST_LOGS, LIST_SCORES, NEW_ROUTES } from '../../chunk-YWORLTQM.js';
 //# sourceMappingURL=observability.js.map
 //# sourceMappingURL=observability.js.map

package/dist/server/handlers/responses.cjs

@@ -1,20 +1,20 @@
 'use strict';
 
-var chunkW4VETOUS_cjs = require('../../chunk-W4VETOUS.cjs');
+var chunkYF6DVWNN_cjs = require('../../chunk-YF6DVWNN.cjs');
 
 
 
 Object.defineProperty(exports, "CREATE_RESPONSE_ROUTE", {
   enumerable: true,
-  get: function () { return chunkW4VETOUS_cjs.CREATE_RESPONSE_ROUTE; }
+  get: function () { return chunkYF6DVWNN_cjs.CREATE_RESPONSE_ROUTE; }
 });
 Object.defineProperty(exports, "DELETE_RESPONSE_ROUTE", {
   enumerable: true,
-  get: function () { return chunkW4VETOUS_cjs.DELETE_RESPONSE_ROUTE; }
+  get: function () { return chunkYF6DVWNN_cjs.DELETE_RESPONSE_ROUTE; }
 });
 Object.defineProperty(exports, "GET_RESPONSE_ROUTE", {
   enumerable: true,
-  get: function () { return chunkW4VETOUS_cjs.GET_RESPONSE_ROUTE; }
+  get: function () { return chunkYF6DVWNN_cjs.GET_RESPONSE_ROUTE; }
 });
 //# sourceMappingURL=responses.cjs.map
 //# sourceMappingURL=responses.cjs.map

package/dist/server/handlers/responses.js

@@ -1,3 +1,3 @@
-export { CREATE_RESPONSE_ROUTE, DELETE_RESPONSE_ROUTE, GET_RESPONSE_ROUTE } from '../../chunk-RQVAWLYS.js';
+export { CREATE_RESPONSE_ROUTE, DELETE_RESPONSE_ROUTE, GET_RESPONSE_ROUTE } from '../../chunk-NVM46NSG.js';
 //# sourceMappingURL=responses.js.map
 //# sourceMappingURL=responses.js.map

package/dist/server/handlers/responses.storage.cjs

@@ -1,36 +1,36 @@
 'use strict';
 
-var chunkIYQS5YRY_cjs = require('../../chunk-IYQS5YRY.cjs');
+var chunkPJYQMPXT_cjs = require('../../chunk-PJYQMPXT.cjs');
 
 
 
 Object.defineProperty(exports, "deleteResponseTurnRecord", {
   enumerable: true,
-  get: function () { return chunkIYQS5YRY_cjs.deleteResponseTurnRecord; }
+  get: function () { return chunkPJYQMPXT_cjs.deleteResponseTurnRecord; }
 });
 Object.defineProperty(exports, "findConversationThreadAcrossAgents", {
   enumerable: true,
-  get: function () { return chunkIYQS5YRY_cjs.findConversationThreadAcrossAgents; }
+  get: function () { return chunkPJYQMPXT_cjs.findConversationThreadAcrossAgents; }
 });
 Object.defineProperty(exports, "findResponseTurnRecord", {
   enumerable: true,
-  get: function () { return chunkIYQS5YRY_cjs.findResponseTurnRecord; }
+  get: function () { return chunkPJYQMPXT_cjs.findResponseTurnRecord; }
 });
 Object.defineProperty(exports, "findResponseTurnRecordAcrossAgents", {
   enumerable: true,
-  get: function () { return chunkIYQS5YRY_cjs.findResponseTurnRecordAcrossAgents; }
+  get: function () { return chunkPJYQMPXT_cjs.findResponseTurnRecordAcrossAgents; }
 });
 Object.defineProperty(exports, "getAgentMemoryStore", {
   enumerable: true,
-  get: function () { return chunkIYQS5YRY_cjs.getAgentMemoryStore; }
+  get: function () { return chunkPJYQMPXT_cjs.getAgentMemoryStore; }
 });
 Object.defineProperty(exports, "persistResponseTurnRecord", {
   enumerable: true,
-  get: function () { return chunkIYQS5YRY_cjs.persistResponseTurnRecord; }
+  get: function () { return chunkPJYQMPXT_cjs.persistResponseTurnRecord; }
 });
 Object.defineProperty(exports, "resolveResponseTurnMessagesForStorage", {
   enumerable: true,
-  get: function () { return chunkIYQS5YRY_cjs.resolveResponseTurnMessagesForStorage; }
+  get: function () { return chunkPJYQMPXT_cjs.resolveResponseTurnMessagesForStorage; }
 });
 //# sourceMappingURL=responses.storage.cjs.map
 //# sourceMappingURL=responses.storage.cjs.map

package/dist/server/handlers/responses.storage.js

@@ -1,3 +1,3 @@
-export { deleteResponseTurnRecord, findConversationThreadAcrossAgents, findResponseTurnRecord, findResponseTurnRecordAcrossAgents, getAgentMemoryStore, persistResponseTurnRecord, resolveResponseTurnMessagesForStorage } from '../../chunk-4H5DNMAO.js';
+export { deleteResponseTurnRecord, findConversationThreadAcrossAgents, findResponseTurnRecord, findResponseTurnRecordAcrossAgents, getAgentMemoryStore, persistResponseTurnRecord, resolveResponseTurnMessagesForStorage } from '../../chunk-DFSUBEGE.js';
 //# sourceMappingURL=responses.storage.js.map
 //# sourceMappingURL=responses.storage.js.map

package/dist/server/handlers/schedules-workflows-shim.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunkDLYZIVMO_cjs = require('../../chunk-DLYZIVMO.cjs');
+
+
+
+Object.defineProperty(exports, "computeNextFireAt", {
+  enumerable: true,
+  get: function () { return chunkDLYZIVMO_cjs.computeNextFireAt; }
+});
+//# sourceMappingURL=schedules-workflows-shim.cjs.map
+//# sourceMappingURL=schedules-workflows-shim.cjs.map

package/dist/server/handlers/schedules-workflows-shim.cjs.map

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

package/dist/server/handlers/schedules-workflows-shim.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Safe re-export of `computeNextFireAt` from `@mastra/core/workflows`.
+ *
+ * Why this shim exists:
+ * `computeNextFireAt` was introduced in `@mastra/core@1.32.0`. Earlier
+ * versions of `@mastra/core` ship `@mastra/core/workflows` but do not export
+ * this function. A direct named import fails at ESM link time when this
+ * version of `@mastra/server` is paired with `@mastra/core < 1.32.0`, taking
+ * the entire user bundle down before any code runs.
+ *
+ * A namespace import tolerates missing names. We expose the real function
+ * when available and fall back to a function that throws a clear error
+ * otherwise — schedules require new-core support anyway, so loud failure at
+ * the call site is far better than silent corruption.
+ *
+ * Typed as `any` on purpose (see ./observability-storage-schemas.ts for
+ * the same rationale): keeps the emitted `.d.ts` free of names that don't
+ * exist in older cores.
+ */
+export declare const computeNextFireAt: any;
+//# sourceMappingURL=schedules-workflows-shim.d.ts.map

package/dist/server/handlers/schedules-workflows-shim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedules-workflows-shim.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/schedules-workflows-shim.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,eAAO,MAAM,iBAAiB,EAAE,GAO5B,CAAC"}

package/dist/server/handlers/schedules-workflows-shim.js

@@ -0,0 +1,3 @@
+export { computeNextFireAt } from '../../chunk-KMGGICVD.js';
+//# sourceMappingURL=schedules-workflows-shim.js.map
+//# sourceMappingURL=schedules-workflows-shim.js.map

package/dist/server/handlers/schedules-workflows-shim.js.map

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

package/dist/server/handlers/schedules.cjs

@@ -1,28 +1,28 @@
 'use strict';
 
-var chunkP2PZPH24_cjs = require('../../chunk-P2PZPH24.cjs');
+var chunkUWBU3GWI_cjs = require('../../chunk-UWBU3GWI.cjs');
 
 
 
 Object.defineProperty(exports, "GET_SCHEDULE_ROUTE", {
   enumerable: true,
-  get: function () { return chunkP2PZPH24_cjs.GET_SCHEDULE_ROUTE; }
+  get: function () { return chunkUWBU3GWI_cjs.GET_SCHEDULE_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_SCHEDULES_ROUTE", {
   enumerable: true,
-  get: function () { return chunkP2PZPH24_cjs.LIST_SCHEDULES_ROUTE; }
+  get: function () { return chunkUWBU3GWI_cjs.LIST_SCHEDULES_ROUTE; }
 });
 Object.defineProperty(exports, "LIST_SCHEDULE_TRIGGERS_ROUTE", {
   enumerable: true,
-  get: function () { return chunkP2PZPH24_cjs.LIST_SCHEDULE_TRIGGERS_ROUTE; }
+  get: function () { return chunkUWBU3GWI_cjs.LIST_SCHEDULE_TRIGGERS_ROUTE; }
 });
 Object.defineProperty(exports, "PAUSE_SCHEDULE_ROUTE", {
   enumerable: true,
-  get: function () { return chunkP2PZPH24_cjs.PAUSE_SCHEDULE_ROUTE; }
+  get: function () { return chunkUWBU3GWI_cjs.PAUSE_SCHEDULE_ROUTE; }
 });
 Object.defineProperty(exports, "RESUME_SCHEDULE_ROUTE", {
   enumerable: true,
-  get: function () { return chunkP2PZPH24_cjs.RESUME_SCHEDULE_ROUTE; }
+  get: function () { return chunkUWBU3GWI_cjs.RESUME_SCHEDULE_ROUTE; }
 });
 //# sourceMappingURL=schedules.cjs.map
 //# sourceMappingURL=schedules.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"schedules.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/schedules.ts"],"names":[],"mappings":"AAqEA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAiC/B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAqB7B,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EA+BvC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EA0B/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2EA8BhC,CAAC"}
+{"version":3,"file":"schedules.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/schedules.ts"],"names":[],"mappings":"AAuEA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAiC/B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAqB7B,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EA+BvC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EA0B/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2EA8BhC,CAAC"}

package/dist/server/handlers/schedules.js

@@ -1,3 +1,3 @@
-export { GET_SCHEDULE_ROUTE, LIST_SCHEDULES_ROUTE, LIST_SCHEDULE_TRIGGERS_ROUTE, PAUSE_SCHEDULE_ROUTE, RESUME_SCHEDULE_ROUTE } from '../../chunk-4Y77CVSI.js';
+export { GET_SCHEDULE_ROUTE, LIST_SCHEDULES_ROUTE, LIST_SCHEDULE_TRIGGERS_ROUTE, PAUSE_SCHEDULE_ROUTE, RESUME_SCHEDULE_ROUTE } from '../../chunk-H656FJUZ.js';
 //# sourceMappingURL=schedules.js.map
 //# sourceMappingURL=schedules.js.map

package/dist/server/handlers/scores.cjs

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

package/dist/server/handlers/scores.js

@@ -1,3 +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-4WWS6GKP.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-YEAIZPBY.js';
 //# sourceMappingURL=scores.js.map
 //# sourceMappingURL=scores.js.map