@mastra/deployer 0.0.0-error-handler-fix-20251020202607 → 0.0.0-execa-dynamic-import-20260304221256

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

@@ -1,3 +0,0 @@
-import { Hono } from 'hono';
-export declare function observabilityRouter(): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-//# sourceMappingURL=router.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../../../../src/server/handlers/routes/observability/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAS5B,wBAAgB,mBAAmB,+EAkQlC"}

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

@@ -1,300 +0,0 @@
-import type { Context } from 'hono';
-export declare function getScorersHandler(c: Context): Promise<Response>;
-export declare function getScorerHandler(c: Context): Promise<Response & import("hono").TypedResponse<{
-    scorer: {
-        config: {
-            name: any;
-            description: string;
-            judge?: {
-                model: import("@mastra/core/llm/model").ModelRouterModelId | {
-                    readonly specificationVersion: "v1";
-                    readonly provider: string;
-                    readonly modelId: string;
-                    readonly defaultObjectGenerationMode: "tool" | "json" | undefined;
-                    readonly supportsImageUrls?: boolean | undefined;
-                    readonly supportsStructuredOutputs?: boolean | undefined;
-                    supportsUrl?: {} | undefined;
-                    doGenerate: {};
-                    doStream: {};
-                } | {
-                    readonly specificationVersion: "v2";
-                    readonly provider: string;
-                    readonly modelId: string;
-                    supportedUrls: {
-                        [x: string]: {
-                            exec: {};
-                            test: {};
-                            readonly source: string;
-                            readonly global: boolean;
-                            readonly ignoreCase: boolean;
-                            readonly multiline: boolean;
-                            lastIndex: number;
-                            compile: {};
-                            readonly flags: string;
-                            readonly sticky: boolean;
-                            readonly unicode: boolean;
-                            readonly dotAll: boolean;
-                            readonly hasIndices: boolean;
-                        }[];
-                    } | {
-                        then: {};
-                    };
-                    doGenerate: {};
-                    doStream: {};
-                } | {
-                    id: `${string}/${string}`;
-                    url?: string | undefined;
-                    apiKey?: string | undefined;
-                    headers?: {
-                        [x: string]: string;
-                    } | undefined;
-                } | {
-                    providerId: string;
-                    modelId: string;
-                    url?: string | undefined;
-                    apiKey?: string | undefined;
-                    headers?: {
-                        [x: string]: string;
-                    } | undefined;
-                };
-                instructions: string;
-            } | undefined;
-            type?: "agent" | {
-                input: {
-                    readonly _type: any;
-                    readonly _output: any;
-                    readonly _input: any;
-                    readonly _def: {
-                        errorMap?: {} | undefined;
-                        description?: string | undefined | undefined;
-                    };
-                    readonly description: string | undefined;
-                    "~standard": {
-                        readonly version: 1;
-                        readonly vendor: string;
-                        readonly types?: {
-                            readonly input: any;
-                            readonly output: any;
-                        } | undefined;
-                    };
-                    _parse: {};
-                    _getType: {};
-                    _getOrReturnCtx: {};
-                    _processInputParams: {};
-                    _parseSync: {};
-                    _parseAsync: {};
-                    parse: {};
-                    safeParse: {};
-                    parseAsync: {};
-                    safeParseAsync: {};
-                    spa: {};
-                    refine: {};
-                    refinement: {};
-                    _refinement: {};
-                    superRefine: {};
-                    or: {};
-                    and: {};
-                    transform: {};
-                    brand: {};
-                    describe: {};
-                    pipe: {};
-                };
-                output: {
-                    readonly _type: any;
-                    readonly _output: any;
-                    readonly _input: any;
-                    readonly _def: {
-                        errorMap?: {} | undefined;
-                        description?: string | undefined | undefined;
-                    };
-                    readonly description: string | undefined;
-                    "~standard": {
-                        readonly version: 1;
-                        readonly vendor: string;
-                        readonly types?: {
-                            readonly input: any;
-                            readonly output: any;
-                        } | undefined;
-                    };
-                    _parse: {};
-                    _getType: {};
-                    _getOrReturnCtx: {};
-                    _processInputParams: {};
-                    _parseSync: {};
-                    _parseAsync: {};
-                    parse: {};
-                    safeParse: {};
-                    parseAsync: {};
-                    safeParseAsync: {};
-                    spa: {};
-                    refine: {};
-                    refinement: {};
-                    _refinement: {};
-                    superRefine: {};
-                    or: {};
-                    and: {};
-                    transform: {};
-                    brand: {};
-                    describe: {};
-                    pipe: {};
-                };
-            } | undefined;
-        };
-        readonly type: "agent" | {
-            input: {
-                readonly _type: any;
-                readonly _output: any;
-                readonly _input: any;
-                readonly _def: {
-                    errorMap?: {} | undefined;
-                    description?: string | undefined | undefined;
-                };
-                readonly description: string | undefined;
-                "~standard": {
-                    readonly version: 1;
-                    readonly vendor: string;
-                    readonly types?: {
-                        readonly input: any;
-                        readonly output: any;
-                    } | undefined;
-                };
-                _parse: {};
-                _getType: {};
-                _getOrReturnCtx: {};
-                _processInputParams: {};
-                _parseSync: {};
-                _parseAsync: {};
-                parse: {};
-                safeParse: {};
-                parseAsync: {};
-                safeParseAsync: {};
-                spa: {};
-                refine: {};
-                refinement: {};
-                _refinement: {};
-                superRefine: {};
-                or: {};
-                and: {};
-                transform: {};
-                brand: {};
-                describe: {};
-                pipe: {};
-            };
-            output: {
-                readonly _type: any;
-                readonly _output: any;
-                readonly _input: any;
-                readonly _def: {
-                    errorMap?: {} | undefined;
-                    description?: string | undefined | undefined;
-                };
-                readonly description: string | undefined;
-                "~standard": {
-                    readonly version: 1;
-                    readonly vendor: string;
-                    readonly types?: {
-                        readonly input: any;
-                        readonly output: any;
-                    } | undefined;
-                };
-                _parse: {};
-                _getType: {};
-                _getOrReturnCtx: {};
-                _processInputParams: {};
-                _parseSync: {};
-                _parseAsync: {};
-                parse: {};
-                safeParse: {};
-                parseAsync: {};
-                safeParseAsync: {};
-                spa: {};
-                refine: {};
-                refinement: {};
-                _refinement: {};
-                superRefine: {};
-                or: {};
-                and: {};
-                transform: {};
-                brand: {};
-                describe: {};
-                pipe: {};
-            };
-        } | undefined;
-        readonly name: any;
-        readonly description: string;
-        readonly judge: {
-            model: import("@mastra/core/llm/model").ModelRouterModelId | {
-                readonly specificationVersion: "v1";
-                readonly provider: string;
-                readonly modelId: string;
-                readonly defaultObjectGenerationMode: "tool" | "json" | undefined;
-                readonly supportsImageUrls?: boolean | undefined;
-                readonly supportsStructuredOutputs?: boolean | undefined;
-                supportsUrl?: {} | undefined;
-                doGenerate: {};
-                doStream: {};
-            } | {
-                readonly specificationVersion: "v2";
-                readonly provider: string;
-                readonly modelId: string;
-                supportedUrls: {
-                    [x: string]: {
-                        exec: {};
-                        test: {};
-                        readonly source: string;
-                        readonly global: boolean;
-                        readonly ignoreCase: boolean;
-                        readonly multiline: boolean;
-                        lastIndex: number;
-                        compile: {};
-                        readonly flags: string;
-                        readonly sticky: boolean;
-                        readonly unicode: boolean;
-                        readonly dotAll: boolean;
-                        readonly hasIndices: boolean;
-                    }[];
-                } | {
-                    then: {};
-                };
-                doGenerate: {};
-                doStream: {};
-            } | {
-                id: `${string}/${string}`;
-                url?: string | undefined;
-                apiKey?: string | undefined;
-                headers?: {
-                    [x: string]: string;
-                } | undefined;
-            } | {
-                providerId: string;
-                modelId: string;
-                url?: string | undefined;
-                apiKey?: string | undefined;
-                headers?: {
-                    [x: string]: string;
-                } | undefined;
-            };
-            instructions: string;
-        } | undefined;
-        preprocess: {};
-        analyze: {};
-        generateScore: {};
-        generateReason: {};
-        run: {};
-    };
-    sampling?: {
-        type: "none";
-    } | {
-        type: "ratio";
-        rate: number;
-    } | undefined;
-    agentIds: string[];
-    agentNames: string[];
-    workflowIds: string[];
-    isRegistered: boolean;
-} | null, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
-export declare function getScoresByRunIdHandler(c: Context): Promise<Response>;
-export declare function getScoresByScorerIdHandler(c: Context): Promise<Response>;
-export declare function getScoresByEntityIdHandler(c: Context): Promise<Response>;
-export declare function saveScoreHandler(c: Context): Promise<Response>;
-//# sourceMappingURL=handlers.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../../../src/server/handlers/routes/scores/handlers.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAGpC,wBAAsB,iBAAiB,CAAC,CAAC,EAAE,OAAO,qBAUjD;AAED,wBAAsB,gBAAgB,CAAC,CAAC,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAYhD;AAED,wBAAsB,uBAAuB,CAAC,CAAC,EAAE,OAAO,qBAkBvD;AAED,wBAAsB,0BAA0B,CAAC,CAAC,EAAE,OAAO,qBAsB1D;AAED,wBAAsB,0BAA0B,CAAC,CAAC,EAAE,OAAO,qBAqB1D;AAED,wBAAsB,gBAAgB,CAAC,CAAC,EAAE,OAAO,qBAchD"}

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

@@ -1,4 +0,0 @@
-import { Hono } from 'hono';
-import type { BodyLimitOptions } from '../../../types.js';
-export declare function scoresRouter(bodyLimitOptions: BodyLimitOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-//# sourceMappingURL=router.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../../../../src/server/handlers/routes/scores/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAG5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAUvD,wBAAgB,YAAY,CAAC,gBAAgB,EAAE,gBAAgB,8EAmM9D"}

package/dist/server/handlers/routes/telemetry/handlers.d.ts

@@ -1,4 +0,0 @@
-import type { Context } from 'hono';
-export declare function getTelemetryHandler(c: Context): Promise<Response>;
-export declare function storeTelemetryHandler(c: Context): Promise<Response>;
-//# sourceMappingURL=handlers.d.ts.map

package/dist/server/handlers/routes/telemetry/handlers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../../../src/server/handlers/routes/telemetry/handlers.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC,wBAAsB,mBAAmB,CAAC,CAAC,EAAE,OAAO,qBAuBnD;AAED,wBAAsB,qBAAqB,CAAC,CAAC,EAAE,OAAO,qBAgBrD"}

package/dist/server/handlers/routes/telemetry/router.d.ts

@@ -1,3 +0,0 @@
-import { Hono } from 'hono';
-export declare function telemetryRouter(): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-//# sourceMappingURL=router.d.ts.map

package/dist/server/handlers/routes/telemetry/router.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../../../../src/server/handlers/routes/telemetry/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAI5B,wBAAgB,eAAe,+EAgC9B"}

package/dist/server/handlers/routes/tools/handlers.d.ts

@@ -1,7 +0,0 @@
-import type { Context } from 'hono';
-export declare function getToolsHandler(c: Context): Promise<Response>;
-export declare function getToolByIdHandler(c: Context): Promise<Response>;
-export declare function executeToolHandler(tools: Record<string, any>): (c: Context) => Promise<Response>;
-export declare function getAgentToolHandler(c: Context): Promise<Response>;
-export declare function executeAgentToolHandler(c: Context): Promise<Response>;
-//# sourceMappingURL=handlers.d.ts.map

package/dist/server/handlers/routes/tools/handlers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../../../src/server/handlers/routes/tools/handlers.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAKpC,wBAAsB,eAAe,CAAC,CAAC,EAAE,OAAO,qBAY/C;AAED,wBAAsB,kBAAkB,CAAC,CAAC,EAAE,OAAO,qBAclD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAC7C,GAAG,OAAO,uBAqBzB;AAED,wBAAsB,mBAAmB,CAAC,CAAC,EAAE,OAAO,qBAkBnD;AAED,wBAAsB,uBAAuB,CAAC,CAAC,EAAE,OAAO,qBAoBvD"}

package/dist/server/handlers/routes/tools/router.d.ts

@@ -1,4 +0,0 @@
-import { Hono } from 'hono';
-import type { BodyLimitOptions } from '../../../types.js';
-export declare function toolsRouter(bodyLimitOptions: BodyLimitOptions, tools: Record<string, any>): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-//# sourceMappingURL=router.d.ts.map

package/dist/server/handlers/routes/tools/router.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../../../../src/server/handlers/routes/tools/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAG5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGvD,wBAAgB,WAAW,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,8EA0FzF"}

package/dist/server/handlers/routes/vector/handlers.d.ts

@@ -1,10 +0,0 @@
-import type { MastraVector } from '@mastra/core/vector';
-import type { Context } from 'hono';
-export declare const getVector: (c: Context, vectorName: string) => MastraVector;
-export declare function upsertVectors(c: Context): Promise<Response>;
-export declare function createIndex(c: Context): Promise<Response>;
-export declare function queryVectors(c: Context): Promise<Response>;
-export declare function listIndexes(c: Context): Promise<Response>;
-export declare function describeIndex(c: Context): Promise<Response>;
-export declare function deleteIndex(c: Context): Promise<Response>;
-//# sourceMappingURL=handlers.d.ts.map

package/dist/server/handlers/routes/vector/handlers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../../../src/server/handlers/routes/vector/handlers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,qBAAqB,CAAC;AASrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AA2BpC,eAAO,MAAM,SAAS,GAAI,GAAG,OAAO,EAAE,YAAY,MAAM,KAAG,YAM1D,CAAC;AAGF,wBAAsB,aAAa,CAAC,CAAC,EAAE,OAAO,qBAgB7C;AAGD,wBAAsB,WAAW,CAAC,CAAC,EAAE,OAAO,qBAgB3C;AAGD,wBAAsB,YAAY,CAAC,CAAC,EAAE,OAAO,qBAgB5C;AAGD,wBAAsB,WAAW,CAAC,CAAC,EAAE,OAAO,qBAc3C;AAGD,wBAAsB,aAAa,CAAC,CAAC,EAAE,OAAO,qBAwB7C;AAGD,wBAAsB,WAAW,CAAC,CAAC,EAAE,OAAO,qBAoB3C"}

package/dist/server/handlers/routes/vector/router.d.ts

@@ -1,4 +0,0 @@
-import { Hono } from 'hono';
-import type { BodyLimitOptions } from '../../../types.js';
-export declare function vectorRouter(bodyLimitOptions: BodyLimitOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-//# sourceMappingURL=router.d.ts.map

package/dist/server/handlers/routes/vector/router.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../../../../src/server/handlers/routes/vector/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAG5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGvD,wBAAgB,YAAY,CAAC,gBAAgB,EAAE,gBAAgB,8EA4N9D"}

package/dist/server/handlers/routes/workflows/handlers.d.ts

@@ -1,20 +0,0 @@
-import type { Context } from 'hono';
-export declare function getWorkflowsHandler(c: Context): Promise<Response>;
-export declare function getWorkflowByIdHandler(c: Context): Promise<Response>;
-export declare function createWorkflowRunHandler(c: Context): Promise<Response>;
-export declare function startAsyncWorkflowHandler(c: Context): Promise<Response>;
-export declare function startWorkflowRunHandler(c: Context): Promise<Response>;
-export declare function watchWorkflowHandler(c: Context): Response | Promise<Response>;
-export declare function streamWorkflowHandler(c: Context): Promise<Response>;
-export declare function observeStreamWorkflowHandler(c: Context): Promise<Response>;
-export declare function streamVNextWorkflowHandler(c: Context): Promise<Response>;
-export declare function observeStreamVNextWorkflowHandler(c: Context): Promise<Response>;
-export declare function resumeStreamWorkflowHandler(c: Context): Promise<Response>;
-export declare function resumeAsyncWorkflowHandler(c: Context): Promise<Response>;
-export declare function resumeWorkflowHandler(c: Context): Promise<Response>;
-export declare function getWorkflowRunsHandler(c: Context): Promise<Response>;
-export declare function getWorkflowRunByIdHandler(c: Context): Promise<Response>;
-export declare function getWorkflowRunExecutionResultHandler(c: Context): Promise<Response>;
-export declare function cancelWorkflowRunHandler(c: Context): Promise<Response>;
-export declare function sendWorkflowRunEventHandler(c: Context): Promise<Response>;
-//# sourceMappingURL=handlers.d.ts.map

package/dist/server/handlers/routes/workflows/handlers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../../../src/server/handlers/routes/workflows/handlers.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAMpC,wBAAsB,mBAAmB,CAAC,CAAC,EAAE,OAAO,qBAYnD;AAED,wBAAsB,sBAAsB,CAAC,CAAC,EAAE,OAAO,qBActD;AAED,wBAAsB,wBAAwB,CAAC,CAAC,EAAE,OAAO,qBAgBxD;AAED,wBAAsB,yBAAyB,CAAC,CAAC,EAAE,OAAO,qBAqBzD;AAED,wBAAsB,uBAAuB,CAAC,CAAC,EAAE,OAAO,qBAqBvD;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,OAAO,gCA4C9C;AAED,wBAAsB,qBAAqB,CAAC,CAAC,EAAE,OAAO,qBA8CrD;AAED,wBAAsB,4BAA4B,CAAC,CAAC,EAAE,OAAO,qBA6C5D;AAED,wBAAsB,0BAA0B,CAAC,CAAC,EAAE,OAAO,qBA8C1D;AAED,wBAAsB,iCAAiC,CAAC,CAAC,EAAE,OAAO,qBAwCjE;AAED,wBAAsB,2BAA2B,CAAC,CAAC,EAAE,OAAO,qBA6C3D;AAED,wBAAsB,0BAA0B,CAAC,CAAC,EAAE,OAAO,qBAyB1D;AAED,wBAAsB,qBAAqB,CAAC,CAAC,EAAE,OAAO,qBAyBrD;AAED,wBAAsB,sBAAsB,CAAC,CAAC,EAAE,OAAO,qBAmBtD;AAED,wBAAsB,yBAAyB,CAAC,CAAC,EAAE,OAAO,qBAezD;AAED,wBAAsB,oCAAoC,CAAC,CAAC,EAAE,OAAO,qBAepE;AAED,wBAAsB,wBAAwB,CAAC,CAAC,EAAE,OAAO,qBAgBxD;AAED,wBAAsB,2BAA2B,CAAC,CAAC,EAAE,OAAO,qBAmB3D"}

package/dist/server/handlers/routes/workflows/legacyWorkflows.d.ts

@@ -1,11 +0,0 @@
-import type { Context } from 'hono';
-export declare function getLegacyWorkflowsHandler(c: Context): Promise<Response>;
-export declare function getLegacyWorkflowByIdHandler(c: Context): Promise<Response>;
-export declare function startAsyncLegacyWorkflowHandler(c: Context): Promise<Response>;
-export declare function createLegacyWorkflowRunHandler(c: Context): Promise<Response>;
-export declare function startLegacyWorkflowRunHandler(c: Context): Promise<Response>;
-export declare function watchLegacyWorkflowHandler(c: Context): Response | Promise<Response>;
-export declare function resumeAsyncLegacyWorkflowHandler(c: Context): Promise<Response>;
-export declare function resumeLegacyWorkflowHandler(c: Context): Promise<Response>;
-export declare function getLegacyWorkflowRunsHandler(c: Context): Promise<Response>;
-//# sourceMappingURL=legacyWorkflows.d.ts.map

package/dist/server/handlers/routes/workflows/legacyWorkflows.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacyWorkflows.d.ts","sourceRoot":"","sources":["../../../../../src/server/handlers/routes/workflows/legacyWorkflows.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAMpC,wBAAsB,yBAAyB,CAAC,CAAC,EAAE,OAAO,qBAYzD;AAED,wBAAsB,4BAA4B,CAAC,CAAC,EAAE,OAAO,qBAc5D;AAED,wBAAsB,+BAA+B,CAAC,CAAC,EAAE,OAAO,qBAoB/D;AAED,wBAAsB,8BAA8B,CAAC,CAAC,EAAE,OAAO,qBAgB9D;AAED,wBAAsB,6BAA6B,CAAC,CAAC,EAAE,OAAO,qBAoB7D;AAED,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,OAAO,gCAwCpD;AAED,wBAAsB,gCAAgC,CAAC,CAAC,EAAE,OAAO,qBAwBhE;AAED,wBAAsB,2BAA2B,CAAC,CAAC,EAAE,OAAO,qBAwB3D;AAED,wBAAsB,4BAA4B,CAAC,CAAC,EAAE,OAAO,qBAmB5D"}

package/dist/server/handlers/routes/workflows/router.d.ts

@@ -1,4 +0,0 @@
-import { Hono } from 'hono';
-import type { BodyLimitOptions } from '../../../types.js';
-export declare function workflowsRouter(bodyLimitOptions: BodyLimitOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-//# sourceMappingURL=router.d.ts.map

package/dist/server/handlers/routes/workflows/router.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../../../../src/server/handlers/routes/workflows/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAG5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAiCvD,wBAAgB,eAAe,CAAC,gBAAgB,EAAE,gBAAgB,8EAi/BjE"}

package/dist/templates/instrumentation-template.js

@@ -1,172 +0,0 @@
-import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
-import { ExportResultCode } from '@opentelemetry/core';
-import { OTLPTraceExporter as OTLPGrpcExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
-import { OTLPTraceExporter as OTLPHttpExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { resourceFromAttributes } from '@opentelemetry/resources';
-import { NodeSDK } from '@opentelemetry/sdk-node';
-import {
-  ParentBasedSampler,
-  TraceIdRatioBasedSampler,
-  AlwaysOnSampler,
-  AlwaysOffSampler,
-} from '@opentelemetry/sdk-trace-base';
-import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-import { telemetry } from './telemetry-config.mjs';
-
-globalThis.___MASTRA_TELEMETRY___ = true;
-
-function parseHeaders(headerString) {
-  const headers = {}
-  if (!headerString) return headers;
-
-  const headersStringPairs = headerString.split(',');
-  for (const pair of headersStringPairs) {
-    const [key, value] = pair.split('=').map(s => s.trim());
-    if (key && value) headers[key] = value;
-  }
-
-  return headers;
-}
-
-class CompositeExporter {
-  constructor(exporters) {
-    this.exporters = exporters;
-  }
-  export(spans, resultCallback) {
-    const telemetryTraceIds = new Set(
-      spans.filter((span) => {
-        const attrs = span.attributes || {};
-        const httpTarget = attrs["http.target"];
-        return httpTarget === "/api/telemetry";
-      }).map((span) => span.spanContext().traceId)
-    );
-
-    const filteredSpans = spans.filter((span) => {
-      // instrumentation-http spans are the root spans for a trace.
-      // Other @opentelemetry spans are noisy and we do not display them.
-      // At the storage layer, we remove the HTTP instrumentation spans entirely.
-      // And promote their direct children to root spans.
-      return !(span.instrumentationScope?.name?.startsWith('@opentelemetry') &&
-      span.instrumentationScope?.name !== '@opentelemetry/instrumentation-http') &&
-       !telemetryTraceIds.has(span.spanContext().traceId)
-    });
-
-    if (filteredSpans.length === 0) {
-      resultCallback({ code: ExportResultCode.SUCCESS });
-      return;
-    }
-    void Promise.all(
-      this.exporters.map(
-        (exporter) => new Promise((resolve) => {
-          if (exporter.export) {
-            exporter.export(filteredSpans, resolve);
-          } else {
-            resolve({ code: ExportResultCode.FAILED });
-          }
-        })
-      )
-    ).then((results) => {
-      const hasError = results.some((r) => r.code === ExportResultCode.FAILED);
-      resultCallback({
-        code: hasError ? ExportResultCode.FAILED : ExportResultCode.SUCCESS
-      });
-    }).catch((error) => {
-      console.error("[CompositeExporter] Export error:", error);
-      resultCallback({ code: ExportResultCode.FAILED, error });
-    });
-  }
-  shutdown() {
-    return Promise.all(this.exporters.map((e) => e.shutdown?.() ?? Promise.resolve())).then(() => void 0);
-  }
-  forceFlush() {
-    return Promise.all(this.exporters.map((e) => e.forceFlush?.() ?? Promise.resolve())).then(() => void 0);
-  }
-};
-
-function getSampler(config) {
-  if (!config.sampling) {
-    return new AlwaysOnSampler();
-  }
-
-  if (!config.enabled) {
-    return new AlwaysOffSampler();
-  }
-
-  switch (config.sampling.type) {
-    case 'ratio':
-      return new TraceIdRatioBasedSampler(config.sampling.probability);
-    case 'always_on':
-      return new AlwaysOnSampler();
-    case 'always_off':
-      return new AlwaysOffSampler();
-    case 'parent_based':
-      const rootSampler = new TraceIdRatioBasedSampler(config.sampling.root?.probability || 1.0);
-      return new ParentBasedSampler({ root: rootSampler });
-    default:
-      return new AlwaysOnSampler();
-  }
-}
-
-async function getExporters(config) {
-  const exporters = [];
-
-  // Add local exporter by default
-  if (!config.disableLocalExport) {
-    exporters.push(new OTLPHttpExporter({
-      url: `http://localhost:${process.env.PORT ?? 4111}/api/telemetry`,
-      headers: process.env.MASTRA_DEV ? {
-        'x-mastra-dev-playground': 'true',
-      } : {},
-    }));
-  }
-
-  if (config.export?.type === 'otlp') {
-    if (config.export?.protocol === 'grpc') {
-      exporters.push(new OTLPGrpcExporter({
-        url: config.export.endpoint,
-        headers: config.export.headers,
-      }));
-    } else {
-      const exporterEndpoint = config.export.endpoint ?? process.env.OTEL_EXPORTER_OTLP_ENDPOINT
-      let exporterHeaders = config.export.headers
-      if (!exporterHeaders) {
-        exporterHeaders = parseHeaders(process.env.OTEL_EXPORTER_OTLP_HEADERS)
-      }
-
-      exporters.push(new OTLPHttpExporter({
-        url: exporterEndpoint,
-        headers: exporterHeaders,
-      }));
-    }
-  } else if (config.export?.type === 'custom') {
-    exporters.push(config.export.exporter);
-  }
-
-  return exporters
-}
-
-const sampler = getSampler(telemetry);
-const exporters = await getExporters(telemetry);
-const compositeExporter = new CompositeExporter(exporters);
-
-const sdk = new NodeSDK({
-  resource: resourceFromAttributes({
-    [ATTR_SERVICE_NAME]: telemetry.serviceName || 'default-service',
-  }),
-  sampler,
-  traceExporter: compositeExporter,
-  instrumentations: [getNodeAutoInstrumentations()],
-});
-
-if (telemetry.enabled !== false) {
-  sdk.start();
-
-  // gracefully shut down the SDK on process exit
-  process.on('SIGTERM', () => {
-    sdk.shutdown().catch(() => {
-      // do nothing
-    });
-  });
-}
-
-