@mastra/code-sdk 0.0.0-client-tool-results-20260912062135

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

@@ -0,0 +1,7 @@
+export interface CommonBinary {
+    name: string;
+    path: string | null;
+}
+export declare function detectCommonBinaries(): CommonBinary[];
+export declare function detectCommonBinariesAsync(): Promise<CommonBinary[]>;
+//# sourceMappingURL=binaries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"binaries.d.ts","sourceRoot":"","sources":["../../src/utils/binaries.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB;AAmDD,wBAAgB,oBAAoB,IAAI,YAAY,EAAE,CAOrD;AAED,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzE"}

package/dist/utils/binaries.js

@@ -0,0 +1,78 @@
+import { execFile, execFileSync } from "child_process";
+//#region src/utils/binaries.ts
+const COMMON_BINARIES = [
+	"python",
+	"python3",
+	"node",
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun",
+	"git",
+	"rg",
+	"fd",
+	"fdfind",
+	"curl",
+	"wget",
+	"docker",
+	"make",
+	"gcc",
+	"g++",
+	"go",
+	"rustc",
+	"cargo"
+];
+let cachedBinaries = null;
+let inFlightPromise = null;
+function resolveBinary(name) {
+	const command = process.platform === "win32" ? "where" : "which";
+	try {
+		return execFileSync(command, [name], {
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim().split(/\r?\n/)[0] || null;
+	} catch {
+		return null;
+	}
+}
+function resolveBinaryAsync(name) {
+	const command = process.platform === "win32" ? "where" : "which";
+	return new Promise((resolve) => {
+		execFile(command, [name], { encoding: "utf-8" }, (err, stdout) => {
+			if (err) {
+				resolve(null);
+				return;
+			}
+			resolve(stdout.trim().split(/\r?\n/)[0] || null);
+		});
+	});
+}
+function detectCommonBinaries() {
+	cachedBinaries ??= COMMON_BINARIES.map((name) => ({
+		name,
+		path: resolveBinary(name)
+	}));
+	return cachedBinaries;
+}
+async function detectCommonBinariesAsync() {
+	if (cachedBinaries) return cachedBinaries;
+	if (inFlightPromise) return inFlightPromise;
+	inFlightPromise = Promise.all(COMMON_BINARIES.map(async (name) => ({
+		name,
+		path: await resolveBinaryAsync(name)
+	})));
+	try {
+		cachedBinaries = await inFlightPromise;
+		return cachedBinaries;
+	} finally {
+		inFlightPromise = null;
+	}
+}
+//#endregion
+export { detectCommonBinaries, detectCommonBinariesAsync };
+
+//# sourceMappingURL=binaries.js.map

package/dist/utils/binaries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binaries.js","names":[],"sources":["../../src/utils/binaries.ts"],"sourcesContent":["import { execFile, execFileSync } from 'node:child_process';\n\nexport interface CommonBinary {\n  name: string;\n  path: string | null;\n}\n\nconst COMMON_BINARIES = [\n  'python',\n  'python3',\n  'node',\n  'npm',\n  'pnpm',\n  'yarn',\n  'bun',\n  'git',\n  'rg',\n  'fd',\n  'fdfind',\n  'curl',\n  'wget',\n  'docker',\n  'make',\n  'gcc',\n  'g++',\n  'go',\n  'rustc',\n  'cargo',\n] as const;\n\nlet cachedBinaries: CommonBinary[] | null = null;\nlet inFlightPromise: Promise<CommonBinary[]> | null = null;\n\nfunction resolveBinary(name: string): string | null {\n  const command = process.platform === 'win32' ? 'where' : 'which';\n  try {\n    const output = execFileSync(command, [name], { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();\n    return output.split(/\\r?\\n/)[0] || null;\n  } catch {\n    return null;\n  }\n}\n\nfunction resolveBinaryAsync(name: string): Promise<string | null> {\n  const command = process.platform === 'win32' ? 'where' : 'which';\n  return new Promise(resolve => {\n    execFile(command, [name], { encoding: 'utf-8' }, (err, stdout) => {\n      if (err) {\n        resolve(null);\n        return;\n      }\n      resolve(stdout.trim().split(/\\r?\\n/)[0] || null);\n    });\n  });\n}\n\nexport function detectCommonBinaries(): CommonBinary[] {\n  cachedBinaries ??= COMMON_BINARIES.map(name => ({\n    name,\n    path: resolveBinary(name),\n  }));\n\n  return cachedBinaries;\n}\n\nexport async function detectCommonBinariesAsync(): Promise<CommonBinary[]> {\n  if (cachedBinaries) return cachedBinaries;\n  if (inFlightPromise) return inFlightPromise;\n\n  inFlightPromise = Promise.all(\n    COMMON_BINARIES.map(async name => ({\n      name,\n      path: await resolveBinaryAsync(name),\n    })),\n  );\n\n  try {\n    cachedBinaries = await inFlightPromise;\n    return cachedBinaries;\n  } finally {\n    inFlightPromise = null;\n  }\n}\n"],"mappings":";;AAOA,MAAM,kBAAkB;CACtB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,IAAI,iBAAwC;AAC5C,IAAI,kBAAkD;AAEtD,SAAS,cAAc,MAA6B;CAClD,MAAM,UAAU,QAAQ,aAAa,UAAU,UAAU;CACzD,IAAI;EAEF,OADe,aAAa,SAAS,CAAC,IAAI,GAAG;GAAE,UAAU;GAAS,OAAO;IAAC;IAAQ;IAAQ;GAAM;EAAE,CAAC,CAAC,CAAC,KACzF,CAAC,CAAC,MAAM,OAAO,CAAC,CAAC,MAAM;CACrC,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAS,mBAAmB,MAAsC;CAChE,MAAM,UAAU,QAAQ,aAAa,UAAU,UAAU;CACzD,OAAO,IAAI,SAAQ,YAAW;EAC5B,SAAS,SAAS,CAAC,IAAI,GAAG,EAAE,UAAU,QAAQ,IAAI,KAAK,WAAW;GAChE,IAAI,KAAK;IACP,QAAQ,IAAI;IACZ;GACF;GACA,QAAQ,OAAO,KAAK,CAAC,CAAC,MAAM,OAAO,CAAC,CAAC,MAAM,IAAI;EACjD,CAAC;CACH,CAAC;AACH;AAEA,SAAgB,uBAAuC;CACrD,mBAAmB,gBAAgB,KAAI,UAAS;EAC9C;EACA,MAAM,cAAc,IAAI;CAC1B,EAAE;CAEF,OAAO;AACT;AAEA,eAAsB,4BAAqD;CACzE,IAAI,gBAAgB,OAAO;CAC3B,IAAI,iBAAiB,OAAO;CAE5B,kBAAkB,QAAQ,IACxB,gBAAgB,IAAI,OAAM,UAAS;EACjC;EACA,MAAM,MAAM,mBAAmB,IAAI;CACrC,EAAE,CACJ;CAEA,IAAI;EACF,iBAAiB,MAAM;EACvB,OAAO;CACT,UAAU;EACR,kBAAkB;CACpB;AACF"}

package/dist/utils/debug-log.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Truncate a log file to roughly {@link KEEP_SIZE} bytes if it exceeds
+ * {@link MAX_LOG_SIZE}, cutting at the first newline so we don't start mid-line.
+ */
+export declare function truncateLogFile(logFile: string): void;
+/**
+ * Set up debug logging. When {@link MASTRA_DEBUG} is `"true"`, redirects
+ * `console.error` and `console.warn` to a log file (truncating it first if
+ * oversized). Otherwise silences them to avoid corrupting the TUI.
+ */
+export declare function setupDebugLogging(): void;
+//# sourceMappingURL=debug-log.d.ts.map

package/dist/utils/debug-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-log.d.ts","sourceRoot":"","sources":["../../src/utils/debug-log.ts"],"names":[],"mappings":"AAQA;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAerD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CA4BxC"}

package/dist/utils/debug-log.js

@@ -0,0 +1,59 @@
+import { getAppDataDir } from "./project.js";
+import * as fs$1 from "fs";
+import * as path$1 from "path";
+//#region src/utils/debug-log.ts
+const MAX_LOG_SIZE = 5 * 1024 * 1024;
+const KEEP_SIZE = 4 * 1024 * 1024;
+/**
+* Truncate a log file to roughly {@link KEEP_SIZE} bytes if it exceeds
+* {@link MAX_LOG_SIZE}, cutting at the first newline so we don't start mid-line.
+*/
+function truncateLogFile(logFile) {
+	try {
+		const stat = fs$1.statSync(logFile);
+		if (stat.size > MAX_LOG_SIZE) {
+			const buf = Buffer.alloc(KEEP_SIZE);
+			const fd = fs$1.openSync(logFile, "r");
+			fs$1.readSync(fd, buf, 0, KEEP_SIZE, stat.size - KEEP_SIZE);
+			fs$1.closeSync(fd);
+			const firstNewline = buf.indexOf(10);
+			const trimmed = firstNewline >= 0 ? buf.subarray(firstNewline + 1) : buf;
+			fs$1.writeFileSync(logFile, trimmed);
+		}
+	} catch {}
+}
+/**
+* Set up debug logging. When {@link MASTRA_DEBUG} is `"true"`, redirects
+* `console.error` and `console.warn` to a log file (truncating it first if
+* oversized). Otherwise silences them to avoid corrupting the TUI.
+*/
+function setupDebugLogging() {
+	if (["true", "1"].includes(process.env.MASTRA_DEBUG ?? "")) {
+		const logFile = path$1.join(getAppDataDir(), "debug.log");
+		truncateLogFile(logFile);
+		const logStream = fs$1.createWriteStream(logFile, { flags: "a" });
+		const fmt = (a) => {
+			if (typeof a === "string") return a;
+			if (a instanceof Error) return a.stack ?? `${a.name}: ${a.message}`;
+			try {
+				return JSON.stringify(a);
+			} catch {
+				return String(a);
+			}
+		};
+		console.error = (...args) => {
+			logStream.write(`[ERROR] ${(/* @__PURE__ */ new Date()).toISOString()} ${args.map(fmt).join(" ")}\n`);
+		};
+		console.warn = (...args) => {
+			logStream.write(`[WARN] ${(/* @__PURE__ */ new Date()).toISOString()} ${args.map(fmt).join(" ")}\n`);
+		};
+	} else {
+		const noop = () => {};
+		console.error = noop;
+		console.warn = noop;
+	}
+}
+//#endregion
+export { setupDebugLogging, truncateLogFile };
+
+//# sourceMappingURL=debug-log.js.map

package/dist/utils/debug-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-log.js","names":["fs","path"],"sources":["../../src/utils/debug-log.ts"],"sourcesContent":["import * as fs from 'node:fs';\nimport * as path from 'node:path';\n\nimport { getAppDataDir } from './project.js';\n\nconst MAX_LOG_SIZE = 5 * 1024 * 1024; // 5 MB\nconst KEEP_SIZE = 4 * 1024 * 1024; // 4 MB\n\n/**\n * Truncate a log file to roughly {@link KEEP_SIZE} bytes if it exceeds\n * {@link MAX_LOG_SIZE}, cutting at the first newline so we don't start mid-line.\n */\nexport function truncateLogFile(logFile: string): void {\n  try {\n    const stat = fs.statSync(logFile);\n    if (stat.size > MAX_LOG_SIZE) {\n      const buf = Buffer.alloc(KEEP_SIZE);\n      const fd = fs.openSync(logFile, 'r');\n      fs.readSync(fd, buf, 0, KEEP_SIZE, stat.size - KEEP_SIZE);\n      fs.closeSync(fd);\n      const firstNewline = buf.indexOf(10);\n      const trimmed = firstNewline >= 0 ? buf.subarray(firstNewline + 1) : buf;\n      fs.writeFileSync(logFile, trimmed);\n    }\n  } catch {\n    // File may not exist yet — that's fine\n  }\n}\n\n/**\n * Set up debug logging. When {@link MASTRA_DEBUG} is `\"true\"`, redirects\n * `console.error` and `console.warn` to a log file (truncating it first if\n * oversized). Otherwise silences them to avoid corrupting the TUI.\n */\nexport function setupDebugLogging(): void {\n  const debugEnabled = ['true', '1'].includes(process.env.MASTRA_DEBUG ?? '');\n\n  if (debugEnabled) {\n    const logFile = path.join(getAppDataDir(), 'debug.log');\n    truncateLogFile(logFile);\n\n    const logStream = fs.createWriteStream(logFile, { flags: 'a' });\n    const fmt = (a: unknown): string => {\n      if (typeof a === 'string') return a;\n      if (a instanceof Error) return a.stack ?? `${a.name}: ${a.message}`;\n      try {\n        return JSON.stringify(a);\n      } catch {\n        return String(a);\n      }\n    };\n    console.error = (...args: unknown[]) => {\n      logStream.write(`[ERROR] ${new Date().toISOString()} ${args.map(fmt).join(' ')}\\n`);\n    };\n    console.warn = (...args: unknown[]) => {\n      logStream.write(`[WARN] ${new Date().toISOString()} ${args.map(fmt).join(' ')}\\n`);\n    };\n  } else {\n    const noop = () => {};\n    console.error = noop;\n    console.warn = noop;\n  }\n}\n"],"mappings":";;;;AAKA,MAAM,eAAe,IAAI,OAAO;AAChC,MAAM,YAAY,IAAI,OAAO;;;;;AAM7B,SAAgB,gBAAgB,SAAuB;CACrD,IAAI;EACF,MAAM,OAAOA,KAAG,SAAS,OAAO;EAChC,IAAI,KAAK,OAAO,cAAc;GAC5B,MAAM,MAAM,OAAO,MAAM,SAAS;GAClC,MAAM,KAAKA,KAAG,SAAS,SAAS,GAAG;GACnC,KAAG,SAAS,IAAI,KAAK,GAAG,WAAW,KAAK,OAAO,SAAS;GACxD,KAAG,UAAU,EAAE;GACf,MAAM,eAAe,IAAI,QAAQ,EAAE;GACnC,MAAM,UAAU,gBAAgB,IAAI,IAAI,SAAS,eAAe,CAAC,IAAI;GACrE,KAAG,cAAc,SAAS,OAAO;EACnC;CACF,QAAQ,CAER;AACF;;;;;;AAOA,SAAgB,oBAA0B;CAGxC,IAFqB,CAAC,QAAQ,GAAG,CAAC,CAAC,SAAS,QAAQ,IAAI,gBAAgB,EAEzD,GAAG;EAChB,MAAM,UAAUC,OAAK,KAAK,cAAc,GAAG,WAAW;EACtD,gBAAgB,OAAO;EAEvB,MAAM,YAAYD,KAAG,kBAAkB,SAAS,EAAE,OAAO,IAAI,CAAC;EAC9D,MAAM,OAAO,MAAuB;GAClC,IAAI,OAAO,MAAM,UAAU,OAAO;GAClC,IAAI,aAAa,OAAO,OAAO,EAAE,SAAS,GAAG,EAAE,KAAK,IAAI,EAAE;GAC1D,IAAI;IACF,OAAO,KAAK,UAAU,CAAC;GACzB,QAAQ;IACN,OAAO,OAAO,CAAC;GACjB;EACF;EACA,QAAQ,SAAS,GAAG,SAAoB;GACtC,UAAU,MAAM,4BAAW,IAAI,KAAK,EAAA,CAAE,YAAY,EAAE,GAAG,KAAK,IAAI,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,GAAG;EACpF;EACA,QAAQ,QAAQ,GAAG,SAAoB;GACrC,UAAU,MAAM,2BAAU,IAAI,KAAK,EAAA,CAAE,YAAY,EAAE,GAAG,KAAK,IAAI,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,GAAG;EACnF;CACF,OAAO;EACL,MAAM,aAAa,CAAC;EACpB,QAAQ,QAAQ;EAChB,QAAQ,OAAO;CACjB;AACF"}

package/dist/utils/errors.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Error handling utilities for the Mastra Code TUI.
+ * Parses API errors and provides user-friendly messages.
+ */
+export interface ParsedError {
+    /** User-friendly error message */
+    message: string;
+    /** Extra diagnostic detail to surface to the user */
+    detail?: string;
+    /** Request URL involved in the failure, when available */
+    requestUrl?: string;
+    /** Error type for categorization */
+    type: ErrorType;
+    /** Whether this error is retryable */
+    retryable: boolean;
+    /** Suggested retry delay in ms (if retryable) */
+    retryDelay?: number;
+    /** Original error for debugging */
+    originalError: Error;
+}
+export type ErrorType = 'rate_limit' | 'auth' | 'network' | 'timeout' | 'invalid_request' | 'server_error' | 'model_not_found' | 'context_length' | 'content_filter' | 'unknown';
+export declare function parseError(error: unknown): ParsedError;
+/**
+ * Sleep for a given number of milliseconds.
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Retry a function with exponential backoff.
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: {
+    maxRetries?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    onRetry?: (error: ParsedError, attempt: number) => void;
+}): Promise<T>;
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/utils/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,WAAW;IAC1B,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oCAAoC;IACpC,IAAI,EAAE,SAAS,CAAC;IAChB,sCAAsC;IACtC,SAAS,EAAE,OAAO,CAAC;IACnB,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mCAAmC;IACnC,aAAa,EAAE,KAAK,CAAC;CACtB;AAED,MAAM,MAAM,SAAS,GACjB,YAAY,GACZ,MAAM,GACN,SAAS,GACT,SAAS,GACT,iBAAiB,GACjB,cAAc,GACd,iBAAiB,GACjB,gBAAgB,GAChB,gBAAgB,GAChB,SAAS,CAAC;AAiFd,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAqLtD;AAkDD;;GAEG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC/B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,GAAE;IACP,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACpD,GACL,OAAO,CAAC,CAAC,CAAC,CA6BZ"}

package/dist/utils/errors.js

@@ -0,0 +1,196 @@
+import "../auth/provider-auth-error.js";
+//#region src/utils/errors.ts
+/**
+* Error handling utilities for the Mastra Code TUI.
+* Parses API errors and provides user-friendly messages.
+*/
+/**
+* Parse an error and return a user-friendly representation.
+*/
+function summarizeErrorDetail(error) {
+	if (error instanceof Error) {
+		if (error.cause instanceof Error && error.cause.message) return error.cause.message;
+		if (typeof error.cause === "string" && error.cause.trim().length > 0) return error.cause;
+		if (error.message.trim().length > 0) return error.message;
+	}
+	if (typeof error === "string" && error.trim().length > 0) return error;
+	if (error && typeof error === "object") {
+		const errorObj = error;
+		const candidates = [
+			errorObj["message"],
+			errorObj["cause"],
+			errorObj["code"],
+			errorObj["statusText"]
+		];
+		for (const candidate of candidates) if (typeof candidate === "string" && candidate.trim().length > 0) return candidate;
+	}
+}
+function extractRequestUrl(error) {
+	if (!error || typeof error !== "object") return;
+	const candidates = [];
+	const errorObj = error;
+	candidates.push(errorObj["requestUrl"], errorObj["url"]);
+	if (errorObj["cause"] && typeof errorObj["cause"] === "object") {
+		const causeObj = errorObj["cause"];
+		candidates.push(causeObj["requestUrl"], causeObj["url"]);
+	}
+	for (const candidate of candidates) if (typeof candidate === "string" && candidate.trim().length > 0) return candidate;
+}
+/** A flattened error crossing the wire: the server sends `{ name, message }`, not an `Error`. */
+function isSerializedError(value) {
+	return typeof value === "object" && value !== null && "name" in value && typeof value.name === "string" && "message" in value && typeof value.message === "string";
+}
+function toError(error) {
+	if (error instanceof Error) return error;
+	if (!isSerializedError(error)) return new Error(String(error));
+	const rebuilt = new Error(error.message);
+	rebuilt.name = error.name;
+	return rebuilt;
+}
+function parseError(error) {
+	const err = toError(error);
+	const message = err.message.toLowerCase();
+	const errorObj = error;
+	const detail = summarizeErrorDetail(error);
+	const requestUrl = extractRequestUrl(error);
+	if (err.name === "ProviderAuthRequiredError") return {
+		message: err.message,
+		detail,
+		requestUrl,
+		type: "auth",
+		retryable: false,
+		originalError: err
+	};
+	if (message.includes("rate limit") || message.includes("rate_limit") || message.includes("429") || errorObj.statusCode === 429 || errorObj.status === 429) return {
+		message: "Rate limited. Please wait a moment before trying again.",
+		type: "rate_limit",
+		retryable: true,
+		retryDelay: extractRetryAfter(errorObj) || 5e3,
+		originalError: err
+	};
+	if (message.includes("unauthorized") || message.includes("authentication") || message.includes("invalid api key") || message.includes("invalid_api_key") || message.includes("api key") || errorObj.statusCode === 401 || errorObj.status === 401) return {
+		message: "Authentication failed. Check the credential configured for this provider.",
+		detail,
+		requestUrl,
+		type: "auth",
+		retryable: false,
+		originalError: err
+	};
+	if (errorObj.statusCode === 403 || errorObj.status === 403) return {
+		message: "Access denied. You may not have permission to use this model.",
+		detail,
+		requestUrl,
+		type: "auth",
+		retryable: false,
+		originalError: err
+	};
+	if (message.includes("network") || message.includes("econnrefused") || message.includes("enotfound") || message.includes("fetch failed") || message.includes("connection")) return {
+		message: "Network error while contacting the provider or gateway.",
+		detail,
+		requestUrl,
+		type: "network",
+		retryable: true,
+		retryDelay: 2e3,
+		originalError: err
+	};
+	if (message.includes("timeout") || message.includes("timed out") || message.includes("etimedout")) return {
+		message: "Request timed out. The server may be overloaded.",
+		type: "timeout",
+		retryable: true,
+		retryDelay: 3e3,
+		originalError: err
+	};
+	if (message.includes("model not found") || message.includes("model_not_found") || message.includes("does not exist") || message.includes("invalid model")) return {
+		message: "Model not found. Please select a different model with /models.",
+		type: "model_not_found",
+		retryable: false,
+		originalError: err
+	};
+	if (message.includes("context length") || message.includes("context_length") || message.includes("too many tokens") || message.includes("maximum context") || message.includes("token limit")) return {
+		message: "Message too long. Try starting a new thread with /new.",
+		type: "context_length",
+		retryable: false,
+		originalError: err
+	};
+	if (message.includes("content filter") || message.includes("content_filter") || message.includes("content policy") || message.includes("safety") || message.includes("prohibited")) return {
+		message: "Content was filtered by the model's safety system.",
+		type: "content_filter",
+		retryable: false,
+		originalError: err
+	};
+	if (message.includes("internal server") || message.includes("server error") || errorObj.statusCode === 500 || errorObj.status === 500 || errorObj.statusCode === 502 || errorObj.status === 502 || errorObj.statusCode === 503 || errorObj.status === 503) return {
+		message: "Server error. The API may be experiencing issues.",
+		type: "server_error",
+		retryable: true,
+		retryDelay: 5e3,
+		originalError: err
+	};
+	if (message.includes("invalid request") || message.includes("bad request") || errorObj.statusCode === 400 || errorObj.status === 400) return {
+		message: `Invalid request: ${extractErrorDetail(err)}`,
+		type: "invalid_request",
+		retryable: false,
+		originalError: err
+	};
+	return {
+		message: extractErrorDetail(err),
+		type: "unknown",
+		retryable: false,
+		originalError: err
+	};
+}
+/**
+* Extract retry-after header value from error.
+*/
+function extractRetryAfter(error) {
+	const headers = error.headers;
+	const retryAfter = error.retryAfter || headers?.["retry-after"];
+	if (typeof retryAfter === "number") return retryAfter * 1e3;
+	if (typeof retryAfter === "string") {
+		const seconds = parseInt(retryAfter, 10);
+		if (!isNaN(seconds)) return seconds * 1e3;
+	}
+}
+/**
+* Extract a useful error detail from an error object.
+*/
+function extractErrorDetail(error) {
+	const errorObj = error;
+	if (errorObj.error && typeof errorObj.error === "object") {
+		const apiError = errorObj.error;
+		if (apiError.message) return String(apiError.message);
+	}
+	if (errorObj.message) return String(errorObj.message);
+	if (errorObj.detail) return String(errorObj.detail);
+	if (errorObj.reason) return String(errorObj.reason);
+	let message = error.message;
+	message = message.replace(/^(error|exception|failed):\s*/i, "");
+	if (message.length > 200) message = message.substring(0, 200) + "...";
+	return message || "An unknown error occurred";
+}
+/**
+* Sleep for a given number of milliseconds.
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Retry a function with exponential backoff.
+*/
+async function withRetry(fn, options = {}) {
+	const { maxRetries = 3, initialDelay = 1e3, maxDelay = 3e4, onRetry } = options;
+	let lastError;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		return await fn();
+	} catch (error) {
+		lastError = parseError(error);
+		if (!lastError.retryable || attempt === maxRetries) throw lastError.originalError;
+		const delay = Math.min(lastError.retryDelay || initialDelay * Math.pow(2, attempt), maxDelay);
+		if (onRetry) onRetry(lastError, attempt + 1);
+		await sleep(delay);
+	}
+	throw lastError?.originalError || /* @__PURE__ */ new Error("Retry failed");
+}
+//#endregion
+export { parseError, sleep, withRetry };
+
+//# sourceMappingURL=errors.js.map

package/dist/utils/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../../src/utils/errors.ts"],"sourcesContent":["/**\n * Error handling utilities for the Mastra Code TUI.\n * Parses API errors and provides user-friendly messages.\n */\n\nimport { PROVIDER_AUTH_REQUIRED_ERROR } from '../auth/provider-auth-error.js';\n\nexport interface ParsedError {\n  /** User-friendly error message */\n  message: string;\n  /** Extra diagnostic detail to surface to the user */\n  detail?: string;\n  /** Request URL involved in the failure, when available */\n  requestUrl?: string;\n  /** Error type for categorization */\n  type: ErrorType;\n  /** Whether this error is retryable */\n  retryable: boolean;\n  /** Suggested retry delay in ms (if retryable) */\n  retryDelay?: number;\n  /** Original error for debugging */\n  originalError: Error;\n}\n\nexport type ErrorType =\n  | 'rate_limit'\n  | 'auth'\n  | 'network'\n  | 'timeout'\n  | 'invalid_request'\n  | 'server_error'\n  | 'model_not_found'\n  | 'context_length'\n  | 'content_filter'\n  | 'unknown';\n\n/**\n * Parse an error and return a user-friendly representation.\n */\nfunction summarizeErrorDetail(error: unknown): string | undefined {\n  if (error instanceof Error) {\n    if (error.cause instanceof Error && error.cause.message) {\n      return error.cause.message;\n    }\n\n    if (typeof error.cause === 'string' && error.cause.trim().length > 0) {\n      return error.cause;\n    }\n\n    if (error.message.trim().length > 0) {\n      return error.message;\n    }\n  }\n\n  if (typeof error === 'string' && error.trim().length > 0) {\n    return error;\n  }\n\n  if (error && typeof error === 'object') {\n    const errorObj = error as Record<string, unknown>;\n    const candidates = [errorObj['message'], errorObj['cause'], errorObj['code'], errorObj['statusText']];\n\n    for (const candidate of candidates) {\n      if (typeof candidate === 'string' && candidate.trim().length > 0) {\n        return candidate;\n      }\n    }\n  }\n\n  return undefined;\n}\n\nfunction extractRequestUrl(error: unknown): string | undefined {\n  if (!error || typeof error !== 'object') {\n    return undefined;\n  }\n\n  const candidates: unknown[] = [];\n  const errorObj = error as Record<string, unknown>;\n  candidates.push(errorObj['requestUrl'], errorObj['url']);\n\n  if (errorObj['cause'] && typeof errorObj['cause'] === 'object') {\n    const causeObj = errorObj['cause'] as Record<string, unknown>;\n    candidates.push(causeObj['requestUrl'], causeObj['url']);\n  }\n\n  for (const candidate of candidates) {\n    if (typeof candidate === 'string' && candidate.trim().length > 0) {\n      return candidate;\n    }\n  }\n\n  return undefined;\n}\n\n/** A flattened error crossing the wire: the server sends `{ name, message }`, not an `Error`. */\nfunction isSerializedError(value: unknown): value is { name: string; message: string } {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'name' in value &&\n    typeof value.name === 'string' &&\n    'message' in value &&\n    typeof value.message === 'string'\n  );\n}\n\nfunction toError(error: unknown): Error {\n  if (error instanceof Error) return error;\n  if (!isSerializedError(error)) return new Error(String(error));\n  const rebuilt = new Error(error.message);\n  rebuilt.name = error.name;\n  return rebuilt;\n}\n\nexport function parseError(error: unknown): ParsedError {\n  const err = toError(error);\n  const message = err.message.toLowerCase();\n  const errorObj = error as Record<string, unknown>;\n  const detail = summarizeErrorDetail(error);\n  const requestUrl = extractRequestUrl(error);\n\n  // Matched by name, not instance: the error may have crossed a serialization boundary.\n  if (err.name === PROVIDER_AUTH_REQUIRED_ERROR) {\n    return { message: err.message, detail, requestUrl, type: 'auth', retryable: false, originalError: err };\n  }\n\n  // Check for rate limiting\n  if (\n    message.includes('rate limit') ||\n    message.includes('rate_limit') ||\n    message.includes('429') ||\n    errorObj.statusCode === 429 ||\n    errorObj.status === 429\n  ) {\n    const retryAfter = extractRetryAfter(errorObj);\n    return {\n      message: 'Rate limited. Please wait a moment before trying again.',\n      type: 'rate_limit',\n      retryable: true,\n      retryDelay: retryAfter || 5000,\n      originalError: err,\n    };\n  }\n\n  // Check for authentication errors\n  if (\n    message.includes('unauthorized') ||\n    message.includes('authentication') ||\n    message.includes('invalid api key') ||\n    message.includes('invalid_api_key') ||\n    message.includes('api key') ||\n    errorObj.statusCode === 401 ||\n    errorObj.status === 401\n  ) {\n    return {\n      message: 'Authentication failed. Check the credential configured for this provider.',\n      detail,\n      requestUrl,\n      type: 'auth',\n      retryable: false,\n      originalError: err,\n    };\n  }\n\n  // Check for forbidden/permission errors\n  if (errorObj.statusCode === 403 || errorObj.status === 403) {\n    return {\n      message: 'Access denied. You may not have permission to use this model.',\n      detail,\n      requestUrl,\n      type: 'auth',\n      retryable: false,\n      originalError: err,\n    };\n  }\n\n  // Check for network errors\n  if (\n    message.includes('network') ||\n    message.includes('econnrefused') ||\n    message.includes('enotfound') ||\n    message.includes('fetch failed') ||\n    message.includes('connection')\n  ) {\n    return {\n      message: 'Network error while contacting the provider or gateway.',\n      detail,\n      requestUrl,\n      type: 'network',\n      retryable: true,\n      retryDelay: 2000,\n      originalError: err,\n    };\n  }\n\n  // Check for timeout errors\n  if (message.includes('timeout') || message.includes('timed out') || message.includes('etimedout')) {\n    return {\n      message: 'Request timed out. The server may be overloaded.',\n      type: 'timeout',\n      retryable: true,\n      retryDelay: 3000,\n      originalError: err,\n    };\n  }\n\n  // Check for model not found\n  if (\n    message.includes('model not found') ||\n    message.includes('model_not_found') ||\n    message.includes('does not exist') ||\n    message.includes('invalid model')\n  ) {\n    return {\n      message: 'Model not found. Please select a different model with /models.',\n      type: 'model_not_found',\n      retryable: false,\n      originalError: err,\n    };\n  }\n\n  // Check for context length errors\n  if (\n    message.includes('context length') ||\n    message.includes('context_length') ||\n    message.includes('too many tokens') ||\n    message.includes('maximum context') ||\n    message.includes('token limit')\n  ) {\n    return {\n      message: 'Message too long. Try starting a new thread with /new.',\n      type: 'context_length',\n      retryable: false,\n      originalError: err,\n    };\n  }\n\n  // Check for content filter errors\n  if (\n    message.includes('content filter') ||\n    message.includes('content_filter') ||\n    message.includes('content policy') ||\n    message.includes('safety') ||\n    message.includes('prohibited')\n  ) {\n    return {\n      message: \"Content was filtered by the model's safety system.\",\n      type: 'content_filter',\n      retryable: false,\n      originalError: err,\n    };\n  }\n\n  // Check for server errors\n  if (\n    message.includes('internal server') ||\n    message.includes('server error') ||\n    errorObj.statusCode === 500 ||\n    errorObj.status === 500 ||\n    errorObj.statusCode === 502 ||\n    errorObj.status === 502 ||\n    errorObj.statusCode === 503 ||\n    errorObj.status === 503\n  ) {\n    return {\n      message: 'Server error. The API may be experiencing issues.',\n      type: 'server_error',\n      retryable: true,\n      retryDelay: 5000,\n      originalError: err,\n    };\n  }\n\n  // Check for invalid request errors\n  if (\n    message.includes('invalid request') ||\n    message.includes('bad request') ||\n    errorObj.statusCode === 400 ||\n    errorObj.status === 400\n  ) {\n    return {\n      message: `Invalid request: ${extractErrorDetail(err)}`,\n      type: 'invalid_request',\n      retryable: false,\n      originalError: err,\n    };\n  }\n\n  // Unknown error - try to extract useful info\n  return {\n    message: extractErrorDetail(err),\n    type: 'unknown',\n    retryable: false,\n    originalError: err,\n  };\n}\n\n/**\n * Extract retry-after header value from error.\n */\nfunction extractRetryAfter(error: Record<string, unknown>): number | undefined {\n  const headers = error.headers as Record<string, unknown> | undefined;\n  const retryAfter = error.retryAfter || headers?.['retry-after'];\n  if (typeof retryAfter === 'number') {\n    return retryAfter * 1000; // Convert seconds to ms\n  }\n  if (typeof retryAfter === 'string') {\n    const seconds = parseInt(retryAfter, 10);\n    if (!isNaN(seconds)) {\n      return seconds * 1000;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Extract a useful error detail from an error object.\n */\nfunction extractErrorDetail(error: Error): string {\n  const errorObj = error as unknown as Record<string, unknown>;\n\n  // Try to get a specific error message from common API error formats\n  if (errorObj.error && typeof errorObj.error === 'object') {\n    const apiError = errorObj.error as Record<string, unknown>;\n    if (apiError.message) return String(apiError.message);\n  }\n\n  if (errorObj.message) return String(errorObj.message);\n  if (errorObj.detail) return String(errorObj.detail);\n  if (errorObj.reason) return String(errorObj.reason);\n\n  // Clean up the error message\n  let message = error.message;\n\n  // Remove common prefixes\n  message = message.replace(/^(error|exception|failed):\\s*/i, '');\n\n  // Truncate very long messages\n  if (message.length > 200) {\n    message = message.substring(0, 200) + '...';\n  }\n\n  return message || 'An unknown error occurred';\n}\n\n/**\n * Sleep for a given number of milliseconds.\n */\nexport function sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/**\n * Retry a function with exponential backoff.\n */\nexport async function withRetry<T>(\n  fn: () => Promise<T>,\n  options: {\n    maxRetries?: number;\n    initialDelay?: number;\n    maxDelay?: number;\n    onRetry?: (error: ParsedError, attempt: number) => void;\n  } = {},\n): Promise<T> {\n  const { maxRetries = 3, initialDelay = 1000, maxDelay = 30000, onRetry } = options;\n\n  let lastError: ParsedError | undefined;\n\n  for (let attempt = 0; attempt <= maxRetries; attempt++) {\n    try {\n      return await fn();\n    } catch (error) {\n      lastError = parseError(error);\n\n      // Don't retry non-retryable errors\n      if (!lastError.retryable || attempt === maxRetries) {\n        throw lastError.originalError;\n      }\n\n      // Calculate delay with exponential backoff\n      const delay = Math.min(lastError.retryDelay || initialDelay * Math.pow(2, attempt), maxDelay);\n\n      if (onRetry) {\n        onRetry(lastError, attempt + 1);\n      }\n\n      await sleep(delay);\n    }\n  }\n\n  // Should never reach here, but TypeScript needs this\n  throw lastError?.originalError || new Error('Retry failed');\n}\n"],"mappings":"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"}

package/dist/utils/gateway-sync.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Gateway sync utility for keeping the model registry up to date.
+ *
+ * This is a thin wrapper around `@mastra/core/llm`'s `GatewayRegistry` so
+ * mastracode and `mastra dev` share a single implementation for fetching
+ * providers, generating types, and writing to the global cache. Keep this
+ * file small — provider/registry logic belongs in `@mastra/core`.
+ */
+/**
+ * Sync gateways and update the global cache via `@mastra/core`'s registry.
+ *
+ * Skips the sync if the global cache was refreshed within the last
+ * `DEFAULT_SYNC_INTERVAL_MS`, unless `force` is set. Multiple calls in
+ * the same process coalesce while a sync is in flight.
+ */
+export declare function syncGateways(force?: boolean): Promise<void>;
+/**
+ * Start periodic gateway sync.
+ * @param intervalMs Sync interval in milliseconds (default: 5 minutes)
+ */
+export declare function startGatewaySync(intervalMs?: number): void;
+/**
+ * Stop periodic gateway sync.
+ */
+export declare function stopGatewaySync(): void;
+//# sourceMappingURL=gateway-sync.d.ts.map

package/dist/utils/gateway-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-sync.d.ts","sourceRoot":"","sources":["../../src/utils/gateway-sync.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAaH;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,KAAK,UAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAqB/D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,SAA2B,GAAG,IAAI,CAe5E;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAKtC"}

package/dist/utils/gateway-sync.js

@@ -0,0 +1,61 @@
+import { GatewayRegistry } from "@mastra/core/llm";
+//#region src/utils/gateway-sync.ts
+/**
+* Gateway sync utility for keeping the model registry up to date.
+*
+* This is a thin wrapper around `@mastra/core/llm`'s `GatewayRegistry` so
+* mastracode and `mastra dev` share a single implementation for fetching
+* providers, generating types, and writing to the global cache. Keep this
+* file small — provider/registry logic belongs in `@mastra/core`.
+*/
+const DEFAULT_SYNC_INTERVAL_MS = 300 * 1e3;
+let syncInterval = null;
+let isSyncing = false;
+function getRegistry() {
+	return GatewayRegistry.getInstance({ useDynamicLoading: true });
+}
+/**
+* Sync gateways and update the global cache via `@mastra/core`'s registry.
+*
+* Skips the sync if the global cache was refreshed within the last
+* `DEFAULT_SYNC_INTERVAL_MS`, unless `force` is set. Multiple calls in
+* the same process coalesce while a sync is in flight.
+*/
+async function syncGateways(force = false) {
+	if (isSyncing && !force) return;
+	if (!force) {
+		const lastSync = getRegistry().getLastRefreshTime();
+		if (lastSync && Date.now() - lastSync.getTime() < DEFAULT_SYNC_INTERVAL_MS) return;
+	}
+	isSyncing = true;
+	try {
+		await getRegistry().syncGateways(true);
+	} catch {} finally {
+		isSyncing = false;
+	}
+}
+/**
+* Start periodic gateway sync.
+* @param intervalMs Sync interval in milliseconds (default: 5 minutes)
+*/
+function startGatewaySync(intervalMs = DEFAULT_SYNC_INTERVAL_MS) {
+	if (syncInterval) return;
+	syncGateways().catch(() => {});
+	syncInterval = setInterval(() => {
+		syncGateways().catch(() => {});
+	}, intervalMs);
+	syncInterval.unref();
+}
+/**
+* Stop periodic gateway sync.
+*/
+function stopGatewaySync() {
+	if (syncInterval) {
+		clearInterval(syncInterval);
+		syncInterval = null;
+	}
+}
+//#endregion
+export { startGatewaySync, stopGatewaySync, syncGateways };
+
+//# sourceMappingURL=gateway-sync.js.map