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

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-workflow.js","names":[],"sources":["../../../src/tools/workflows/create-workflow.ts"],"sourcesContent":["/**\n * Parent-mode tool: delegate workflow construction to the workflow-builder\n * sub-agent. The parent code-agent calls this with the user's request verbatim;\n * the sub-agent runs its own discovery → compose → save loop and returns a\n * one-paragraph summary the parent relays to the user.\n *\n * The split exists so the parent code-agent's system prompt stays focused on\n * coding and isn't polluted with the long workflow-authoring contract.\n */\nimport type { Mastra } from '@mastra/core/mastra';\nimport { createTool } from '@mastra/core/tools';\nimport { z } from 'zod';\n\n/**\n * Coerce an unknown thrown value into a readable string. Sub-agent tool errors\n * come through the stream in various shapes (Error, plain object, string) —\n * normalise so the parent tool's error message is always useful.\n */\nfunction stringifyError(err: unknown): string {\n  if (err instanceof Error) return err.message;\n  if (typeof err === 'string') return err;\n  try {\n    return JSON.stringify(err) ?? String(err);\n  } catch {\n    return String(err);\n  }\n}\n\nexport const createWorkflowTool = createTool({\n  id: 'create-workflow',\n  description:\n    'Build and save a Dynamic Workflow on behalf of the user. Pass the user request verbatim — a focused sub-agent handles discovery, construction, and persistence, then returns a summary. Use this whenever the user asks to \"build a workflow\", \"compose a workflow\", or similar. Do NOT try to construct workflows inline yourself.',\n  inputSchema: z.object({\n    request: z.string().describe('The user request, verbatim — do not paraphrase or summarise.'),\n  }),\n  outputSchema: z.object({\n    summary: z.string().describe('Natural-language summary of what the sub-agent built. Relay this to the user.'),\n    workflowId: z.string().optional().describe('The id of the saved workflow, if save-workflow returned ok.'),\n  }),\n  execute: async ({ request }, { mastra, requestContext }) => {\n    if (!mastra) throw new Error('create-workflow requires a Mastra context.');\n    const builder = (mastra as Mastra).getAgent('workflow-builder' as never);\n    if (!builder) {\n      throw new Error(\n        'The \"workflow-builder\" sub-agent is not registered on this Mastra instance. Cannot build workflows.',\n      );\n    }\n\n    // Propagate the parent code-agent's requestContext so the sub-agent's\n    // dynamic model resolver (getDynamicModel) sees controller.session.modelId.\n    // Without this the sub-agent throws \"No model selected\" even when the user\n    // has /models configured for the main code-agent.\n    const stream = await builder.stream(request, { requestContext });\n\n    // Sub-agent runs its own tool loop. We MUST verify save-workflow actually\n    // ran and returned ok — otherwise the sub-agent's natural-language \"summary\"\n    // is worthless (it will happily claim success without ever calling the tool,\n    // or claim success after save-workflow threw). Surface every error the\n    // sub-agent's tools produce so the caller sees them instead of a fake ok.\n    let workflowId: string | undefined;\n    let saveAttempted = false;\n    let saveSucceeded = false;\n    const toolErrors: Array<{ toolName: string; error: string }> = [];\n\n    const reader = stream.fullStream.getReader();\n    let streamCompleted = false;\n    try {\n      while (true) {\n        const { value, done } = await reader.read();\n        if (done) {\n          streamCompleted = true;\n          break;\n        }\n        if (value?.type === 'tool-call' && value.payload?.toolName === 'save-workflow') {\n          saveAttempted = true;\n        }\n        if (value?.type === 'tool-result' && value.payload?.toolName === 'save-workflow') {\n          const result = value.payload.result as { id?: string; ok?: boolean } | undefined;\n          if (result && result.ok === true && typeof result.id === 'string') {\n            workflowId = result.id;\n            saveSucceeded = true;\n          }\n        }\n        if (value?.type === 'tool-error' && typeof value.payload?.toolName === 'string') {\n          toolErrors.push({ toolName: value.payload.toolName, error: stringifyError(value.payload.error) });\n        }\n      }\n    } finally {\n      if (!streamCompleted) {\n        await reader.cancel().catch(() => undefined);\n      }\n      reader.releaseLock();\n    }\n\n    const summary = await stream.text;\n\n    // If save-workflow errored, surface that error explicitly — do NOT return\n    // the sub-agent's summary as if things were fine.\n    const saveErrors = toolErrors.filter(e => e.toolName === 'save-workflow');\n    if (saveErrors.length > 0 && !saveSucceeded) {\n      throw new Error(\n        `create-workflow failed: save-workflow threw ${saveErrors.length} error(s):\\n- ${saveErrors\n          .map(e => e.error)\n          .join('\\n- ')}\\n\\nSub-agent summary (unreliable, save did not succeed):\\n${summary}`,\n      );\n    }\n\n    // If save-workflow was never called, the sub-agent gave up (or hallucinated\n    // success). Fail loudly so the caller doesn't think a workflow exists.\n    if (!saveAttempted) {\n      const otherErrors = toolErrors.length\n        ? `\\n\\nOther sub-agent tool errors:\\n- ${toolErrors.map(e => `${e.toolName}: ${e.error}`).join('\\n- ')}`\n        : '';\n      throw new Error(\n        `create-workflow failed: the workflow-builder sub-agent never called save-workflow. No workflow was persisted.${otherErrors}\\n\\nSub-agent summary:\\n${summary}`,\n      );\n    }\n\n    // Save was attempted but never returned ok (no tool-result with { ok: true, id }).\n    if (!saveSucceeded) {\n      const otherErrors = toolErrors.length\n        ? `\\n\\nSub-agent tool errors:\\n- ${toolErrors.map(e => `${e.toolName}: ${e.error}`).join('\\n- ')}`\n        : '';\n      throw new Error(\n        `create-workflow failed: save-workflow was called but did not return { ok: true }.${otherErrors}\\n\\nSub-agent summary:\\n${summary}`,\n      );\n    }\n\n    return { summary, workflowId };\n  },\n});\n"],"mappings":";;;;;;;;AAkBA,SAAS,eAAe,KAAsB;CAC5C,IAAI,eAAe,OAAO,OAAO,IAAI;CACrC,IAAI,OAAO,QAAQ,UAAU,OAAO;CACpC,IAAI;EACF,OAAO,KAAK,UAAU,GAAG,KAAK,OAAO,GAAG;CAC1C,QAAQ;EACN,OAAO,OAAO,GAAG;CACnB;AACF;AAEA,MAAa,qBAAqB,WAAW;CAC3C,IAAI;CACJ,aACE;CACF,aAAa,EAAE,OAAO,EACpB,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS,8DAA8D,EAC7F,CAAC;CACD,cAAc,EAAE,OAAO;EACrB,SAAS,EAAE,OAAO,CAAC,CAAC,SAAS,+EAA+E;EAC5G,YAAY,EAAE,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,6DAA6D;CAC1G,CAAC;CACD,SAAS,OAAO,EAAE,WAAW,EAAE,QAAQ,qBAAqB;EAC1D,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,4CAA4C;EACzE,MAAM,UAAW,OAAkB,SAAS,kBAA2B;EACvE,IAAI,CAAC,SACH,MAAM,IAAI,MACR,uGACF;EAOF,MAAM,SAAS,MAAM,QAAQ,OAAO,SAAS,EAAE,eAAe,CAAC;EAO/D,IAAI;EACJ,IAAI,gBAAgB;EACpB,IAAI,gBAAgB;EACpB,MAAM,aAAyD,CAAC;EAEhE,MAAM,SAAS,OAAO,WAAW,UAAU;EAC3C,IAAI,kBAAkB;EACtB,IAAI;GACF,OAAO,MAAM;IACX,MAAM,EAAE,OAAO,SAAS,MAAM,OAAO,KAAK;IAC1C,IAAI,MAAM;KACR,kBAAkB;KAClB;IACF;IACA,IAAI,OAAO,SAAS,eAAe,MAAM,SAAS,aAAa,iBAC7D,gBAAgB;IAElB,IAAI,OAAO,SAAS,iBAAiB,MAAM,SAAS,aAAa,iBAAiB;KAChF,MAAM,SAAS,MAAM,QAAQ;KAC7B,IAAI,UAAU,OAAO,OAAO,QAAQ,OAAO,OAAO,OAAO,UAAU;MACjE,aAAa,OAAO;MACpB,gBAAgB;KAClB;IACF;IACA,IAAI,OAAO,SAAS,gBAAgB,OAAO,MAAM,SAAS,aAAa,UACrE,WAAW,KAAK;KAAE,UAAU,MAAM,QAAQ;KAAU,OAAO,eAAe,MAAM,QAAQ,KAAK;IAAE,CAAC;GAEpG;EACF,UAAU;GACR,IAAI,CAAC,iBACH,MAAM,OAAO,OAAO,CAAC,CAAC,YAAY,KAAA,CAAS;GAE7C,OAAO,YAAY;EACrB;EAEA,MAAM,UAAU,MAAM,OAAO;EAI7B,MAAM,aAAa,WAAW,QAAO,MAAK,EAAE,aAAa,eAAe;EACxE,IAAI,WAAW,SAAS,KAAK,CAAC,eAC5B,MAAM,IAAI,MACR,+CAA+C,WAAW,OAAO,gBAAgB,WAC9E,KAAI,MAAK,EAAE,KAAK,CAAC,CACjB,KAAK,MAAM,EAAE,6DAA6D,SAC/E;EAKF,IAAI,CAAC,eAAe;GAClB,MAAM,cAAc,WAAW,SAC3B,uCAAuC,WAAW,KAAI,MAAK,GAAG,EAAE,SAAS,IAAI,EAAE,OAAO,CAAC,CAAC,KAAK,MAAM,MACnG;GACJ,MAAM,IAAI,MACR,gHAAgH,YAAY,0BAA0B,SACxJ;EACF;EAGA,IAAI,CAAC,eAAe;GAClB,MAAM,cAAc,WAAW,SAC3B,iCAAiC,WAAW,KAAI,MAAK,GAAG,EAAE,SAAS,IAAI,EAAE,OAAO,CAAC,CAAC,KAAK,MAAM,MAC7F;GACJ,MAAM,IAAI,MACR,oFAAoF,YAAY,0BAA0B,SAC5H;EACF;EAEA,OAAO;GAAE;GAAS;EAAW;CAC/B;AACF,CAAC"}

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

@@ -0,0 +1,7 @@
+export declare const deleteWorkflowTool: import("@mastra/core/tools").Tool<{
+    id: string;
+}, {
+    ok: true;
+    id: string;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "delete-workflow", unknown>;
+//# sourceMappingURL=delete-workflow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-workflow.d.ts","sourceRoot":"","sources":["../../../src/tools/workflows/delete-workflow.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,kBAAkB;;;;;8HAe7B,CAAC"}

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

@@ -0,0 +1,21 @@
+import { deleteWorkflow } from "../../workflows/service.js";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+//#region src/tools/workflows/delete-workflow.ts
+const deleteWorkflowTool = createTool({
+	id: "delete-workflow",
+	description: "Remove a saved workflow from storage and unregister the live in-process Workflow instance. Idempotent. Subsequent save-workflow calls with the same id re-register cleanly.",
+	inputSchema: z.object({ id: z.string().describe("The workflow id to delete.") }),
+	outputSchema: z.object({
+		ok: z.literal(true),
+		id: z.string()
+	}),
+	execute: async ({ id }, { mastra }) => {
+		if (!mastra) throw new Error("delete-workflow requires a Mastra context.");
+		return deleteWorkflow(mastra, id);
+	}
+});
+//#endregion
+export { deleteWorkflowTool };
+
+//# sourceMappingURL=delete-workflow.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-workflow.js","names":[],"sources":["../../../src/tools/workflows/delete-workflow.ts"],"sourcesContent":["/**\n * Parent-mode tool: delete a saved workflow from storage and unregister the\n * live in-process Workflow instance so a subsequent save-workflow with the\n * same id re-registers cleanly.\n */\nimport type { Mastra } from '@mastra/core/mastra';\nimport { createTool } from '@mastra/core/tools';\nimport { z } from 'zod';\nimport { deleteWorkflow } from '../../workflows/service.js';\n\nexport const deleteWorkflowTool = createTool({\n  id: 'delete-workflow',\n  description:\n    'Remove a saved workflow from storage and unregister the live in-process Workflow instance. Idempotent. Subsequent save-workflow calls with the same id re-register cleanly.',\n  inputSchema: z.object({\n    id: z.string().describe('The workflow id to delete.'),\n  }),\n  outputSchema: z.object({\n    ok: z.literal(true),\n    id: z.string(),\n  }),\n  execute: async ({ id }, { mastra }) => {\n    if (!mastra) throw new Error('delete-workflow requires a Mastra context.');\n    return deleteWorkflow(mastra as Mastra, id);\n  },\n});\n"],"mappings":";;;;AAUA,MAAa,qBAAqB,WAAW;CAC3C,IAAI;CACJ,aACE;CACF,aAAa,EAAE,OAAO,EACpB,IAAI,EAAE,OAAO,CAAC,CAAC,SAAS,4BAA4B,EACtD,CAAC;CACD,cAAc,EAAE,OAAO;EACrB,IAAI,EAAE,QAAQ,IAAI;EAClB,IAAI,EAAE,OAAO;CACf,CAAC;CACD,SAAS,OAAO,EAAE,MAAM,EAAE,aAAa;EACrC,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,4CAA4C;EACzE,OAAO,eAAe,QAAkB,EAAE;CAC5C;AACF,CAAC"}

package/dist/tools/workflows/ephemeral-memory.d.ts

@@ -0,0 +1,7 @@
+import { RequestContext } from '@mastra/core/request-context';
+interface EphemeralMemoryOptions {
+    threadId?: string;
+}
+export declare function withEphemeralMemory<T>(requestContext: RequestContext | undefined, fn: (requestContext: RequestContext | undefined) => Promise<T>, options?: EphemeralMemoryOptions): Promise<T>;
+export {};
+//# sourceMappingURL=ephemeral-memory.d.ts.map

package/dist/tools/workflows/ephemeral-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ephemeral-memory.d.ts","sourceRoot":"","sources":["../../../src/tools/workflows/ephemeral-memory.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAgD,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAE5G,UAAU,sBAAsB;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,mBAAmB,CAAC,CAAC,EACzC,cAAc,EAAE,cAAc,GAAG,SAAS,EAC1C,EAAE,EAAE,CAAC,cAAc,EAAE,cAAc,GAAG,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,EAC9D,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,CAAC,CAAC,CA6BZ"}

package/dist/tools/workflows/ephemeral-memory.js

@@ -0,0 +1,45 @@
+import { randomUUID } from "crypto";
+import { MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY, RequestContext } from "@mastra/core/request-context";
+//#region src/tools/workflows/ephemeral-memory.ts
+/**
+* Sub-invocations launched from a parent chat turn (workflow agent steps,
+* sub-agent tool calls) must run under a fresh isolated Mastra memory scope
+* so they don't:
+*
+*   - write their prompts/responses into the parent chat thread's history, or
+*   - contend with the parent turn's memory-dependent processors
+*     (observational-memory, task-state, working-memory-state).
+*
+* `withEphemeralMemory` copies the caller's request context into a child,
+* replaces its MastraMemory with a fresh thread id and inherited resource id,
+* then passes that isolated child to `fn`. The parent context is never mutated,
+* so concurrent sub-invocations cannot overwrite or restore each other's
+* memory values. Isolation writes the ephemeral ids instead of scrubbing them:
+* inner agent invocations resolve their thread/resource via those reserved
+* keys, and leaving them unset causes downstream storage saves to throw
+* "Thread ID is required".
+*
+* Callers can override the ephemeral thread id (e.g. for tests) via
+* `options.threadId`.
+*/
+async function withEphemeralMemory(requestContext, fn, options = {}) {
+	if (!requestContext) return fn(void 0);
+	const childRequestContext = new RequestContext(requestContext.entries());
+	const mastraMemory = requestContext.get("MastraMemory");
+	const resourceId = requestContext.get(MASTRA_RESOURCE_ID_KEY);
+	const ephemeralThreadId = options.threadId ?? randomUUID();
+	const parentResourceId = mastraMemory?.resourceId ?? resourceId ?? "";
+	childRequestContext.set("MastraMemory", {
+		thread: { id: ephemeralThreadId },
+		resourceId: parentResourceId,
+		memoryConfig: void 0
+	});
+	childRequestContext.set(MASTRA_THREAD_ID_KEY, ephemeralThreadId);
+	if (parentResourceId) childRequestContext.set(MASTRA_RESOURCE_ID_KEY, parentResourceId);
+	else childRequestContext.delete(MASTRA_RESOURCE_ID_KEY);
+	return fn(childRequestContext);
+}
+//#endregion
+export { withEphemeralMemory };
+
+//# sourceMappingURL=ephemeral-memory.js.map

package/dist/tools/workflows/ephemeral-memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ephemeral-memory.js","names":[],"sources":["../../../src/tools/workflows/ephemeral-memory.ts"],"sourcesContent":["/**\n * Sub-invocations launched from a parent chat turn (workflow agent steps,\n * sub-agent tool calls) must run under a fresh isolated Mastra memory scope\n * so they don't:\n *\n *   - write their prompts/responses into the parent chat thread's history, or\n *   - contend with the parent turn's memory-dependent processors\n *     (observational-memory, task-state, working-memory-state).\n *\n * `withEphemeralMemory` copies the caller's request context into a child,\n * replaces its MastraMemory with a fresh thread id and inherited resource id,\n * then passes that isolated child to `fn`. The parent context is never mutated,\n * so concurrent sub-invocations cannot overwrite or restore each other's\n * memory values. Isolation writes the ephemeral ids instead of scrubbing them:\n * inner agent invocations resolve their thread/resource via those reserved\n * keys, and leaving them unset causes downstream storage saves to throw\n * \"Thread ID is required\".\n *\n * Callers can override the ephemeral thread id (e.g. for tests) via\n * `options.threadId`.\n */\nimport { randomUUID } from 'node:crypto';\nimport { MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY, RequestContext } from '@mastra/core/request-context';\n\ninterface EphemeralMemoryOptions {\n  threadId?: string;\n}\n\nexport async function withEphemeralMemory<T>(\n  requestContext: RequestContext | undefined,\n  fn: (requestContext: RequestContext | undefined) => Promise<T>,\n  options: EphemeralMemoryOptions = {},\n): Promise<T> {\n  if (!requestContext) return fn(undefined);\n\n  const childRequestContext = new RequestContext(requestContext.entries());\n  const mastraMemory = requestContext.get('MastraMemory') as\n    | { thread?: { id?: string }; resourceId?: string; memoryConfig?: unknown }\n    | undefined;\n  const resourceId = requestContext.get(MASTRA_RESOURCE_ID_KEY) as string | undefined;\n  const ephemeralThreadId = options.threadId ?? randomUUID();\n  const parentResourceId = mastraMemory?.resourceId ?? resourceId ?? '';\n\n  childRequestContext.set('MastraMemory', {\n    thread: { id: ephemeralThreadId },\n    resourceId: parentResourceId,\n    memoryConfig: undefined,\n  });\n  // Stamp the reserved thread/resource-key context values with the same\n  // ephemeral ids. Inner agent invocations (workflow agent steps, sub-agent\n  // tool calls) read these keys to resolve their runtime thread; leaving\n  // MASTRA_THREAD_ID_KEY unset causes prepare-memory-step to build a\n  // MessageList without a threadId, which storage rejects downstream.\n  childRequestContext.set(MASTRA_THREAD_ID_KEY, ephemeralThreadId);\n  if (parentResourceId) {\n    childRequestContext.set(MASTRA_RESOURCE_ID_KEY, parentResourceId);\n  } else {\n    childRequestContext.delete(MASTRA_RESOURCE_ID_KEY);\n  }\n\n  return fn(childRequestContext);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA4BA,eAAsB,oBACpB,gBACA,IACA,UAAkC,CAAC,GACvB;CACZ,IAAI,CAAC,gBAAgB,OAAO,GAAG,KAAA,CAAS;CAExC,MAAM,sBAAsB,IAAI,eAAe,eAAe,QAAQ,CAAC;CACvE,MAAM,eAAe,eAAe,IAAI,cAAc;CAGtD,MAAM,aAAa,eAAe,IAAI,sBAAsB;CAC5D,MAAM,oBAAoB,QAAQ,YAAY,WAAW;CACzD,MAAM,mBAAmB,cAAc,cAAc,cAAc;CAEnE,oBAAoB,IAAI,gBAAgB;EACtC,QAAQ,EAAE,IAAI,kBAAkB;EAChC,YAAY;EACZ,cAAc,KAAA;CAChB,CAAC;CAMD,oBAAoB,IAAI,sBAAsB,iBAAiB;CAC/D,IAAI,kBACF,oBAAoB,IAAI,wBAAwB,gBAAgB;MAEhE,oBAAoB,OAAO,sBAAsB;CAGnD,OAAO,GAAG,mBAAmB;AAC/B"}

package/dist/tools/workflows/extract-json-schema.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Extract a JSON Schema from a Mastra tool's schema field. Tools created via
+ * `createTool({...})` wrap their Zod schemas with `toStandardSchema`, exposing
+ * `['~standard'].jsonSchema` as a `{ input(opts), output(opts) }` converter
+ * (see packages/schema-compat/src/standard-schema/adapters/zod-v3.ts:110-119).
+ * `direction` selects which side — pass 'input' for inputSchema, 'output' for
+ * outputSchema. Returns undefined if the schema is missing or not
+ * standard-schema-compliant — the workflow-builder agent then knows the tool's
+ * shape is opaque and must reshape via mapping.
+ */
+export declare function extractJsonSchema(maybeSchema: unknown, direction: 'input' | 'output'): unknown | undefined;
+//# sourceMappingURL=extract-json-schema.d.ts.map

package/dist/tools/workflows/extract-json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-json-schema.d.ts","sourceRoot":"","sources":["../../../src/tools/workflows/extract-json-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAc1G"}

package/dist/tools/workflows/extract-json-schema.js

@@ -0,0 +1,22 @@
+//#region src/tools/workflows/extract-json-schema.ts
+/**
+* Extract a JSON Schema from a Mastra tool's schema field. Tools created via
+* `createTool({...})` wrap their Zod schemas with `toStandardSchema`, exposing
+* `['~standard'].jsonSchema` as a `{ input(opts), output(opts) }` converter
+* (see packages/schema-compat/src/standard-schema/adapters/zod-v3.ts:110-119).
+* `direction` selects which side — pass 'input' for inputSchema, 'output' for
+* outputSchema. Returns undefined if the schema is missing or not
+* standard-schema-compliant — the workflow-builder agent then knows the tool's
+* shape is opaque and must reshape via mapping.
+*/
+function extractJsonSchema(maybeSchema, direction) {
+	try {
+		return (maybeSchema?.["~standard"]?.jsonSchema)?.[direction]?.({ target: "draft-2020-12" });
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { extractJsonSchema };
+
+//# sourceMappingURL=extract-json-schema.js.map

package/dist/tools/workflows/extract-json-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-json-schema.js","names":["s"],"sources":["../../../src/tools/workflows/extract-json-schema.ts"],"sourcesContent":["/**\n * Extract a JSON Schema from a Mastra tool's schema field. Tools created via\n * `createTool({...})` wrap their Zod schemas with `toStandardSchema`, exposing\n * `['~standard'].jsonSchema` as a `{ input(opts), output(opts) }` converter\n * (see packages/schema-compat/src/standard-schema/adapters/zod-v3.ts:110-119).\n * `direction` selects which side — pass 'input' for inputSchema, 'output' for\n * outputSchema. Returns undefined if the schema is missing or not\n * standard-schema-compliant — the workflow-builder agent then knows the tool's\n * shape is opaque and must reshape via mapping.\n */\nexport function extractJsonSchema(maybeSchema: unknown, direction: 'input' | 'output'): unknown | undefined {\n  try {\n    const s = maybeSchema as\n      | {\n          ['~standard']?: {\n            jsonSchema?: { input?: (opts: unknown) => unknown; output?: (opts: unknown) => unknown };\n          };\n        }\n      | undefined;\n    const converter = s?.['~standard']?.jsonSchema;\n    return converter?.[direction]?.({ target: 'draft-2020-12' });\n  } catch {\n    return undefined;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAUA,SAAgB,kBAAkB,aAAsB,WAAoD;CAC1G,IAAI;EASF,QADkBA,cAAI,YAAY,EAAE,WAAA,GACjB,UAAU,GAAG,EAAE,QAAQ,gBAAgB,CAAC;CAC7D,QAAQ;EACN;CACF;AACF"}

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

@@ -0,0 +1,11 @@
+export declare const getWorkflowTool: import("@mastra/core/tools").Tool<{
+    id: string;
+}, {
+    id: string;
+    status: "active" | "archived";
+    description?: string | undefined;
+    inputSchema?: any;
+    outputSchema?: any;
+    graph?: any[] | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "get-workflow", unknown>;
+//# sourceMappingURL=get-workflow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-workflow.d.ts","sourceRoot":"","sources":["../../../src/tools/workflows/get-workflow.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,eAAe;;;;;;;;;2HA2B1B,CAAC"}

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

@@ -0,0 +1,34 @@
+import { getWorkflow } from "../../workflows/service.js";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+//#region src/tools/workflows/get-workflow.ts
+const getWorkflowTool = createTool({
+	id: "get-workflow",
+	description: "Return the full stored definition of a workflow (input/output schemas + the step graph).",
+	inputSchema: z.object({ id: z.string().describe("The workflow id.") }),
+	outputSchema: z.object({
+		id: z.string(),
+		description: z.string().optional(),
+		status: z.enum(["active", "archived"]),
+		inputSchema: z.any().optional(),
+		outputSchema: z.any().optional(),
+		graph: z.array(z.any()).optional()
+	}),
+	execute: async ({ id }, { mastra }) => {
+		if (!mastra) throw new Error("get-workflow requires a Mastra context.");
+		const def = await getWorkflow(mastra, id);
+		if (!def) throw new Error(`No workflow with id "${id}".`);
+		return {
+			id: def.id,
+			description: def.description,
+			status: def.status,
+			inputSchema: def.inputSchema,
+			outputSchema: def.outputSchema,
+			graph: def.graph
+		};
+	}
+});
+//#endregion
+export { getWorkflowTool };
+
+//# sourceMappingURL=get-workflow.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-workflow.js","names":[],"sources":["../../../src/tools/workflows/get-workflow.ts"],"sourcesContent":["/**\n * Parent-mode tool: inspect a saved workflow's full definition.\n */\nimport type { Mastra } from '@mastra/core/mastra';\nimport { createTool } from '@mastra/core/tools';\nimport { z } from 'zod';\nimport { getWorkflow } from '../../workflows/service.js';\n\nexport const getWorkflowTool = createTool({\n  id: 'get-workflow',\n  description: 'Return the full stored definition of a workflow (input/output schemas + the step graph).',\n  inputSchema: z.object({\n    id: z.string().describe('The workflow id.'),\n  }),\n  outputSchema: z.object({\n    id: z.string(),\n    description: z.string().optional(),\n    status: z.enum(['active', 'archived']),\n    inputSchema: z.any().optional(),\n    outputSchema: z.any().optional(),\n    graph: z.array(z.any()).optional(),\n  }),\n  execute: async ({ id }, { mastra }) => {\n    if (!mastra) throw new Error('get-workflow requires a Mastra context.');\n    const def = await getWorkflow(mastra as Mastra, id);\n    if (!def) throw new Error(`No workflow with id \"${id}\".`);\n    return {\n      id: def.id,\n      description: def.description,\n      status: def.status,\n      inputSchema: def.inputSchema,\n      outputSchema: def.outputSchema,\n      graph: def.graph,\n    };\n  },\n});\n"],"mappings":";;;;AAQA,MAAa,kBAAkB,WAAW;CACxC,IAAI;CACJ,aAAa;CACb,aAAa,EAAE,OAAO,EACpB,IAAI,EAAE,OAAO,CAAC,CAAC,SAAS,kBAAkB,EAC5C,CAAC;CACD,cAAc,EAAE,OAAO;EACrB,IAAI,EAAE,OAAO;EACb,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS;EACjC,QAAQ,EAAE,KAAK,CAAC,UAAU,UAAU,CAAC;EACrC,aAAa,EAAE,IAAI,CAAC,CAAC,SAAS;EAC9B,cAAc,EAAE,IAAI,CAAC,CAAC,SAAS;EAC/B,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,SAAS;CACnC,CAAC;CACD,SAAS,OAAO,EAAE,MAAM,EAAE,aAAa;EACrC,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,yCAAyC;EACtE,MAAM,MAAM,MAAM,YAAY,QAAkB,EAAE;EAClD,IAAI,CAAC,KAAK,MAAM,IAAI,MAAM,wBAAwB,GAAG,GAAG;EACxD,OAAO;GACL,IAAI,IAAI;GACR,aAAa,IAAI;GACjB,QAAQ,IAAI;GACZ,aAAa,IAAI;GACjB,cAAc,IAAI;GAClB,OAAO,IAAI;EACb;CACF;AACF,CAAC"}

package/dist/tools/workflows/list-available-agents.d.ts

@@ -0,0 +1,8 @@
+export declare const listAvailableAgentsTool: import("@mastra/core/tools").Tool<Record<string, never>, {
+    agents: {
+        id: string;
+        outputShape: string;
+        description?: string | undefined;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "list-available-agents", unknown>;
+//# sourceMappingURL=list-available-agents.d.ts.map

package/dist/tools/workflows/list-available-agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-available-agents.d.ts","sourceRoot":"","sources":["../../../src/tools/workflows/list-available-agents.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,uBAAuB;;;;;;oIA8BlC,CAAC"}

package/dist/tools/workflows/list-available-agents.js

@@ -0,0 +1,32 @@
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+//#region src/tools/workflows/list-available-agents.ts
+/**
+* Sub-agent tool: list agents the workflow-builder can reference in agent-step
+* entries of a Dynamic Workflow graph. Read-only.
+*/
+/** Self / management tools the workflow-builder shouldn't recursively try to compose. */
+const WORKFLOW_BUILDER_NOISE_AGENTS = /* @__PURE__ */ new Set(["workflow-builder"]);
+const listAvailableAgentsTool = createTool({
+	id: "list-available-agents",
+	description: "Returns the agents currently registered on the Mastra instance. The agent ids returned here are the only valid values you can put in `{ type: \"agent\", agentId }` graph entries. `outputShape` describes the default text output; an entry-level `outputSchema` replaces that default with structured output.",
+	inputSchema: z.object({}),
+	outputSchema: z.object({ agents: z.array(z.object({
+		id: z.string(),
+		description: z.string().optional(),
+		outputShape: z.string()
+	})) }),
+	execute: async (_input, { mastra }) => {
+		if (!mastra) throw new Error("list-available-agents requires a Mastra context.");
+		const all = mastra.listAgents?.() ?? {};
+		return { agents: Object.entries(all).filter(([id]) => !WORKFLOW_BUILDER_NOISE_AGENTS.has(id)).map(([id, a]) => ({
+			id,
+			description: a?.description,
+			outputShape: "Default: { text: string }. An entry-level outputSchema produces that schema instead."
+		})) };
+	}
+});
+//#endregion
+export { listAvailableAgentsTool };
+
+//# sourceMappingURL=list-available-agents.js.map

package/dist/tools/workflows/list-available-agents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-available-agents.js","names":[],"sources":["../../../src/tools/workflows/list-available-agents.ts"],"sourcesContent":["/**\n * Sub-agent tool: list agents the workflow-builder can reference in agent-step\n * entries of a Dynamic Workflow graph. Read-only.\n */\nimport { createTool } from '@mastra/core/tools';\nimport { z } from 'zod';\n\n/** Self / management tools the workflow-builder shouldn't recursively try to compose. */\nconst WORKFLOW_BUILDER_NOISE_AGENTS = new Set(['workflow-builder']);\n\nexport const listAvailableAgentsTool = createTool({\n  id: 'list-available-agents',\n  description:\n    'Returns the agents currently registered on the Mastra instance. The agent ids returned here are the only valid values you can put in `{ type: \"agent\", agentId }` graph entries. `outputShape` describes the default text output; an entry-level `outputSchema` replaces that default with structured output.',\n  inputSchema: z.object({}),\n  outputSchema: z.object({\n    agents: z.array(\n      z.object({\n        id: z.string(),\n        description: z.string().optional(),\n        // Human-readable string in v1. Could become a JSON Schema now that\n        // structuredOutput round-trips through the rehydrator\n        // (packages/core/src/workflows/rehydrate-workflow.ts).\n        outputShape: z.string(),\n      }),\n    ),\n  }),\n  execute: async (_input, { mastra }) => {\n    if (!mastra) throw new Error('list-available-agents requires a Mastra context.');\n    const all = (mastra as { listAgents?: () => Record<string, unknown> }).listAgents?.() ?? {};\n    return {\n      agents: Object.entries(all)\n        .filter(([id]) => !WORKFLOW_BUILDER_NOISE_AGENTS.has(id))\n        .map(([id, a]) => ({\n          id,\n          description: (a as { description?: string } | undefined)?.description,\n          outputShape: 'Default: { text: string }. An entry-level outputSchema produces that schema instead.',\n        })),\n    };\n  },\n});\n"],"mappings":";;;;;;;;AAQA,MAAM,gDAAgC,IAAI,IAAI,CAAC,kBAAkB,CAAC;AAElE,MAAa,0BAA0B,WAAW;CAChD,IAAI;CACJ,aACE;CACF,aAAa,EAAE,OAAO,CAAC,CAAC;CACxB,cAAc,EAAE,OAAO,EACrB,QAAQ,EAAE,MACR,EAAE,OAAO;EACP,IAAI,EAAE,OAAO;EACb,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS;EAIjC,aAAa,EAAE,OAAO;CACxB,CAAC,CACH,EACF,CAAC;CACD,SAAS,OAAO,QAAQ,EAAE,aAAa;EACrC,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,kDAAkD;EAC/E,MAAM,MAAO,OAA0D,aAAa,KAAK,CAAC;EAC1F,OAAO,EACL,QAAQ,OAAO,QAAQ,GAAG,CAAC,CACxB,QAAQ,CAAC,QAAQ,CAAC,8BAA8B,IAAI,EAAE,CAAC,CAAC,CACxD,KAAK,CAAC,IAAI,QAAQ;GACjB;GACA,aAAc,GAA4C;GAC1D,aAAa;EACf,EAAE,EACN;CACF;AACF,CAAC"}

package/dist/tools/workflows/list-available-tools.d.ts

@@ -0,0 +1,9 @@
+export declare const listAvailableToolsTool: import("@mastra/core/tools").Tool<Record<string, never>, {
+    tools: {
+        id: string;
+        description?: string | undefined;
+        inputSchema?: any;
+        outputSchema?: any;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "list-available-tools", unknown>;
+//# sourceMappingURL=list-available-tools.d.ts.map

package/dist/tools/workflows/list-available-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-available-tools.d.ts","sourceRoot":"","sources":["../../../src/tools/workflows/list-available-tools.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,sBAAsB;;;;;;;mIAgCjC,CAAC"}

package/dist/tools/workflows/list-available-tools.js

@@ -0,0 +1,40 @@
+import { WORKFLOW_BUILDER_NOISE_TOOL_IDS } from "./tool-ids.js";
+import { extractJsonSchema } from "./extract-json-schema.js";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+//#region src/tools/workflows/list-available-tools.ts
+/**
+* Sub-agent tool: list tools the workflow-builder can reference in tool-step
+* entries of a Dynamic Workflow graph. Returns JSON Schema for inputs/outputs
+* so the LLM has ground truth instead of guessing.
+*/
+/** Authoring and management tools are not valid workflow building blocks. */
+const WORKFLOW_BUILDER_NOISE_TOOLS = new Set(WORKFLOW_BUILDER_NOISE_TOOL_IDS);
+const listAvailableToolsTool = createTool({
+	id: "list-available-tools",
+	description: "Returns the tools currently registered on the Mastra instance. The tool ids returned here are the only valid values you can put in `{ type: \"tool\", toolId }` graph entries. Each row includes `inputSchema` and `outputSchema` as JSON Schema — read them to know what fields the tool accepts and emits; never invent field names.",
+	inputSchema: z.object({}),
+	outputSchema: z.object({ tools: z.array(z.object({
+		id: z.string(),
+		description: z.string().optional(),
+		inputSchema: z.any().optional(),
+		outputSchema: z.any().optional()
+	})) }),
+	execute: async (_input, { mastra }) => {
+		if (!mastra) throw new Error("list-available-tools requires a Mastra context.");
+		const all = mastra.listTools?.() ?? {};
+		return { tools: Object.entries(all).filter(([id]) => !WORKFLOW_BUILDER_NOISE_TOOLS.has(id)).map(([id, t]) => {
+			const tool = t;
+			return {
+				id,
+				description: tool?.description,
+				inputSchema: extractJsonSchema(tool?.inputSchema, "input"),
+				outputSchema: extractJsonSchema(tool?.outputSchema, "output")
+			};
+		}) };
+	}
+});
+//#endregion
+export { listAvailableToolsTool };
+
+//# sourceMappingURL=list-available-tools.js.map

package/dist/tools/workflows/list-available-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-available-tools.js","names":[],"sources":["../../../src/tools/workflows/list-available-tools.ts"],"sourcesContent":["/**\n * Sub-agent tool: list tools the workflow-builder can reference in tool-step\n * entries of a Dynamic Workflow graph. Returns JSON Schema for inputs/outputs\n * so the LLM has ground truth instead of guessing.\n */\nimport { createTool } from '@mastra/core/tools';\nimport { z } from 'zod';\nimport { extractJsonSchema } from './extract-json-schema.js';\nimport { WORKFLOW_BUILDER_NOISE_TOOL_IDS } from './tool-ids.js';\n\n/** Authoring and management tools are not valid workflow building blocks. */\nconst WORKFLOW_BUILDER_NOISE_TOOLS = new Set<string>(WORKFLOW_BUILDER_NOISE_TOOL_IDS);\n\nexport const listAvailableToolsTool = createTool({\n  id: 'list-available-tools',\n  description:\n    'Returns the tools currently registered on the Mastra instance. The tool ids returned here are the only valid values you can put in `{ type: \"tool\", toolId }` graph entries. Each row includes `inputSchema` and `outputSchema` as JSON Schema — read them to know what fields the tool accepts and emits; never invent field names.',\n  inputSchema: z.object({}),\n  outputSchema: z.object({\n    tools: z.array(\n      z.object({\n        id: z.string(),\n        description: z.string().optional(),\n        inputSchema: z.any().optional(),\n        outputSchema: z.any().optional(),\n      }),\n    ),\n  }),\n  execute: async (_input, { mastra }) => {\n    if (!mastra) throw new Error('list-available-tools requires a Mastra context.');\n    const all = (mastra as { listTools?: () => Record<string, unknown> }).listTools?.() ?? {};\n    return {\n      tools: Object.entries(all)\n        .filter(([id]) => !WORKFLOW_BUILDER_NOISE_TOOLS.has(id))\n        .map(([id, t]) => {\n          const tool = t as { description?: string; inputSchema?: unknown; outputSchema?: unknown } | undefined;\n          return {\n            id,\n            description: tool?.description,\n            inputSchema: extractJsonSchema(tool?.inputSchema, 'input'),\n            outputSchema: extractJsonSchema(tool?.outputSchema, 'output'),\n          };\n        }),\n    };\n  },\n});\n"],"mappings":";;;;;;;;;;;AAWA,MAAM,+BAA+B,IAAI,IAAY,+BAA+B;AAEpF,MAAa,yBAAyB,WAAW;CAC/C,IAAI;CACJ,aACE;CACF,aAAa,EAAE,OAAO,CAAC,CAAC;CACxB,cAAc,EAAE,OAAO,EACrB,OAAO,EAAE,MACP,EAAE,OAAO;EACP,IAAI,EAAE,OAAO;EACb,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS;EACjC,aAAa,EAAE,IAAI,CAAC,CAAC,SAAS;EAC9B,cAAc,EAAE,IAAI,CAAC,CAAC,SAAS;CACjC,CAAC,CACH,EACF,CAAC;CACD,SAAS,OAAO,QAAQ,EAAE,aAAa;EACrC,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,iDAAiD;EAC9E,MAAM,MAAO,OAAyD,YAAY,KAAK,CAAC;EACxF,OAAO,EACL,OAAO,OAAO,QAAQ,GAAG,CAAC,CACvB,QAAQ,CAAC,QAAQ,CAAC,6BAA6B,IAAI,EAAE,CAAC,CAAC,CACvD,KAAK,CAAC,IAAI,OAAO;GAChB,MAAM,OAAO;GACb,OAAO;IACL;IACA,aAAa,MAAM;IACnB,aAAa,kBAAkB,MAAM,aAAa,OAAO;IACzD,cAAc,kBAAkB,MAAM,cAAc,QAAQ;GAC9D;EACF,CAAC,EACL;CACF;AACF,CAAC"}

package/dist/tools/workflows/list-available-workflows.d.ts

@@ -0,0 +1,9 @@
+export declare const listAvailableWorkflowsTool: import("@mastra/core/tools").Tool<Record<string, never>, {
+    workflows: {
+        id: string;
+        description?: string | undefined;
+        inputSchema?: any;
+        outputSchema?: any;
+    }[];
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "list-available-workflows", unknown>;
+//# sourceMappingURL=list-available-workflows.d.ts.map

package/dist/tools/workflows/list-available-workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-available-workflows.d.ts","sourceRoot":"","sources":["../../../src/tools/workflows/list-available-workflows.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,0BAA0B;;;;;;;uIA8BrC,CAAC"}

package/dist/tools/workflows/list-available-workflows.js

@@ -0,0 +1,32 @@
+import { extractJsonSchema } from "./extract-json-schema.js";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+//#region src/tools/workflows/list-available-workflows.ts
+const listAvailableWorkflowsTool = createTool({
+	id: "list-available-workflows",
+	description: "Returns the workflows currently registered on the Mastra instance (both code-defined and dynamic). The ids returned here are the only valid values you can put in `{ type: \"workflow\", workflowId }` graph entries. Each row includes `inputSchema` and `outputSchema` as JSON Schema — read them to know what shape the nested workflow expects and produces; never invent field names.",
+	inputSchema: z.object({}),
+	outputSchema: z.object({ workflows: z.array(z.object({
+		id: z.string(),
+		description: z.string().optional(),
+		inputSchema: z.any().optional(),
+		outputSchema: z.any().optional()
+	})) }),
+	execute: async (_input, { mastra }) => {
+		if (!mastra) throw new Error("list-available-workflows requires a Mastra context.");
+		const all = mastra.listWorkflows?.() ?? {};
+		return { workflows: Object.entries(all).map(([id, wf]) => {
+			const w = wf;
+			return {
+				id,
+				description: w?.description,
+				inputSchema: extractJsonSchema(w?.inputSchema, "input"),
+				outputSchema: extractJsonSchema(w?.outputSchema, "output")
+			};
+		}) };
+	}
+});
+//#endregion
+export { listAvailableWorkflowsTool };
+
+//# sourceMappingURL=list-available-workflows.js.map

package/dist/tools/workflows/list-available-workflows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-available-workflows.js","names":[],"sources":["../../../src/tools/workflows/list-available-workflows.ts"],"sourcesContent":["/**\n * Sub-agent tool: list workflows the workflow-builder can reference in\n * `{ type: \"workflow\", workflowId }` graph entries. Includes both code-defined\n * and Dynamic Workflows, so the builder can nest one workflow inside another.\n * The pre-flight validator rejects self-references and dependency cycles.\n */\nimport type { Mastra } from '@mastra/core/mastra';\nimport { createTool } from '@mastra/core/tools';\nimport { z } from 'zod';\nimport { extractJsonSchema } from './extract-json-schema.js';\n\nexport const listAvailableWorkflowsTool = createTool({\n  id: 'list-available-workflows',\n  description:\n    'Returns the workflows currently registered on the Mastra instance (both code-defined and dynamic). The ids returned here are the only valid values you can put in `{ type: \"workflow\", workflowId }` graph entries. Each row includes `inputSchema` and `outputSchema` as JSON Schema — read them to know what shape the nested workflow expects and produces; never invent field names.',\n  inputSchema: z.object({}),\n  outputSchema: z.object({\n    workflows: z.array(\n      z.object({\n        id: z.string(),\n        description: z.string().optional(),\n        inputSchema: z.any().optional(),\n        outputSchema: z.any().optional(),\n      }),\n    ),\n  }),\n  execute: async (_input, { mastra }) => {\n    if (!mastra) throw new Error('list-available-workflows requires a Mastra context.');\n    const all = (mastra as Mastra).listWorkflows?.() ?? {};\n    return {\n      workflows: Object.entries(all).map(([id, wf]) => {\n        const w = wf as { description?: string; inputSchema?: unknown; outputSchema?: unknown } | undefined;\n        return {\n          id,\n          description: w?.description,\n          inputSchema: extractJsonSchema(w?.inputSchema, 'input'),\n          outputSchema: extractJsonSchema(w?.outputSchema, 'output'),\n        };\n      }),\n    };\n  },\n});\n"],"mappings":";;;;AAWA,MAAa,6BAA6B,WAAW;CACnD,IAAI;CACJ,aACE;CACF,aAAa,EAAE,OAAO,CAAC,CAAC;CACxB,cAAc,EAAE,OAAO,EACrB,WAAW,EAAE,MACX,EAAE,OAAO;EACP,IAAI,EAAE,OAAO;EACb,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS;EACjC,aAAa,EAAE,IAAI,CAAC,CAAC,SAAS;EAC9B,cAAc,EAAE,IAAI,CAAC,CAAC,SAAS;CACjC,CAAC,CACH,EACF,CAAC;CACD,SAAS,OAAO,QAAQ,EAAE,aAAa;EACrC,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,qDAAqD;EAClF,MAAM,MAAO,OAAkB,gBAAgB,KAAK,CAAC;EACrD,OAAO,EACL,WAAW,OAAO,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,QAAQ;GAC/C,MAAM,IAAI;GACV,OAAO;IACL;IACA,aAAa,GAAG;IAChB,aAAa,kBAAkB,GAAG,aAAa,OAAO;IACtD,cAAc,kBAAkB,GAAG,cAAc,QAAQ;GAC3D;EACF,CAAC,EACH;CACF;AACF,CAAC"}

package/dist/tools/workflows/list-workflows.d.ts

@@ -0,0 +1,9 @@
+export declare const listWorkflowsTool: import("@mastra/core/tools").Tool<Record<string, never>, {
+    workflows: {
+        id: string;
+        status: "active" | "archived";
+        description?: string | undefined;
+    }[];
+    total: number;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "list-workflows", unknown>;
+//# sourceMappingURL=list-workflows.d.ts.map

package/dist/tools/workflows/list-workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-workflows.d.ts","sourceRoot":"","sources":["../../../src/tools/workflows/list-workflows.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,iBAAiB;;;;;;;6HAsB5B,CAAC"}

package/dist/tools/workflows/list-workflows.js

@@ -0,0 +1,33 @@
+import { listWorkflows } from "../../workflows/service.js";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+//#region src/tools/workflows/list-workflows.ts
+const listWorkflowsTool = createTool({
+	id: "list-workflows",
+	description: "List active Dynamic Workflows persisted to storage. Returns id + description + status for each.",
+	inputSchema: z.object({}),
+	outputSchema: z.object({
+		workflows: z.array(z.object({
+			id: z.string(),
+			description: z.string().optional(),
+			status: z.enum(["active", "archived"])
+		})),
+		total: z.number()
+	}),
+	execute: async (_input, { mastra }) => {
+		if (!mastra) throw new Error("list-workflows requires a Mastra context.");
+		const { workflows, total } = await listWorkflows(mastra);
+		return {
+			workflows: workflows.map((wf) => ({
+				id: wf.id,
+				description: wf.description,
+				status: wf.status
+			})),
+			total
+		};
+	}
+});
+//#endregion
+export { listWorkflowsTool };
+
+//# sourceMappingURL=list-workflows.js.map

package/dist/tools/workflows/list-workflows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-workflows.js","names":[],"sources":["../../../src/tools/workflows/list-workflows.ts"],"sourcesContent":["/**\n * Parent-mode tool: list saved workflows. Read-only, available in all modes.\n */\nimport type { Mastra } from '@mastra/core/mastra';\nimport { createTool } from '@mastra/core/tools';\nimport { z } from 'zod';\nimport { listWorkflows } from '../../workflows/service.js';\n\nexport const listWorkflowsTool = createTool({\n  id: 'list-workflows',\n  description: 'List active Dynamic Workflows persisted to storage. Returns id + description + status for each.',\n  inputSchema: z.object({}),\n  outputSchema: z.object({\n    workflows: z.array(\n      z.object({\n        id: z.string(),\n        description: z.string().optional(),\n        status: z.enum(['active', 'archived']),\n      }),\n    ),\n    total: z.number(),\n  }),\n  execute: async (_input, { mastra }) => {\n    if (!mastra) throw new Error('list-workflows requires a Mastra context.');\n    const { workflows, total } = await listWorkflows(mastra as Mastra);\n    return {\n      workflows: workflows.map(wf => ({ id: wf.id, description: wf.description, status: wf.status })),\n      total,\n    };\n  },\n});\n"],"mappings":";;;;AAQA,MAAa,oBAAoB,WAAW;CAC1C,IAAI;CACJ,aAAa;CACb,aAAa,EAAE,OAAO,CAAC,CAAC;CACxB,cAAc,EAAE,OAAO;EACrB,WAAW,EAAE,MACX,EAAE,OAAO;GACP,IAAI,EAAE,OAAO;GACb,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS;GACjC,QAAQ,EAAE,KAAK,CAAC,UAAU,UAAU,CAAC;EACvC,CAAC,CACH;EACA,OAAO,EAAE,OAAO;CAClB,CAAC;CACD,SAAS,OAAO,QAAQ,EAAE,aAAa;EACrC,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,2CAA2C;EACxE,MAAM,EAAE,WAAW,UAAU,MAAM,cAAc,MAAgB;EACjE,OAAO;GACL,WAAW,UAAU,KAAI,QAAO;IAAE,IAAI,GAAG;IAAI,aAAa,GAAG;IAAa,QAAQ,GAAG;GAAO,EAAE;GAC9F;EACF;CACF;AACF,CAAC"}

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

@@ -0,0 +1,9 @@
+export declare const runWorkflowTool: import("@mastra/core/tools").Tool<{
+    workflowId: string;
+    inputData: any;
+}, {
+    status: string;
+    result?: any;
+    error?: any;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "run-workflow", unknown>;
+//# sourceMappingURL=run-workflow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run-workflow.d.ts","sourceRoot":"","sources":["../../../src/tools/workflows/run-workflow.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,eAAe;;;;;;;2HAkD1B,CAAC"}

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

@@ -0,0 +1,52 @@
+import { runWorkflow } from "../../workflows/service.js";
+import { withEphemeralMemory } from "./ephemeral-memory.js";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+//#region src/tools/workflows/run-workflow.ts
+const runWorkflowTool = createTool({
+	id: "run-workflow",
+	description: "Run a saved workflow by id with the provided input data. Returns the run result inline. Use when the user asks you to \"run X\", \"execute X\", or asks for the outcome of a saved workflow.",
+	inputSchema: z.object({
+		workflowId: z.string().describe("The id of the saved workflow to run."),
+		inputData: z.any().describe("The input object the workflow consumes. Must match the workflow inputSchema.")
+	}),
+	outputSchema: z.object({
+		status: z.string(),
+		result: z.any().optional(),
+		error: z.any().optional()
+	}),
+	execute: async ({ workflowId, inputData }, { mastra, requestContext }) => {
+		if (!mastra) throw new Error("run-workflow requires a Mastra context.");
+		return withEphemeralMemory(requestContext, async (ephemeralRequestContext) => {
+			const result = await runWorkflow(mastra, workflowId, inputData, ephemeralRequestContext);
+			if (result.status === "tripwire" && result.tripwire) return {
+				status: result.status,
+				error: `Tripwire: ${result.tripwire.reason ?? "unknown"} (processor: ${result.tripwire.processorId ?? "unknown"})`
+			};
+			let errorText;
+			if (result.error instanceof Error) {
+				errorText = `${result.error.name}: ${result.error.message}`;
+				const cause = result.error.cause;
+				if (cause) try {
+					errorText += ` | cause: ${JSON.stringify(cause, Object.getOwnPropertyNames(cause))}`;
+				} catch {
+					errorText += ` | cause: ${String(cause)}`;
+				}
+				if (result.error.stack) errorText += `\nstack: ${result.error.stack}`;
+			} else if (result.error) try {
+				errorText = JSON.stringify(result.error, Object.getOwnPropertyNames(result.error));
+			} catch {
+				errorText = String(result.error);
+			}
+			return {
+				status: result.status,
+				result: result.result,
+				error: errorText
+			};
+		});
+	}
+});
+//#endregion
+export { runWorkflowTool };
+
+//# sourceMappingURL=run-workflow.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run-workflow.js","names":[],"sources":["../../../src/tools/workflows/run-workflow.ts"],"sourcesContent":["/**\n * Parent-mode tool: run a saved workflow with input data. Returns the run\n * result inline so the parent agent can summarise / chain it.\n */\nimport type { Mastra } from '@mastra/core/mastra';\nimport { createTool } from '@mastra/core/tools';\nimport { z } from 'zod';\nimport { runWorkflow } from '../../workflows/service.js';\nimport { withEphemeralMemory } from './ephemeral-memory.js';\n\nexport const runWorkflowTool = createTool({\n  id: 'run-workflow',\n  description:\n    'Run a saved workflow by id with the provided input data. Returns the run result inline. Use when the user asks you to \"run X\", \"execute X\", or asks for the outcome of a saved workflow.',\n  inputSchema: z.object({\n    workflowId: z.string().describe('The id of the saved workflow to run.'),\n    inputData: z.any().describe('The input object the workflow consumes. Must match the workflow inputSchema.'),\n  }),\n  outputSchema: z.object({\n    status: z.string(),\n    result: z.any().optional(),\n    error: z.any().optional(),\n  }),\n  execute: async ({ workflowId, inputData }, { mastra, requestContext }) => {\n    if (!mastra) throw new Error('run-workflow requires a Mastra context.');\n    // Forward the caller's requestContext so agent steps can resolve dynamic\n    // model/tool bindings from session state, and swap the caller's chat\n    // memory scope for a fresh isolated one for the duration of the run so\n    // the workflow's agent step doesn't write into (or read from) the parent\n    // chat thread. See ephemeral-memory.ts.\n    return withEphemeralMemory(requestContext, async ephemeralRequestContext => {\n      const result = await runWorkflow(mastra as Mastra, workflowId, inputData, ephemeralRequestContext);\n      if (result.status === 'tripwire' && result.tripwire) {\n        return {\n          status: result.status,\n          error: `Tripwire: ${result.tripwire.reason ?? 'unknown'} (processor: ${result.tripwire.processorId ?? 'unknown'})`,\n        };\n      }\n      let errorText: string | undefined;\n      if (result.error instanceof Error) {\n        errorText = `${result.error.name}: ${result.error.message}`;\n        const cause = (result.error as { cause?: unknown }).cause;\n        if (cause) {\n          try {\n            errorText += ` | cause: ${JSON.stringify(cause, Object.getOwnPropertyNames(cause))}`;\n          } catch {\n            errorText += ` | cause: ${String(cause)}`;\n          }\n        }\n        if (result.error.stack) errorText += `\\nstack: ${result.error.stack}`;\n      } else if (result.error) {\n        try {\n          errorText = JSON.stringify(result.error, Object.getOwnPropertyNames(result.error));\n        } catch {\n          errorText = String(result.error);\n        }\n      }\n      return { status: result.status, result: result.result, error: errorText };\n    });\n  },\n});\n"],"mappings":";;;;;AAUA,MAAa,kBAAkB,WAAW;CACxC,IAAI;CACJ,aACE;CACF,aAAa,EAAE,OAAO;EACpB,YAAY,EAAE,OAAO,CAAC,CAAC,SAAS,sCAAsC;EACtE,WAAW,EAAE,IAAI,CAAC,CAAC,SAAS,8EAA8E;CAC5G,CAAC;CACD,cAAc,EAAE,OAAO;EACrB,QAAQ,EAAE,OAAO;EACjB,QAAQ,EAAE,IAAI,CAAC,CAAC,SAAS;EACzB,OAAO,EAAE,IAAI,CAAC,CAAC,SAAS;CAC1B,CAAC;CACD,SAAS,OAAO,EAAE,YAAY,aAAa,EAAE,QAAQ,qBAAqB;EACxE,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,yCAAyC;EAMtE,OAAO,oBAAoB,gBAAgB,OAAM,4BAA2B;GAC1E,MAAM,SAAS,MAAM,YAAY,QAAkB,YAAY,WAAW,uBAAuB;GACjG,IAAI,OAAO,WAAW,cAAc,OAAO,UACzC,OAAO;IACL,QAAQ,OAAO;IACf,OAAO,aAAa,OAAO,SAAS,UAAU,UAAU,eAAe,OAAO,SAAS,eAAe,UAAU;GAClH;GAEF,IAAI;GACJ,IAAI,OAAO,iBAAiB,OAAO;IACjC,YAAY,GAAG,OAAO,MAAM,KAAK,IAAI,OAAO,MAAM;IAClD,MAAM,QAAS,OAAO,MAA8B;IACpD,IAAI,OACF,IAAI;KACF,aAAa,aAAa,KAAK,UAAU,OAAO,OAAO,oBAAoB,KAAK,CAAC;IACnF,QAAQ;KACN,aAAa,aAAa,OAAO,KAAK;IACxC;IAEF,IAAI,OAAO,MAAM,OAAO,aAAa,YAAY,OAAO,MAAM;GAChE,OAAO,IAAI,OAAO,OAChB,IAAI;IACF,YAAY,KAAK,UAAU,OAAO,OAAO,OAAO,oBAAoB,OAAO,KAAK,CAAC;GACnF,QAAQ;IACN,YAAY,OAAO,OAAO,KAAK;GACjC;GAEF,OAAO;IAAE,QAAQ,OAAO;IAAQ,QAAQ,OAAO;IAAQ,OAAO;GAAU;EAC1E,CAAC;CACH;AACF,CAAC"}