@mastra/code-sdk 1.2.0-alpha.17 → 1.2.0-alpha.18

package/dist/tools/workflows/save-workflow.d.ts

@@ -0,0 +1,369 @@
+import { z } from 'zod';
+export { WORKFLOW_BUILDER_MAPPING_CONFIG_DESCRIPTION as MAPPING_CONFIG_DESCRIPTION } from '@mastra/core/workflows/builder';
+export declare const workflowDefinitionInputSchema: z.ZodPreprocess<z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    inputSchema: z.ZodUnknown;
+    outputSchema: z.ZodUnknown;
+    stateSchema: z.ZodOptional<z.ZodUnknown>;
+    requestContextSchema: z.ZodOptional<z.ZodUnknown>;
+    graph: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"agent">;
+        id: z.ZodString;
+        agentId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        outputSchema: z.ZodOptional<z.ZodUnknown>;
+        options: z.ZodOptional<z.ZodObject<{
+            retries: z.ZodOptional<z.ZodNumber>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"tool">;
+        id: z.ZodString;
+        toolId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodObject<{
+            retries: z.ZodOptional<z.ZodNumber>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"mapping">;
+        id: z.ZodString;
+        mapConfig: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"workflow">;
+        id: z.ZodString;
+        workflowId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodObject<{
+            retries: z.ZodOptional<z.ZodNumber>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"parallel">;
+        steps: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"agent">;
+            id: z.ZodString;
+            agentId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            outputSchema: z.ZodOptional<z.ZodUnknown>;
+            options: z.ZodOptional<z.ZodObject<{
+                retries: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"tool">;
+            id: z.ZodString;
+            toolId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodObject<{
+                retries: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"workflow">;
+            id: z.ZodString;
+            workflowId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodObject<{
+                retries: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"foreach">;
+        step: z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"agent">;
+            id: z.ZodString;
+            agentId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            outputSchema: z.ZodOptional<z.ZodUnknown>;
+            options: z.ZodOptional<z.ZodObject<{
+                retries: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"tool">;
+            id: z.ZodString;
+            toolId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodObject<{
+                retries: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"workflow">;
+            id: z.ZodString;
+            workflowId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodObject<{
+                retries: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>]>;
+        opts: z.ZodOptional<z.ZodObject<{
+            concurrency: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"sleep">;
+        id: z.ZodString;
+        duration: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"sleepUntil">;
+        id: z.ZodString;
+        date: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"conditional">;
+        steps: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"agent">;
+            id: z.ZodString;
+            agentId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            outputSchema: z.ZodOptional<z.ZodUnknown>;
+            options: z.ZodOptional<z.ZodObject<{
+                retries: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"tool">;
+            id: z.ZodString;
+            toolId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodObject<{
+                retries: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"workflow">;
+            id: z.ZodString;
+            workflowId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodObject<{
+                retries: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>]>>;
+        predicates: z.ZodArray<z.ZodType<import("@mastra/core/workflows").Predicate, unknown, z.core.$ZodTypeInternals<import("@mastra/core/workflows").Predicate, unknown>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"loop">;
+        step: z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"agent">;
+            id: z.ZodString;
+            agentId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            outputSchema: z.ZodOptional<z.ZodUnknown>;
+            options: z.ZodOptional<z.ZodObject<{
+                retries: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"tool">;
+            id: z.ZodString;
+            toolId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodObject<{
+                retries: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"workflow">;
+            id: z.ZodString;
+            workflowId: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodObject<{
+                retries: z.ZodOptional<z.ZodNumber>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>]>;
+        loopType: z.ZodEnum<{
+            dowhile: "dowhile";
+            dountil: "dountil";
+        }>;
+        predicate: z.ZodType<import("@mastra/core/workflows").Predicate, unknown, z.core.$ZodTypeInternals<import("@mastra/core/workflows").Predicate, unknown>>;
+    }, z.core.$strict>], "type">>;
+}, z.core.$strict>>;
+export declare const saveWorkflowTool: import("@mastra/core/tools").Tool<{
+    id: string;
+    inputSchema: unknown;
+    outputSchema: unknown;
+    graph: ({
+        type: "agent";
+        id: string;
+        agentId: string;
+        description?: string | undefined;
+        outputSchema?: unknown;
+        options?: {
+            retries?: number | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | {
+        type: "tool";
+        id: string;
+        toolId: string;
+        description?: string | undefined;
+        options?: {
+            retries?: number | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | {
+        type: "mapping";
+        id: string;
+        mapConfig: string;
+    } | {
+        type: "workflow";
+        id: string;
+        workflowId: string;
+        description?: string | undefined;
+        options?: {
+            retries?: number | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | {
+        type: "parallel";
+        steps: ({
+            type: "agent";
+            id: string;
+            agentId: string;
+            description?: string | undefined;
+            outputSchema?: unknown;
+            options?: {
+                retries?: number | undefined;
+                metadata?: Record<string, unknown> | undefined;
+            } | undefined;
+        } | {
+            type: "tool";
+            id: string;
+            toolId: string;
+            description?: string | undefined;
+            options?: {
+                retries?: number | undefined;
+                metadata?: Record<string, unknown> | undefined;
+            } | undefined;
+        } | {
+            type: "workflow";
+            id: string;
+            workflowId: string;
+            description?: string | undefined;
+            options?: {
+                retries?: number | undefined;
+                metadata?: Record<string, unknown> | undefined;
+            } | undefined;
+        })[];
+    } | {
+        type: "foreach";
+        step: {
+            type: "agent";
+            id: string;
+            agentId: string;
+            description?: string | undefined;
+            outputSchema?: unknown;
+            options?: {
+                retries?: number | undefined;
+                metadata?: Record<string, unknown> | undefined;
+            } | undefined;
+        } | {
+            type: "tool";
+            id: string;
+            toolId: string;
+            description?: string | undefined;
+            options?: {
+                retries?: number | undefined;
+                metadata?: Record<string, unknown> | undefined;
+            } | undefined;
+        } | {
+            type: "workflow";
+            id: string;
+            workflowId: string;
+            description?: string | undefined;
+            options?: {
+                retries?: number | undefined;
+                metadata?: Record<string, unknown> | undefined;
+            } | undefined;
+        };
+        opts?: {
+            concurrency: number;
+        } | undefined;
+    } | {
+        type: "sleep";
+        id: string;
+        duration: number;
+    } | {
+        type: "sleepUntil";
+        id: string;
+        date: string;
+    } | {
+        type: "conditional";
+        steps: ({
+            type: "agent";
+            id: string;
+            agentId: string;
+            description?: string | undefined;
+            outputSchema?: unknown;
+            options?: {
+                retries?: number | undefined;
+                metadata?: Record<string, unknown> | undefined;
+            } | undefined;
+        } | {
+            type: "tool";
+            id: string;
+            toolId: string;
+            description?: string | undefined;
+            options?: {
+                retries?: number | undefined;
+                metadata?: Record<string, unknown> | undefined;
+            } | undefined;
+        } | {
+            type: "workflow";
+            id: string;
+            workflowId: string;
+            description?: string | undefined;
+            options?: {
+                retries?: number | undefined;
+                metadata?: Record<string, unknown> | undefined;
+            } | undefined;
+        })[];
+        predicates: import("@mastra/core/workflows").Predicate[];
+    } | {
+        type: "loop";
+        step: {
+            type: "agent";
+            id: string;
+            agentId: string;
+            description?: string | undefined;
+            outputSchema?: unknown;
+            options?: {
+                retries?: number | undefined;
+                metadata?: Record<string, unknown> | undefined;
+            } | undefined;
+        } | {
+            type: "tool";
+            id: string;
+            toolId: string;
+            description?: string | undefined;
+            options?: {
+                retries?: number | undefined;
+                metadata?: Record<string, unknown> | undefined;
+            } | undefined;
+        } | {
+            type: "workflow";
+            id: string;
+            workflowId: string;
+            description?: string | undefined;
+            options?: {
+                retries?: number | undefined;
+                metadata?: Record<string, unknown> | undefined;
+            } | undefined;
+        };
+        loopType: "dowhile" | "dountil";
+        predicate: import("@mastra/core/workflows").Predicate;
+    })[];
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    stateSchema?: unknown;
+    requestContextSchema?: unknown;
+}, {
+    ok: true;
+    id: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "save-workflow", unknown>;
+//# sourceMappingURL=save-workflow.d.ts.map

package/dist/tools/workflows/save-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"save-workflow.d.ts","sourceRoot":"","sources":["../../../src/tools/workflows/save-workflow.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,2CAA2C,IAAI,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAE3H,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAGzC,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4HAsB3B,CAAC"}

package/dist/tools/workflows/save-workflow.js

@@ -0,0 +1,28 @@
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+import { WORKFLOW_BUILDER_MAPPING_CONFIG_DESCRIPTION as MAPPING_CONFIG_DESCRIPTION, normalizeWorkflowBuilderDefinition, workflowBuilderDefinitionSchema } from "@mastra/core/workflows/builder";
+//#region src/tools/workflows/save-workflow.ts
+const workflowDefinitionInputSchema = z.preprocess(normalizeWorkflowBuilderDefinition, workflowBuilderDefinitionSchema);
+const saveWorkflowTool = createTool({
+	id: "save-workflow",
+	description: "Persist a Dynamic Workflow definition and live-register it on the running Mastra instance. Supports all ten persisted graph families: agent, tool, mapping, nested workflow, parallel, foreach, sleep, sleepUntil, conditional, and loop. Conditional and loop entries require declarative predicates; JS closures cannot round-trip through storage. After this returns, the workflow is immediately runnable. Call it exactly once with the complete definition; there is no incremental save API.",
+	inputSchema: workflowDefinitionInputSchema,
+	outputSchema: z.object({
+		ok: z.literal(true),
+		id: z.string()
+	}),
+	execute: async (def, { mastra }) => {
+		if (!mastra) throw new Error("save-workflow requires a Mastra context.");
+		const m = mastra;
+		const normalizedDefinition = normalizeWorkflowBuilderDefinition(def);
+		await m.addDynamicWorkflow(normalizedDefinition);
+		return {
+			ok: true,
+			id: normalizedDefinition.id
+		};
+	}
+});
+//#endregion
+export { MAPPING_CONFIG_DESCRIPTION, saveWorkflowTool, workflowDefinitionInputSchema };
+
+//# sourceMappingURL=save-workflow.js.map

package/dist/tools/workflows/save-workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"save-workflow.js","names":[],"sources":["../../../src/tools/workflows/save-workflow.ts"],"sourcesContent":["/**\n * Sub-agent tool: persist the Dynamic Workflow definition and live-register it.\n * Calls `mastra.addDynamicWorkflow()`. After this returns the workflow is\n * immediately runnable.\n *\n * The complete-definition authoring contract (graph families, mapping sources,\n * predicate DSL, and all model-facing guidance) is shared with Studio's\n * `submit-workflow-draft` and lives in `@mastra/core/workflows/builder`.\n */\nimport type { Mastra } from '@mastra/core/mastra';\nimport { createTool } from '@mastra/core/tools';\nimport { normalizeWorkflowBuilderDefinition, workflowBuilderDefinitionSchema } from '@mastra/core/workflows/builder';\nimport { z } from 'zod';\n\nexport { WORKFLOW_BUILDER_MAPPING_CONFIG_DESCRIPTION as MAPPING_CONFIG_DESCRIPTION } from '@mastra/core/workflows/builder';\n\nexport const workflowDefinitionInputSchema = z.preprocess(\n  normalizeWorkflowBuilderDefinition,\n  workflowBuilderDefinitionSchema,\n);\n\nexport const saveWorkflowTool = createTool({\n  id: 'save-workflow',\n  description:\n    'Persist a Dynamic Workflow definition and live-register it on the running Mastra instance. Supports all ten persisted graph families: agent, tool, mapping, nested workflow, parallel, foreach, sleep, sleepUntil, conditional, and loop. Conditional and loop entries require declarative predicates; JS closures cannot round-trip through storage. After this returns, the workflow is immediately runnable. Call it exactly once with the complete definition; there is no incremental save API.',\n  inputSchema: workflowDefinitionInputSchema,\n  outputSchema: z.object({\n    ok: z.literal(true),\n    id: z.string(),\n  }),\n  execute: async (def, { mastra }) => {\n    if (!mastra) throw new Error('save-workflow requires a Mastra context.');\n    const m = mastra as Mastra;\n    const normalizedDefinition = normalizeWorkflowBuilderDefinition(def);\n\n    // `mastra.addDynamicWorkflow` performs registry pre-flight — a mis-classified\n    // agentId/toolId or unregistered id throws before rehydration with an\n    // actionable message listing every offender. It also rejects JSON Schemas\n    // that use keywords the storage-side converter can't rehydrate\n    // (oneOf/anyOf/allOf/not/$ref/patternProperties/discriminator).\n    await m.addDynamicWorkflow(normalizedDefinition as Parameters<Mastra['addDynamicWorkflow']>[0]);\n    return { ok: true as const, id: normalizedDefinition.id };\n  },\n});\n"],"mappings":";;;;AAgBA,MAAa,gCAAgC,EAAE,WAC7C,oCACA,+BACF;AAEA,MAAa,mBAAmB,WAAW;CACzC,IAAI;CACJ,aACE;CACF,aAAa;CACb,cAAc,EAAE,OAAO;EACrB,IAAI,EAAE,QAAQ,IAAI;EAClB,IAAI,EAAE,OAAO;CACf,CAAC;CACD,SAAS,OAAO,KAAK,EAAE,aAAa;EAClC,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,0CAA0C;EACvE,MAAM,IAAI;EACV,MAAM,uBAAuB,mCAAmC,GAAG;EAOnE,MAAM,EAAE,mBAAmB,oBAAmE;EAC9F,OAAO;GAAE,IAAI;GAAe,IAAI,qBAAqB;EAAG;CAC1D;AACF,CAAC"}

package/dist/tools/workflows/tool-ids.d.ts

@@ -0,0 +1,15 @@
+export declare const WORKFLOW_AUTHORING_TOOL_IDS: {
+    readonly listAgents: "list-available-agents";
+    readonly listTools: "list-available-tools";
+    readonly listWorkflows: "list-available-workflows";
+    readonly saveWorkflow: "save-workflow";
+};
+export declare const WORKFLOW_MANAGEMENT_TOOL_IDS: {
+    readonly createWorkflow: "create-workflow";
+    readonly listWorkflows: "list-workflows";
+    readonly getWorkflow: "get-workflow";
+    readonly runWorkflow: "run-workflow";
+    readonly deleteWorkflow: "delete-workflow";
+};
+export declare const WORKFLOW_BUILDER_NOISE_TOOL_IDS: readonly ("create-workflow" | "delete-workflow" | "get-workflow" | "list-workflows" | "run-workflow" | "list-available-agents" | "list-available-tools" | "list-available-workflows" | "save-workflow")[];
+//# sourceMappingURL=tool-ids.d.ts.map

package/dist/tools/workflows/tool-ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-ids.d.ts","sourceRoot":"","sources":["../../../src/tools/workflows/tool-ids.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B;;;;;CAK9B,CAAC;AAEX,eAAO,MAAM,4BAA4B;;;;;;CAM/B,CAAC;AAEX,eAAO,MAAM,+BAA+B,2MAGlC,CAAC"}

package/dist/tools/workflows/tool-ids.js

@@ -0,0 +1,19 @@
+//#region src/tools/workflows/tool-ids.ts
+const WORKFLOW_AUTHORING_TOOL_IDS = {
+	listAgents: "list-available-agents",
+	listTools: "list-available-tools",
+	listWorkflows: "list-available-workflows",
+	saveWorkflow: "save-workflow"
+};
+const WORKFLOW_MANAGEMENT_TOOL_IDS = {
+	createWorkflow: "create-workflow",
+	listWorkflows: "list-workflows",
+	getWorkflow: "get-workflow",
+	runWorkflow: "run-workflow",
+	deleteWorkflow: "delete-workflow"
+};
+const WORKFLOW_BUILDER_NOISE_TOOL_IDS = [...Object.values(WORKFLOW_AUTHORING_TOOL_IDS), ...Object.values(WORKFLOW_MANAGEMENT_TOOL_IDS)];
+//#endregion
+export { WORKFLOW_AUTHORING_TOOL_IDS, WORKFLOW_BUILDER_NOISE_TOOL_IDS, WORKFLOW_MANAGEMENT_TOOL_IDS };
+
+//# sourceMappingURL=tool-ids.js.map

package/dist/tools/workflows/tool-ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-ids.js","names":[],"sources":["../../../src/tools/workflows/tool-ids.ts"],"sourcesContent":["export const WORKFLOW_AUTHORING_TOOL_IDS = {\n  listAgents: 'list-available-agents',\n  listTools: 'list-available-tools',\n  listWorkflows: 'list-available-workflows',\n  saveWorkflow: 'save-workflow',\n} as const;\n\nexport const WORKFLOW_MANAGEMENT_TOOL_IDS = {\n  createWorkflow: 'create-workflow',\n  listWorkflows: 'list-workflows',\n  getWorkflow: 'get-workflow',\n  runWorkflow: 'run-workflow',\n  deleteWorkflow: 'delete-workflow',\n} as const;\n\nexport const WORKFLOW_BUILDER_NOISE_TOOL_IDS = [\n  ...Object.values(WORKFLOW_AUTHORING_TOOL_IDS),\n  ...Object.values(WORKFLOW_MANAGEMENT_TOOL_IDS),\n] as const;\n"],"mappings":";AAAA,MAAa,8BAA8B;CACzC,YAAY;CACZ,WAAW;CACX,eAAe;CACf,cAAc;AAChB;AAEA,MAAa,+BAA+B;CAC1C,gBAAgB;CAChB,eAAe;CACf,aAAa;CACb,aAAa;CACb,gBAAgB;AAClB;AAEA,MAAa,kCAAkC,CAC7C,GAAG,OAAO,OAAO,2BAA2B,GAC5C,GAAG,OAAO,OAAO,4BAA4B,CAC/C"}

package/dist/workflows/register-primitives.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Statically register workflow-related primitives on the mastracode Mastra
+ * instance so `mastra.listTools()` + `mastra.listAgents()` — and, therefore,
+ * the workflow-builder's discovery + the workflow rehydrator — see everything
+ * a workflow might want to compose:
+ *
+ *   - workflow-builder sub-agent (so `create-workflow` can delegate)
+ *   - code-agent (as a plain agent, callable via agent steps)
+ *   - workspace tools (view/write/edit/find_files/execute_command/etc.)
+ *   - web tools (Tavily-gated) so workflows can compose search/extract steps
+ *   - notification_inbox
+ *   - snapshot of MCP tools from mcpManager
+ *
+ * Called after `controller.init()` but before `startWorkers()` in both boot
+ * paths, so `loadStoredWorkflows()` (inside startWorkers) sees the full
+ * registry when rehydrating previously-saved workflows.
+ *
+ * Tradeoffs:
+ *   - MCP tools are snapshotted. Servers added after boot are invisible to
+ *     the workflow-builder until restart.
+ *   - Web tool flavor is Tavily-only. Provider-native (Anthropic/OpenAI) web
+ *     tools are skipped because they'd freeze workflows to one model provider.
+ *   - Workflow tool steps get the closed-over workspace + auth (Tavily key,
+ *     MCP server credentials), not per-request permissions — deliberate; if
+ *     the user built + saved the workflow they meant to run it.
+ */
+import type { Agent } from '@mastra/core/agent';
+import type { Mastra } from '@mastra/core/mastra';
+import type { McpManager } from '../mcp/index.js';
+export interface RegisterWorkflowBuilderPrimitivesOptions {
+    projectPath: string;
+    /**
+     * Extra allowed paths the workspace can read/write. Mastracode normally
+     * collects skill paths + sandboxAllowedPaths per-request; for the workflow
+     * workspace we accept anything the caller wants up-front and trust the
+     * worker process to honour the user's intent.
+     */
+    allowedPaths?: string[];
+    /**
+     * The code-agent Agent instance. Registered as `code-agent` so workflows
+     * can compose it in agent steps. It already has full dynamic tool access
+     * (workspace/MCP/web/etc.) via its own `tools: createDynamicTools(...)`.
+     */
+    codeAgent: Agent;
+    /**
+     * McpManager for snapshotting MCP tools at boot. Omit or pass undefined
+     * if MCP is disabled — workflow-builder will just see fewer tools.
+     */
+    mcpManager?: McpManager;
+}
+export declare function registerWorkflowBuilderPrimitives(mastra: Mastra, options: RegisterWorkflowBuilderPrimitivesOptions): Promise<void>;
+//# sourceMappingURL=register-primitives.d.ts.map

package/dist/workflows/register-primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-primitives.d.ts","sourceRoot":"","sources":["../../src/workflows/register-primitives.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAMlD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAIzC,MAAM,WAAW,wCAAwC;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB;;;;OAIG;IACH,SAAS,EAAE,KAAK,CAAC;IACjB;;;OAGG;IACH,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB;AAED,wBAAsB,iCAAiC,CACrD,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wCAAwC,GAChD,OAAO,CAAC,IAAI,CAAC,CAiDf"}

package/dist/workflows/register-primitives.js

@@ -0,0 +1,39 @@
+import { createWebExtractTool, createWebSearchTool, hasTavilyKey } from "../tools/web-search.js";
+import { MC_TOOLS } from "../tool-names.js";
+import { MASTRACODE_WORKSPACE_TOOLS } from "../agents/tool-availability.js";
+import { LazyNotificationsStorage } from "../agents/tools.js";
+import { workflowBuilderAgent } from "../agents/workflow-builder-agent.js";
+import { createNotificationInboxTool } from "@mastra/core/notifications";
+import { LocalFilesystem, LocalSandbox, Workspace, createWorkspaceTools } from "@mastra/core/workspace";
+//#region src/workflows/register-primitives.ts
+async function registerWorkflowBuilderPrimitives(mastra, options) {
+	const { projectPath, allowedPaths = [], codeAgent, mcpManager } = options;
+	mastra.addAgent(workflowBuilderAgent, "workflow-builder");
+	mastra.addAgent(codeAgent, "code-agent");
+	const workspace = new Workspace({
+		id: "workflow-builder-workspace",
+		name: "Mastra Code Workspace (workflows)",
+		filesystem: new LocalFilesystem({
+			basePath: projectPath,
+			allowedPaths: [projectPath, ...allowedPaths]
+		}),
+		sandbox: new LocalSandbox({ workingDirectory: projectPath }),
+		tools: MASTRACODE_WORKSPACE_TOOLS
+	});
+	const workspaceTools = await createWorkspaceTools(workspace, { workspace });
+	for (const [toolId, tool] of Object.entries(workspaceTools)) mastra.addTool(tool, toolId);
+	if (hasTavilyKey()) {
+		mastra.addTool(createWebSearchTool(), "web-search");
+		mastra.addTool(createWebExtractTool(), "web-extract");
+	}
+	const storage = mastra.getStorage();
+	if (storage) {
+		const notificationInbox = createNotificationInboxTool({ storage: new LazyNotificationsStorage(storage) });
+		mastra.addTool(notificationInbox, MC_TOOLS.NOTIFICATION_INBOX);
+	}
+	if (mcpManager) for (const [toolId, tool] of Object.entries(mcpManager.getTools())) mastra.addTool(tool, toolId);
+}
+//#endregion
+export { registerWorkflowBuilderPrimitives };
+
+//# sourceMappingURL=register-primitives.js.map

package/dist/workflows/register-primitives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-primitives.js","names":[],"sources":["../../src/workflows/register-primitives.ts"],"sourcesContent":["/**\n * Statically register workflow-related primitives on the mastracode Mastra\n * instance so `mastra.listTools()` + `mastra.listAgents()` — and, therefore,\n * the workflow-builder's discovery + the workflow rehydrator — see everything\n * a workflow might want to compose:\n *\n *   - workflow-builder sub-agent (so `create-workflow` can delegate)\n *   - code-agent (as a plain agent, callable via agent steps)\n *   - workspace tools (view/write/edit/find_files/execute_command/etc.)\n *   - web tools (Tavily-gated) so workflows can compose search/extract steps\n *   - notification_inbox\n *   - snapshot of MCP tools from mcpManager\n *\n * Called after `controller.init()` but before `startWorkers()` in both boot\n * paths, so `loadStoredWorkflows()` (inside startWorkers) sees the full\n * registry when rehydrating previously-saved workflows.\n *\n * Tradeoffs:\n *   - MCP tools are snapshotted. Servers added after boot are invisible to\n *     the workflow-builder until restart.\n *   - Web tool flavor is Tavily-only. Provider-native (Anthropic/OpenAI) web\n *     tools are skipped because they'd freeze workflows to one model provider.\n *   - Workflow tool steps get the closed-over workspace + auth (Tavily key,\n *     MCP server credentials), not per-request permissions — deliberate; if\n *     the user built + saved the workflow they meant to run it.\n */\nimport type { Agent } from '@mastra/core/agent';\nimport type { Mastra } from '@mastra/core/mastra';\nimport { createNotificationInboxTool } from '@mastra/core/notifications';\nimport { LocalFilesystem, LocalSandbox, Workspace, createWorkspaceTools } from '@mastra/core/workspace';\nimport { MASTRACODE_WORKSPACE_TOOLS } from '../agents/tool-availability.js';\nimport { LazyNotificationsStorage } from '../agents/tools.js';\nimport { workflowBuilderAgent } from '../agents/workflow-builder-agent.js';\nimport type { McpManager } from '../mcp';\nimport { MC_TOOLS } from '../tool-names.js';\nimport { createWebExtractTool, createWebSearchTool, hasTavilyKey } from '../tools/web-search.js';\n\nexport interface RegisterWorkflowBuilderPrimitivesOptions {\n  projectPath: string;\n  /**\n   * Extra allowed paths the workspace can read/write. Mastracode normally\n   * collects skill paths + sandboxAllowedPaths per-request; for the workflow\n   * workspace we accept anything the caller wants up-front and trust the\n   * worker process to honour the user's intent.\n   */\n  allowedPaths?: string[];\n  /**\n   * The code-agent Agent instance. Registered as `code-agent` so workflows\n   * can compose it in agent steps. It already has full dynamic tool access\n   * (workspace/MCP/web/etc.) via its own `tools: createDynamicTools(...)`.\n   */\n  codeAgent: Agent;\n  /**\n   * McpManager for snapshotting MCP tools at boot. Omit or pass undefined\n   * if MCP is disabled — workflow-builder will just see fewer tools.\n   */\n  mcpManager?: McpManager;\n}\n\nexport async function registerWorkflowBuilderPrimitives(\n  mastra: Mastra,\n  options: RegisterWorkflowBuilderPrimitivesOptions,\n): Promise<void> {\n  const { projectPath, allowedPaths = [], codeAgent, mcpManager } = options;\n\n  // 1. Agents workflows can compose.\n  mastra.addAgent(workflowBuilderAgent, 'workflow-builder');\n  mastra.addAgent(codeAgent, 'code-agent');\n\n  // 2. Workspace tools — bound to a project-rooted local workspace.\n  const workspace = new Workspace({\n    id: 'workflow-builder-workspace',\n    name: 'Mastra Code Workspace (workflows)',\n    filesystem: new LocalFilesystem({\n      basePath: projectPath,\n      allowedPaths: [projectPath, ...allowedPaths],\n    }),\n    sandbox: new LocalSandbox({ workingDirectory: projectPath }),\n    tools: MASTRACODE_WORKSPACE_TOOLS,\n  });\n  const workspaceTools = await createWorkspaceTools(workspace, { workspace });\n  for (const [toolId, tool] of Object.entries(workspaceTools)) {\n    mastra.addTool(tool, toolId);\n  }\n\n  // 3. Web tools — Tavily only. Provider-native web tools (Anthropic/OpenAI)\n  //    are model-locked and would freeze workflows to one provider.\n  if (hasTavilyKey()) {\n    mastra.addTool(createWebSearchTool(), 'web-search');\n    mastra.addTool(createWebExtractTool(), 'web-extract');\n  }\n\n  // 4. notification_inbox — LazyNotificationsStorage resolves the notifications\n  //    domain per-call rather than at boot, so it works even when the domain\n  //    isn't fully initialised yet.\n  const storage = mastra.getStorage();\n  if (storage) {\n    const notificationInbox = createNotificationInboxTool({\n      storage: new LazyNotificationsStorage(storage as never),\n    });\n    mastra.addTool(notificationInbox, MC_TOOLS.NOTIFICATION_INBOX);\n  }\n\n  // 5. MCP tools — snapshot the current set. Ids are already server-namespaced\n  //    (`${serverName}_${toolName}`), so the workflow rehydrator's\n  //    `mastra.getTool(id)` resolves them at run time.\n  if (mcpManager) {\n    for (const [toolId, tool] of Object.entries(mcpManager.getTools())) {\n      mastra.addTool(tool, toolId);\n    }\n  }\n}\n"],"mappings":";;;;;;;;AA2DA,eAAsB,kCACpB,QACA,SACe;CACf,MAAM,EAAE,aAAa,eAAe,CAAC,GAAG,WAAW,eAAe;CAGlE,OAAO,SAAS,sBAAsB,kBAAkB;CACxD,OAAO,SAAS,WAAW,YAAY;CAGvC,MAAM,YAAY,IAAI,UAAU;EAC9B,IAAI;EACJ,MAAM;EACN,YAAY,IAAI,gBAAgB;GAC9B,UAAU;GACV,cAAc,CAAC,aAAa,GAAG,YAAY;EAC7C,CAAC;EACD,SAAS,IAAI,aAAa,EAAE,kBAAkB,YAAY,CAAC;EAC3D,OAAO;CACT,CAAC;CACD,MAAM,iBAAiB,MAAM,qBAAqB,WAAW,EAAE,UAAU,CAAC;CAC1E,KAAK,MAAM,CAAC,QAAQ,SAAS,OAAO,QAAQ,cAAc,GACxD,OAAO,QAAQ,MAAM,MAAM;CAK7B,IAAI,aAAa,GAAG;EAClB,OAAO,QAAQ,oBAAoB,GAAG,YAAY;EAClD,OAAO,QAAQ,qBAAqB,GAAG,aAAa;CACtD;CAKA,MAAM,UAAU,OAAO,WAAW;CAClC,IAAI,SAAS;EACX,MAAM,oBAAoB,4BAA4B,EACpD,SAAS,IAAI,yBAAyB,OAAgB,EACxD,CAAC;EACD,OAAO,QAAQ,mBAAmB,SAAS,kBAAkB;CAC/D;CAKA,IAAI,YACF,KAAK,MAAM,CAAC,QAAQ,SAAS,OAAO,QAAQ,WAAW,SAAS,CAAC,GAC/D,OAAO,QAAQ,MAAM,MAAM;AAGjC"}

package/dist/workflows/service.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Thin wrapper around `mastra.getStorage().getStore('workflowDefinitions')` and
+ * `mastra.getWorkflow(id).createRun().stream(...)` so both the parent-mode
+ * tools and the `/workflows` slash command go through one implementation.
+ */
+import type { Mastra } from '@mastra/core/mastra';
+export interface StoredWorkflowRow {
+    id: string;
+    description?: string;
+    status: 'active' | 'archived';
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    graph?: unknown[];
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export interface RunResult {
+    status: string;
+    result?: unknown;
+    error?: unknown;
+    steps?: Record<string, unknown>;
+    tripwire?: {
+        reason?: string;
+        retry?: unknown;
+        metadata?: unknown;
+        processorId?: string;
+    };
+}
+export interface WorkflowRunEvent {
+    type: string;
+    payload?: Record<string, unknown> & {
+        id?: string;
+    };
+    [key: string]: unknown;
+}
+export type WorkflowRunEventCallback = (event: WorkflowRunEvent) => void;
+export declare function listWorkflows(mastra: Mastra): Promise<{
+    workflows: StoredWorkflowRow[];
+    total: number;
+}>;
+export declare function getWorkflow(mastra: Mastra, id: string): Promise<StoredWorkflowRow | null>;
+export declare function deleteWorkflow(mastra: Mastra, id: string): Promise<{
+    ok: true;
+    id: string;
+}>;
+export declare function runWorkflow(mastra: Mastra, workflowId: string, inputData: unknown, 
+/**
+ * Optional. When provided, passed through to `run.stream(...)` so agent steps
+ * (like `code-agent`) that depend on session state — `getDynamicModel` reads
+ * `controller.session.modelId` off it — can resolve correctly.
+ *
+ * Chat-driven `run-workflow` inherits its context from the parent code-agent
+ * turn, so this is unused there. The `/workflows run` slash handler builds a
+ * synthetic context from the current TUI session and passes it here.
+ */
+requestContext?: unknown, 
+/**
+ * Optional. When provided, invoked for every `WorkflowStreamEvent` the run
+ * emits — used by the `/workflows run` slash handler to render live per-step
+ * progress in the TUI. Non-fatal: errors in the callback are swallowed so a
+ * misbehaving consumer can't take the workflow down.
+ */
+onEvent?: WorkflowRunEventCallback): Promise<RunResult>;
+//# sourceMappingURL=service.d.ts.map

package/dist/workflows/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/workflows/service.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC9B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;IAClB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,SAAS,CAAC,EAAE,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,QAAQ,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3F;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACpD,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,MAAM,wBAAwB,GAAG,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;AA0BzE,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAI9G;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAG/F;AAED,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAQlG;AAED,wBAAsB,WAAW,CAC/B,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,OAAO;AAClB;;;;;;;;GAQG;AACH,cAAc,CAAC,EAAE,OAAO;AACxB;;;;;GAKG;AACH,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,SAAS,CAAC,CAoCpB"}