@mastra/code-sdk 1.2.0-alpha.8 → 1.2.0

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/utils/plans.d.ts

@@ -1,16 +1,19 @@
 /** Global plans directory for approved-plan archives. */
 export declare function getPlansDir(): string;
-/** Local (project-scoped) plans directory where the agent writes named plan files. */
-export declare function getLocalPlansDir(projectPath: string): string;
+export interface LocalPlansOptions {
+    factoryProjectId?: string | null;
+}
 /** Workspace-relative directory the agent writes plan files into. */
-export declare function getLocalPlansRelativeDir(): string;
+export declare function getLocalPlansRelativeDir(options?: LocalPlansOptions): string;
+/** Local (project-scoped) plans directory where the agent writes named plan files. */
+export declare function getLocalPlansDir(projectPath: string, options?: LocalPlansOptions): string;
 /** Derive a plan filename from a title (e.g. `add-dark-mode.md`). */
 export declare function getPlanFilename(title: string): string;
 /**
  * Suggested workspace-relative path for a new plan file, shown in plan-mode prompts.
  * Without a title we fall back to a generic name the agent can rename later.
  */
-export declare function getSuggestedPlanRelativePath(title?: string): string;
+export declare function getSuggestedPlanRelativePath(title?: string, options?: LocalPlansOptions): string;
 /**
  * Resolve a plan path submitted by the agent (absolute or project-relative) to an
  * absolute path. Returns `undefined` when no usable path was provided.
@@ -18,11 +21,11 @@ export declare function getSuggestedPlanRelativePath(title?: string): string;
 export declare function resolvePlanPath(projectPath: string, submittedPath: string): string | undefined;
 /**
  * Whether `targetPath` (absolute or project-relative) is a valid plan file: a `.md`
- * file located directly inside the project's `.mastracode/plans/` directory. Used by the
+ * file located directly inside the project's configured plan directory. Used by the
  * plan-mode write guard so the agent can write any named plan file there, but nothing
  * outside that directory.
  */
-export declare function isPlanFilePath(projectPath: string, targetPath: string): boolean;
+export declare function isPlanFilePath(projectPath: string, targetPath: string, options?: LocalPlansOptions): boolean;
 export declare function savePlanToDisk(opts: {
     title: string;
     plan: string;

package/dist/utils/plans.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plans.d.ts","sourceRoot":"","sources":["../../src/utils/plans.ts"],"names":[],"mappings":"AAKA,yDAAyD;AACzD,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,qEAAqE;AACrE,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAUD,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAGnE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG9F;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAU/E;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBhB;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,CAsBxG;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAc9B"}
+{"version":3,"file":"plans.d.ts","sourceRoot":"","sources":["../../src/utils/plans.ts"],"names":[],"mappings":"AAKA,yDAAyD;AACzD,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAED,MAAM,WAAW,iBAAiB;IAChC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED,qEAAqE;AACrE,wBAAgB,wBAAwB,CAAC,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAEhF;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAE7F;AAUD,qEAAqE;AACrE,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAGpG;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG9F;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAUhH;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBhB;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,CAsBxG;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAc9B"}

package/dist/utils/plans.js

@@ -7,13 +7,13 @@ import fs from "fs/promises";
 function getPlansDir() {
 	return process.env.MASTRA_PLANS_DIR ?? path.join(getAppDataDir(), "plans");
 }
-/** Local (project-scoped) plans directory where the agent writes named plan files. */
-function getLocalPlansDir(projectPath) {
-	return path.join(projectPath, DEFAULT_CONFIG_DIR, "plans");
-}
 /** Workspace-relative directory the agent writes plan files into. */
-function getLocalPlansRelativeDir() {
-	return path.join(DEFAULT_CONFIG_DIR, "plans");
+function getLocalPlansRelativeDir(options = {}) {
+	return options.factoryProjectId ? path.join(".artifacts", "plans") : path.join(DEFAULT_CONFIG_DIR, "plans");
+}
+/** Local (project-scoped) plans directory where the agent writes named plan files. */
+function getLocalPlansDir(projectPath, options = {}) {
+	return path.join(projectPath, getLocalPlansRelativeDir(options));
 }
 function slugify(str) {
 	return str.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "untitled";
@@ -26,9 +26,9 @@ function getPlanFilename(title) {
 * Suggested workspace-relative path for a new plan file, shown in plan-mode prompts.
 * Without a title we fall back to a generic name the agent can rename later.
 */
-function getSuggestedPlanRelativePath(title) {
+function getSuggestedPlanRelativePath(title, options = {}) {
 	const filename = title ? getPlanFilename(title) : "plan.md";
-	return path.join(getLocalPlansRelativeDir(), filename);
+	return path.join(getLocalPlansRelativeDir(options), filename);
 }
 /**
 * Resolve a plan path submitted by the agent (absolute or project-relative) to an
@@ -40,15 +40,15 @@ function resolvePlanPath(projectPath, submittedPath) {
 }
 /**
 * Whether `targetPath` (absolute or project-relative) is a valid plan file: a `.md`
-* file located directly inside the project's `.mastracode/plans/` directory. Used by the
+* file located directly inside the project's configured plan directory. Used by the
 * plan-mode write guard so the agent can write any named plan file there, but nothing
 * outside that directory.
 */
-function isPlanFilePath(projectPath, targetPath) {
+function isPlanFilePath(projectPath, targetPath, options = {}) {
 	const abs = resolvePlanPath(projectPath, targetPath);
 	if (!abs) return false;
 	if (path.extname(abs).toLowerCase() !== ".md") return false;
-	const plansDir = path.resolve(getLocalPlansDir(projectPath));
+	const plansDir = path.resolve(getLocalPlansDir(projectPath, options));
 	const rel = path.relative(plansDir, abs);
 	if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return false;
 	return !rel.includes(path.sep);

package/dist/utils/plans.js.map

@@ -1 +1 @@
-{"version":3,"file":"plans.js","names":[],"sources":["../../src/utils/plans.ts"],"sourcesContent":["import fs from 'node:fs/promises';\nimport path from 'node:path';\nimport { DEFAULT_CONFIG_DIR } from '../constants.js';\nimport { getAppDataDir } from './project.js';\n\n/** Global plans directory for approved-plan archives. */\nexport function getPlansDir(): string {\n  return process.env.MASTRA_PLANS_DIR ?? path.join(getAppDataDir(), 'plans');\n}\n\n/** Local (project-scoped) plans directory where the agent writes named plan files. */\nexport function getLocalPlansDir(projectPath: string): string {\n  return path.join(projectPath, DEFAULT_CONFIG_DIR, 'plans');\n}\n\n/** Workspace-relative directory the agent writes plan files into. */\nexport function getLocalPlansRelativeDir(): string {\n  return path.join(DEFAULT_CONFIG_DIR, 'plans');\n}\n\nfunction slugify(str: string): string {\n  const slug = str\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, '-')\n    .replace(/^-|-$/g, '');\n  return slug || 'untitled';\n}\n\n/** Derive a plan filename from a title (e.g. `add-dark-mode.md`). */\nexport function getPlanFilename(title: string): string {\n  return `${slugify(title)}.md`;\n}\n\n/**\n * Suggested workspace-relative path for a new plan file, shown in plan-mode prompts.\n * Without a title we fall back to a generic name the agent can rename later.\n */\nexport function getSuggestedPlanRelativePath(title?: string): string {\n  const filename = title ? getPlanFilename(title) : 'plan.md';\n  return path.join(getLocalPlansRelativeDir(), filename);\n}\n\n/**\n * Resolve a plan path submitted by the agent (absolute or project-relative) to an\n * absolute path. Returns `undefined` when no usable path was provided.\n */\nexport function resolvePlanPath(projectPath: string, submittedPath: string): string | undefined {\n  if (!submittedPath) return undefined;\n  return path.isAbsolute(submittedPath) ? submittedPath : path.resolve(projectPath, submittedPath);\n}\n\n/**\n * Whether `targetPath` (absolute or project-relative) is a valid plan file: a `.md`\n * file located directly inside the project's `.mastracode/plans/` directory. Used by the\n * plan-mode write guard so the agent can write any named plan file there, but nothing\n * outside that directory.\n */\nexport function isPlanFilePath(projectPath: string, targetPath: string): boolean {\n  const abs = resolvePlanPath(projectPath, targetPath);\n  if (!abs) return false;\n  if (path.extname(abs).toLowerCase() !== '.md') return false;\n\n  const plansDir = path.resolve(getLocalPlansDir(projectPath));\n  const rel = path.relative(plansDir, abs);\n  // Must be directly inside the plans dir (no nested subdirectories, no escaping it).\n  if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel)) return false;\n  return !rel.includes(path.sep);\n}\n\nexport async function savePlanToDisk(opts: {\n  title: string;\n  plan: string;\n  resourceId: string;\n  plansDir?: string;\n}): Promise<void> {\n  const { title, plan, resourceId } = opts;\n  const plansDir = opts.plansDir ?? getPlansDir();\n  const baseDir = path.resolve(plansDir);\n  const dir = path.resolve(baseDir, resourceId);\n  const rel = path.relative(baseDir, dir);\n  if (rel.startsWith('..') || path.isAbsolute(rel)) {\n    throw new Error(`Invalid resourceId: ${resourceId}`);\n  }\n\n  await fs.mkdir(dir, { recursive: true });\n\n  const now = new Date();\n  const timestamp = now.toISOString().replace(/:/g, '-');\n  const slug = slugify(title);\n  const filename = `${timestamp}-${slug}.md`;\n\n  const content = `# ${title}\\n\\nApproved: ${now.toISOString()}\\n\\n${plan}\\n`;\n\n  await fs.writeFile(path.join(dir, filename), content, 'utf-8');\n}\n\n/**\n * Read a plan markdown file by absolute path.\n *\n * The leading `# <title>` heading (if present) is parsed as the title and the remaining\n * content is returned as the plan body. Returns `undefined` when the file does not exist.\n */\nexport async function readPlanFile(absPath: string): Promise<{ title: string; plan: string } | undefined> {\n  let raw: string;\n  try {\n    raw = await fs.readFile(absPath, 'utf-8');\n  } catch {\n    return undefined;\n  }\n\n  const lines = raw.split(/\\r?\\n/);\n  const headingIndex = lines.findIndex(line => line.trim().length > 0);\n  const heading = headingIndex >= 0 ? lines[headingIndex] : undefined;\n  if (heading?.startsWith('# ')) {\n    const title = heading.slice(2).trim();\n    const plan = lines\n      .slice(headingIndex + 1)\n      .join('\\n')\n      .replace(/^\\n+/, '')\n      .trimEnd();\n    return { title, plan };\n  }\n\n  return { title: '', plan: raw.trimEnd() };\n}\n\n/**\n * Approve the plan file at `planPath`: write a timestamped copy to the global plans\n * archive so approved plans are findable later. The local named plan file is left in\n * place so the user can review every plan made over time.\n *\n * Returns the local plan filename (e.g. `add-dark-mode.md`), or `undefined` when there\n * was no plan file to approve.\n */\nexport async function approvePlanFile(opts: {\n  planPath: string;\n  title: string;\n  resourceId: string;\n  plansDir?: string;\n}): Promise<string | undefined> {\n  const { planPath, title, resourceId, plansDir } = opts;\n\n  const current = await readPlanFile(planPath);\n  if (!current) {\n    return undefined;\n  }\n\n  const resolvedTitle = title || current.title || 'Implementation Plan';\n\n  // Global archive (timestamped, never overwritten) so approved plans are findable later.\n  await savePlanToDisk({ title: resolvedTitle, plan: current.plan, resourceId, plansDir });\n\n  return path.basename(planPath);\n}\n"],"mappings":"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"}
+{"version":3,"file":"plans.js","names":[],"sources":["../../src/utils/plans.ts"],"sourcesContent":["import fs from 'node:fs/promises';\nimport path from 'node:path';\nimport { DEFAULT_CONFIG_DIR } from '../constants.js';\nimport { getAppDataDir } from './project.js';\n\n/** Global plans directory for approved-plan archives. */\nexport function getPlansDir(): string {\n  return process.env.MASTRA_PLANS_DIR ?? path.join(getAppDataDir(), 'plans');\n}\n\nexport interface LocalPlansOptions {\n  factoryProjectId?: string | null;\n}\n\n/** Workspace-relative directory the agent writes plan files into. */\nexport function getLocalPlansRelativeDir(options: LocalPlansOptions = {}): string {\n  return options.factoryProjectId ? path.join('.artifacts', 'plans') : path.join(DEFAULT_CONFIG_DIR, 'plans');\n}\n\n/** Local (project-scoped) plans directory where the agent writes named plan files. */\nexport function getLocalPlansDir(projectPath: string, options: LocalPlansOptions = {}): string {\n  return path.join(projectPath, getLocalPlansRelativeDir(options));\n}\n\nfunction slugify(str: string): string {\n  const slug = str\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, '-')\n    .replace(/^-|-$/g, '');\n  return slug || 'untitled';\n}\n\n/** Derive a plan filename from a title (e.g. `add-dark-mode.md`). */\nexport function getPlanFilename(title: string): string {\n  return `${slugify(title)}.md`;\n}\n\n/**\n * Suggested workspace-relative path for a new plan file, shown in plan-mode prompts.\n * Without a title we fall back to a generic name the agent can rename later.\n */\nexport function getSuggestedPlanRelativePath(title?: string, options: LocalPlansOptions = {}): string {\n  const filename = title ? getPlanFilename(title) : 'plan.md';\n  return path.join(getLocalPlansRelativeDir(options), filename);\n}\n\n/**\n * Resolve a plan path submitted by the agent (absolute or project-relative) to an\n * absolute path. Returns `undefined` when no usable path was provided.\n */\nexport function resolvePlanPath(projectPath: string, submittedPath: string): string | undefined {\n  if (!submittedPath) return undefined;\n  return path.isAbsolute(submittedPath) ? submittedPath : path.resolve(projectPath, submittedPath);\n}\n\n/**\n * Whether `targetPath` (absolute or project-relative) is a valid plan file: a `.md`\n * file located directly inside the project's configured plan directory. Used by the\n * plan-mode write guard so the agent can write any named plan file there, but nothing\n * outside that directory.\n */\nexport function isPlanFilePath(projectPath: string, targetPath: string, options: LocalPlansOptions = {}): boolean {\n  const abs = resolvePlanPath(projectPath, targetPath);\n  if (!abs) return false;\n  if (path.extname(abs).toLowerCase() !== '.md') return false;\n\n  const plansDir = path.resolve(getLocalPlansDir(projectPath, options));\n  const rel = path.relative(plansDir, abs);\n  // Must be directly inside the plans dir (no nested subdirectories, no escaping it).\n  if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel)) return false;\n  return !rel.includes(path.sep);\n}\n\nexport async function savePlanToDisk(opts: {\n  title: string;\n  plan: string;\n  resourceId: string;\n  plansDir?: string;\n}): Promise<void> {\n  const { title, plan, resourceId } = opts;\n  const plansDir = opts.plansDir ?? getPlansDir();\n  const baseDir = path.resolve(plansDir);\n  const dir = path.resolve(baseDir, resourceId);\n  const rel = path.relative(baseDir, dir);\n  if (rel.startsWith('..') || path.isAbsolute(rel)) {\n    throw new Error(`Invalid resourceId: ${resourceId}`);\n  }\n\n  await fs.mkdir(dir, { recursive: true });\n\n  const now = new Date();\n  const timestamp = now.toISOString().replace(/:/g, '-');\n  const slug = slugify(title);\n  const filename = `${timestamp}-${slug}.md`;\n\n  const content = `# ${title}\\n\\nApproved: ${now.toISOString()}\\n\\n${plan}\\n`;\n\n  await fs.writeFile(path.join(dir, filename), content, 'utf-8');\n}\n\n/**\n * Read a plan markdown file by absolute path.\n *\n * The leading `# <title>` heading (if present) is parsed as the title and the remaining\n * content is returned as the plan body. Returns `undefined` when the file does not exist.\n */\nexport async function readPlanFile(absPath: string): Promise<{ title: string; plan: string } | undefined> {\n  let raw: string;\n  try {\n    raw = await fs.readFile(absPath, 'utf-8');\n  } catch {\n    return undefined;\n  }\n\n  const lines = raw.split(/\\r?\\n/);\n  const headingIndex = lines.findIndex(line => line.trim().length > 0);\n  const heading = headingIndex >= 0 ? lines[headingIndex] : undefined;\n  if (heading?.startsWith('# ')) {\n    const title = heading.slice(2).trim();\n    const plan = lines\n      .slice(headingIndex + 1)\n      .join('\\n')\n      .replace(/^\\n+/, '')\n      .trimEnd();\n    return { title, plan };\n  }\n\n  return { title: '', plan: raw.trimEnd() };\n}\n\n/**\n * Approve the plan file at `planPath`: write a timestamped copy to the global plans\n * archive so approved plans are findable later. The local named plan file is left in\n * place so the user can review every plan made over time.\n *\n * Returns the local plan filename (e.g. `add-dark-mode.md`), or `undefined` when there\n * was no plan file to approve.\n */\nexport async function approvePlanFile(opts: {\n  planPath: string;\n  title: string;\n  resourceId: string;\n  plansDir?: string;\n}): Promise<string | undefined> {\n  const { planPath, title, resourceId, plansDir } = opts;\n\n  const current = await readPlanFile(planPath);\n  if (!current) {\n    return undefined;\n  }\n\n  const resolvedTitle = title || current.title || 'Implementation Plan';\n\n  // Global archive (timestamped, never overwritten) so approved plans are findable later.\n  await savePlanToDisk({ title: resolvedTitle, plan: current.plan, resourceId, plansDir });\n\n  return path.basename(planPath);\n}\n"],"mappings":"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"}

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"}