@mastra/server 1.12.0 → 1.13.0

package/dist/server/server-adapter/routes/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../../src/server/server-adapter/routes/memory.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,GAAG,CAAC;AAErC,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EA0BrD,CAAC"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../../src/server/server-adapter/routes/memory.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8EA0BhB,CAAC"}

package/dist/server/server-adapter/routes/observability.d.ts

@@ -1,3 +1,309 @@
-import type { ServerRoute } from '.';
-export declare const OBSERVABILITY_ROUTES: ServerRoute<any, any, any>[];
+export declare const OBSERVABILITY_ROUTES: readonly [import(".").ServerRoute<Record<string, unknown>, {
+    pagination: {
+        total: number;
+        page: number;
+        perPage: number | false;
+        hasMore: boolean;
+    };
+    spans: {
+        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;
+        entityType?: import("@mastra/core/observability").EntityType | null | undefined;
+        entityId?: string | null | undefined;
+        entityName?: string | null | undefined;
+        parentEntityType?: import("@mastra/core/observability").EntityType | null | undefined;
+        parentEntityId?: string | null | undefined;
+        parentEntityName?: string | null | undefined;
+        rootEntityType?: import("@mastra/core/observability").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;
+        source?: string | null | undefined;
+        serviceName?: string | null | undefined;
+        scope?: Record<string, unknown> | null | undefined;
+        parentSpanId?: string | null | undefined;
+    }[];
+}, "json", import(".").RouteSchemas<undefined, import("zod").ZodObject<Readonly<{
+    [k: string]: import("zod/v4/core").$ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>;
+}>, import("zod/v4/core").$strip>, undefined, import("zod").ZodObject<{
+    pagination: import("zod").ZodObject<{
+        total: import("zod").ZodNumber;
+        page: import("zod").ZodNumber;
+        perPage: import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodLiteral<false>]>;
+        hasMore: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>;
+    spans: import("zod").ZodArray<import("zod").ZodObject<{
+        createdAt: import("zod").ZodDate;
+        updatedAt: import("zod").ZodNullable<import("zod").ZodDate>;
+        experimentId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        attributes: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+        links: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodUnknown>>>;
+        input: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnknown>>;
+        output: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnknown>>;
+        error: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnknown>>;
+        endedAt: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodDate>>;
+        requestContext: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+        metadata: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+        tags: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodString>>>;
+        entityType: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<typeof import("@mastra/core/observability").EntityType>>>;
+        entityId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        entityName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        parentEntityType: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<typeof import("@mastra/core/observability").EntityType>>>;
+        parentEntityId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        parentEntityName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        rootEntityType: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<typeof import("@mastra/core/observability").EntityType>>>;
+        rootEntityId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        rootEntityName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        userId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        organizationId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        resourceId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        runId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        sessionId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        threadId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        requestId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        environment: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        source: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        serviceName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        scope: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+        name: import("zod").ZodString;
+        spanType: import("zod").ZodEnum<typeof import("@mastra/core/observability").SpanType>;
+        isEvent: import("zod").ZodBoolean;
+        startedAt: import("zod").ZodDate;
+        parentSpanId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        traceId: import("zod").ZodString;
+        spanId: import("zod").ZodString;
+        status: import("zod").ZodEnum<typeof import("@mastra/core/storage").TraceStatus>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>>, "GET", "/observability/traces">, import(".").ServerRoute<{
+    traceId: string;
+}, {
+    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;
+        entityType?: import("@mastra/core/observability").EntityType | null | undefined;
+        entityId?: string | null | undefined;
+        entityName?: string | null | undefined;
+        parentEntityType?: import("@mastra/core/observability").EntityType | null | undefined;
+        parentEntityId?: string | null | undefined;
+        parentEntityName?: string | null | undefined;
+        rootEntityType?: import("@mastra/core/observability").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;
+        source?: string | null | undefined;
+        serviceName?: string | null | undefined;
+        scope?: Record<string, unknown> | null | undefined;
+        parentSpanId?: string | null | undefined;
+    }[];
+}, "json", import(".").RouteSchemas<import("zod").ZodObject<{
+    traceId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
+    traceId: import("zod").ZodString;
+    spans: import("zod").ZodArray<import("zod").ZodObject<{
+        createdAt: import("zod").ZodDate;
+        updatedAt: import("zod").ZodNullable<import("zod").ZodDate>;
+        experimentId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        attributes: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+        links: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodUnknown>>>;
+        input: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnknown>>;
+        output: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnknown>>;
+        error: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodUnknown>>;
+        endedAt: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodDate>>;
+        requestContext: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+        metadata: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+        tags: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodArray<import("zod").ZodString>>>;
+        entityType: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<typeof import("@mastra/core/observability").EntityType>>>;
+        entityId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        entityName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        parentEntityType: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<typeof import("@mastra/core/observability").EntityType>>>;
+        parentEntityId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        parentEntityName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        rootEntityType: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<typeof import("@mastra/core/observability").EntityType>>>;
+        rootEntityId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        rootEntityName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        userId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        organizationId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        resourceId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        runId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        sessionId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        threadId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        requestId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        environment: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        source: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        serviceName: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        scope: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+        name: import("zod").ZodString;
+        spanType: import("zod").ZodEnum<typeof import("@mastra/core/observability").SpanType>;
+        isEvent: import("zod").ZodBoolean;
+        startedAt: import("zod").ZodDate;
+        parentSpanId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        traceId: import("zod").ZodString;
+        spanId: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>>, "GET", "/observability/traces/:traceId">, import(".").ServerRoute<{
+    scorerName: string;
+    targets: {
+        traceId: string;
+        spanId?: string | undefined;
+    }[];
+}, {
+    status: string;
+    message: string;
+    traceCount: number;
+}, "json", import(".").RouteSchemas<undefined, undefined, import("zod").ZodObject<{
+    scorerName: import("zod").ZodString;
+    targets: import("zod").ZodArray<import("zod").ZodObject<{
+        traceId: import("zod").ZodString;
+        spanId: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    status: import("zod").ZodString;
+    message: import("zod").ZodString;
+    traceCount: import("zod").ZodNumber;
+}, import("zod/v4/core").$strip>>, "POST", "/observability/traces/score">, import(".").ServerRoute<import(".").InferParams<import("zod").ZodObject<{
+    traceId: import("zod").ZodString;
+    spanId: 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: {
+        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", import(".").RouteSchemas<import("zod").ZodObject<{
+    traceId: import("zod").ZodString;
+    spanId: 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, import("zod").ZodObject<{
+    pagination: import("zod").ZodObject<{
+        total: import("zod").ZodNumber;
+        page: import("zod").ZodNumber;
+        perPage: import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodLiteral<false>]>;
+        hasMore: import("zod").ZodBoolean;
+    }, import("zod/v4/core").$strip>;
+    scores: import("zod").ZodArray<import("zod").ZodObject<{
+        createdAt: import("zod").ZodDate;
+        updatedAt: import("zod").ZodNullable<import("zod").ZodDate>;
+        id: import("zod").ZodString;
+        scorerId: import("zod").ZodString;
+        entityId: import("zod").ZodString;
+        runId: import("zod").ZodString;
+        input: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        output: import("zod").ZodUnknown;
+        additionalContext: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        requestContext: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        extractStepResult: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        extractPrompt: import("zod").ZodOptional<import("zod").ZodString>;
+        score: import("zod").ZodNumber;
+        analyzeStepResult: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        analyzePrompt: import("zod").ZodOptional<import("zod").ZodString>;
+        reason: import("zod").ZodOptional<import("zod").ZodString>;
+        reasonPrompt: import("zod").ZodOptional<import("zod").ZodString>;
+        scorer: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        source: import("zod").ZodEnum<{
+            LIVE: "LIVE";
+            TEST: "TEST";
+        }>;
+        entity: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        entityType: import("zod").ZodOptional<import("zod").ZodEnum<{
+            [x: string]: string;
+        }>>;
+        structuredOutput: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        traceId: import("zod").ZodOptional<import("zod").ZodString>;
+        spanId: import("zod").ZodOptional<import("zod").ZodString>;
+        resourceId: import("zod").ZodOptional<import("zod").ZodString>;
+        threadId: import("zod").ZodOptional<import("zod").ZodString>;
+        preprocessStepResult: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        preprocessPrompt: import("zod").ZodOptional<import("zod").ZodString>;
+        generateScorePrompt: import("zod").ZodOptional<import("zod").ZodString>;
+        generateReasonPrompt: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>>, "GET", "/observability/traces/:traceId/:spanId/scores">];
 //# sourceMappingURL=observability.d.ts.map

package/dist/server/server-adapter/routes/observability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"observability.d.ts","sourceRoot":"","sources":["../../../../src/server/server-adapter/routes/observability.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,GAAG,CAAC;AAErC,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAK5D,CAAC"}
+{"version":3,"file":"observability.d.ts","sourceRoot":"","sources":["../../../../src/server/server-adapter/routes/observability.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2FAKvB,CAAC"}

package/dist/server/server-adapter/routes/processor-providers.d.ts

@@ -1,3 +1,44 @@
-import type { ServerRoute } from '.';
-export declare const PROCESSOR_PROVIDER_ROUTES: ServerRoute<any, any, any>[];
+export declare const PROCESSOR_PROVIDER_ROUTES: readonly [import(".").ServerRoute<{}, {
+    providers: {
+        id: string;
+        name: string;
+        availablePhases: ("processInput" | "processInputStep" | "processOutputStream" | "processOutputResult" | "processOutputStep")[];
+        description?: string | undefined;
+    }[];
+}, "json", import(".").RouteSchemas<undefined, undefined, undefined, import("zod").ZodObject<{
+    providers: import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        availablePhases: import("zod").ZodArray<import("zod").ZodEnum<{
+            processInput: "processInput";
+            processInputStep: "processInputStep";
+            processOutputStream: "processOutputStream";
+            processOutputResult: "processOutputResult";
+            processOutputStep: "processOutputStep";
+        }>>;
+    }, import("zod/v4/core").$strip>>;
+}, import("zod/v4/core").$strip>>, "GET", "/processor-providers">, import(".").ServerRoute<{
+    providerId: string;
+}, {
+    id: string;
+    name: string;
+    availablePhases: ("processInput" | "processInputStep" | "processOutputStream" | "processOutputResult" | "processOutputStep")[];
+    configSchema: Record<string, unknown>;
+    description?: string | undefined;
+}, "json", import(".").RouteSchemas<import("zod").ZodObject<{
+    providerId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    name: import("zod").ZodString;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    availablePhases: import("zod").ZodArray<import("zod").ZodEnum<{
+        processInput: "processInput";
+        processInputStep: "processInputStep";
+        processOutputStream: "processOutputStream";
+        processOutputResult: "processOutputResult";
+        processOutputStep: "processOutputStep";
+    }>>;
+    configSchema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+}, import("zod/v4/core").$strip>>, "GET", "/processor-providers/:providerId">];
 //# sourceMappingURL=processor-providers.d.ts.map

package/dist/server/server-adapter/routes/processor-providers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"processor-providers.d.ts","sourceRoot":"","sources":["../../../../src/server/server-adapter/routes/processor-providers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,GAAG,CAAC;AAErC,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAGjE,CAAC"}
+{"version":3,"file":"processor-providers.d.ts","sourceRoot":"","sources":["../../../../src/server/server-adapter/routes/processor-providers.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8EAA0E,CAAC"}

package/dist/server/server-adapter/routes/processors.d.ts

@@ -1,3 +1,198 @@
-import type { ServerRoute } from '.';
-export declare const PROCESSORS_ROUTES: ServerRoute<any, any, any>[];
+export declare const PROCESSORS_ROUTES: readonly [import(".").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", import(".").RouteSchemas<undefined, undefined, undefined, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    phases: import("zod").ZodArray<import("zod").ZodEnum<{
+        input: "input";
+        inputStep: "inputStep";
+        outputStream: "outputStream";
+        outputResult: "outputResult";
+        outputStep: "outputStep";
+    }>>;
+    agentIds: import("zod").ZodArray<import("zod").ZodString>;
+    configurations: import("zod").ZodArray<import("zod").ZodObject<{
+        agentId: import("zod").ZodString;
+        type: import("zod").ZodEnum<{
+            input: "input";
+            output: "output";
+        }>;
+    }, import("zod/v4/core").$strip>>;
+    isWorkflow: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>>>, "GET", "/processors">, import(".").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", import(".").RouteSchemas<import("zod").ZodObject<{
+    processorId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    description: import("zod").ZodOptional<import("zod").ZodString>;
+    phases: import("zod").ZodArray<import("zod").ZodEnum<{
+        input: "input";
+        inputStep: "inputStep";
+        outputStream: "outputStream";
+        outputResult: "outputResult";
+        outputStep: "outputStep";
+    }>>;
+    configurations: import("zod").ZodArray<import("zod").ZodObject<{
+        agentId: import("zod").ZodString;
+        agentName: import("zod").ZodString;
+        type: import("zod").ZodEnum<{
+            input: "input";
+            output: "output";
+        }>;
+    }, import("zod/v4/core").$strip>>;
+    isWorkflow: import("zod").ZodBoolean;
+}, import("zod/v4/core").$strip>>, "GET", "/processors/:processorId">, import(".").ServerRoute<import(".").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", import(".").RouteSchemas<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>, import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    phase: import("zod").ZodString;
+    messages: import("zod").ZodOptional<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>>>;
+    messageList: import("zod").ZodOptional<import("zod").ZodObject<{
+        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>>;
+    }, import("zod/v4/core").$strip>>;
+    tripwire: import("zod").ZodOptional<import("zod").ZodObject<{
+        triggered: import("zod").ZodBoolean;
+        reason: import("zod").ZodOptional<import("zod").ZodString>;
+        metadata: import("zod").ZodOptional<import("zod").ZodAny>;
+    }, import("zod/v4/core").$strip>>;
+    error: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>>, "POST", "/processors/:processorId/execute">];
 //# sourceMappingURL=processors.d.ts.map

package/dist/server/server-adapter/routes/processors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"processors.d.ts","sourceRoot":"","sources":["../../../../src/server/server-adapter/routes/processors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,GAAG,CAAC;AAErC,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAIzD,CAAC"}
+{"version":3,"file":"processors.d.ts","sourceRoot":"","sources":["../../../../src/server/server-adapter/routes/processors.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+EAAuF,CAAC"}

package/dist/server/server-adapter/routes/route-builder.d.ts

@@ -1,7 +1,7 @@
 import type { ValidationErrorHook } from '@mastra/core/server';
 import { z } from 'zod';
 import type { ZodObject, ZodRawShape, ZodTypeAny } from 'zod';
-import type { InferParams, ResponseType, ServerRoute, ServerRouteHandler } from './index.js';
+import type { InferParams, ResponseType, RouteSchemas, ServerRoute, ServerRouteHandler } from './index.js';
 /**
  * Extracts parameters matching a Zod schema's shape from a params object.
  * Useful for separating schema-defined params from ServerContext in handlers.
@@ -60,9 +60,9 @@ export declare function jsonQueryParam<T extends ZodTypeAny>(schema: T): z.ZodTy
  * ```
  */
 export declare function wrapSchemaForQueryParams<T extends ZodRawShape>(schema: ZodObject<T>): ZodObject<ZodRawShape>;
-interface RouteConfig<TPathSchema extends z.ZodTypeAny | undefined = undefined, TQuerySchema extends z.ZodTypeAny | undefined = undefined, TBodySchema extends z.ZodTypeAny | undefined = undefined, TResponseSchema extends z.ZodTypeAny | undefined = undefined, TResponseType extends ResponseType = 'json'> {
-    method: ServerRoute['method'];
-    path: string;
+interface RouteConfig<TPathSchema extends z.ZodTypeAny | undefined = undefined, TQuerySchema extends z.ZodTypeAny | undefined = undefined, TBodySchema extends z.ZodTypeAny | undefined = undefined, TResponseSchema extends z.ZodTypeAny | undefined = undefined, TResponseType extends ResponseType = 'json', TMethod extends string = string, TPath extends string = string> {
+    method: TMethod;
+    path: TPath;
     responseType: TResponseType;
     streamFormat?: 'sse' | 'stream';
     handler: ServerRouteHandler<InferParams<TPathSchema, TQuerySchema, TBodySchema>, TResponseSchema extends z.ZodTypeAny ? z.infer<TResponseSchema> : unknown, TResponseType>;
@@ -143,7 +143,7 @@ interface RouteConfig<TPathSchema extends z.ZodTypeAny | undefined = undefined,
  * });
  * ```
  */
-export declare function createRoute<TPathSchema extends z.ZodTypeAny | undefined = undefined, TQuerySchema extends z.ZodTypeAny | undefined = undefined, TBodySchema extends z.ZodTypeAny | undefined = undefined, TResponseSchema extends z.ZodTypeAny | undefined = undefined, TResponseType extends ResponseType = 'json'>(config: RouteConfig<TPathSchema, TQuerySchema, TBodySchema, TResponseSchema, TResponseType>): ServerRoute<InferParams<TPathSchema, TQuerySchema, TBodySchema>, TResponseSchema extends z.ZodTypeAny ? z.infer<TResponseSchema> : unknown, TResponseType>;
+export declare function createRoute<TPathSchema extends z.ZodTypeAny | undefined = undefined, TQuerySchema extends z.ZodTypeAny | undefined = undefined, TBodySchema extends z.ZodTypeAny | undefined = undefined, TResponseSchema extends z.ZodTypeAny | undefined = undefined, TResponseType extends ResponseType = 'json', TMethod extends string = string, TPath extends string = string>(config: RouteConfig<TPathSchema, TQuerySchema, TBodySchema, TResponseSchema, TResponseType, TMethod, TPath>): ServerRoute<InferParams<TPathSchema, TQuerySchema, TBodySchema>, TResponseSchema extends z.ZodTypeAny ? z.infer<TResponseSchema> : unknown, TResponseType, RouteSchemas<TPathSchema, TQuerySchema, TBodySchema, TResponseSchema>, TMethod, TPath>;
 /**
  * Creates a public server route that bypasses authentication and authorization.
  *
@@ -180,6 +180,6 @@ export declare function createRoute<TPathSchema extends z.ZodTypeAny | undefined
  * });
  * ```
  */
-export declare function createPublicRoute<TPathSchema extends z.ZodTypeAny | undefined = undefined, TQuerySchema extends z.ZodTypeAny | undefined = undefined, TBodySchema extends z.ZodTypeAny | undefined = undefined, TResponseSchema extends z.ZodTypeAny | undefined = undefined, TResponseType extends ResponseType = 'json'>(config: Omit<RouteConfig<TPathSchema, TQuerySchema, TBodySchema, TResponseSchema, TResponseType>, 'requiresAuth'>): ServerRoute<InferParams<TPathSchema, TQuerySchema, TBodySchema>, TResponseSchema extends z.ZodTypeAny ? z.infer<TResponseSchema> : unknown, TResponseType>;
+export declare function createPublicRoute<TPathSchema extends z.ZodTypeAny | undefined = undefined, TQuerySchema extends z.ZodTypeAny | undefined = undefined, TBodySchema extends z.ZodTypeAny | undefined = undefined, TResponseSchema extends z.ZodTypeAny | undefined = undefined, TResponseType extends ResponseType = 'json', TMethod extends string = string, TPath extends string = string>(config: Omit<RouteConfig<TPathSchema, TQuerySchema, TBodySchema, TResponseSchema, TResponseType, TMethod, TPath>, 'requiresAuth'>): ServerRoute<InferParams<TPathSchema, TQuerySchema, TBodySchema>, TResponseSchema extends z.ZodTypeAny ? z.infer<TResponseSchema> : unknown, TResponseType, RouteSchemas<TPathSchema, TQuerySchema, TBodySchema, TResponseSchema>, TMethod, TPath>;
 export {};
 //# sourceMappingURL=route-builder.d.ts.map