@mastra/code-sdk 0.0.0-aggregate-trace-20261015182851

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAGzC,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,16 @@
+export declare const WORKFLOW_AUTHORING_TOOL_IDS: {
+    readonly listAgents: "list-available-agents";
+    readonly listClassifiers: "list-available-classifiers";
+    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-classifiers" | "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;;;;;;CAM9B,CAAC;AAEX,eAAO,MAAM,4BAA4B;;;;;;CAM/B,CAAC;AAEX,eAAO,MAAM,+BAA+B,0OAGlC,CAAC"}

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

@@ -0,0 +1,20 @@
+//#region src/tools/workflows/tool-ids.ts
+const WORKFLOW_AUTHORING_TOOL_IDS = {
+	listAgents: "list-available-agents",
+	listClassifiers: "list-available-classifiers",
+	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  listClassifiers: 'list-available-classifiers',\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,iBAAiB;CACjB,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 path$1 from "path";
+import * as fs$1 from "fs";
+//#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/discarding-scores-storage.d.ts

@@ -0,0 +1,33 @@
+import type { ListScoresResponse, SaveScorePayload, ScoreRowData } from '@mastra/core/evals';
+import { ScoresStorage } from '@mastra/core/storage';
+import type { StoragePagination } from '@mastra/core/storage';
+/**
+ * A scores domain that accepts writes and keeps nothing.
+ *
+ * mastracode's `outcome` and `efficiency` scorers persist every result through
+ * the scores domain (`validateAndSaveScore` → `getStore('scores')`), but nothing
+ * in mastracode reads scores back. Writing them to libsql grew mastra.db without
+ * bound, and an in-memory store would grow the heap for the life of the process
+ * instead (each payload carries the system prompt, messages, input and output).
+ * Disabling the domain is not an option: core throws
+ * MASTRA_SCORES_STORAGE_NOT_AVAILABLE on every scorer run when it is missing.
+ */
+export declare class DiscardingScoresStorage extends ScoresStorage {
+    getScoreById(): Promise<ScoreRowData | null>;
+    saveScore(score: SaveScorePayload): Promise<{
+        score: ScoreRowData;
+    }>;
+    listScoresByScorerId({ pagination }: {
+        pagination: StoragePagination;
+    }): Promise<ListScoresResponse>;
+    listScoresByRunId({ pagination }: {
+        pagination: StoragePagination;
+    }): Promise<ListScoresResponse>;
+    listScoresByEntityId({ pagination }: {
+        pagination: StoragePagination;
+    }): Promise<ListScoresResponse>;
+    listScoresBySpan({ pagination }: {
+        pagination: StoragePagination;
+    }): Promise<ListScoresResponse>;
+}
+//# sourceMappingURL=discarding-scores-storage.d.ts.map

package/dist/utils/discarding-scores-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discarding-scores-storage.d.ts","sourceRoot":"","sources":["../../src/utils/discarding-scores-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC7F,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D;;;;;;;;;;GAUG;AACH,qBAAa,uBAAwB,SAAQ,aAAa;IAClD,YAAY,IAAI,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAI5C,SAAS,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,YAAY,CAAA;KAAE,CAAC;IAKpE,oBAAoB,CAAC,EAAE,UAAU,EAAE,EAAE;QAAE,UAAU,EAAE,iBAAiB,CAAA;KAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAIpG,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAAE;QAAE,UAAU,EAAE,iBAAiB,CAAA;KAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAIjG,oBAAoB,CAAC,EAAE,UAAU,EAAE,EAAE;QAAE,UAAU,EAAE,iBAAiB,CAAA;KAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAIpG,gBAAgB,CAAC,EAAE,UAAU,EAAE,EAAE;QAAE,UAAU,EAAE,iBAAiB,CAAA;KAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAGvG"}

package/dist/utils/discarding-scores-storage.js

@@ -0,0 +1,54 @@
+import { ScoresStorage } from "@mastra/core/storage";
+//#region src/utils/discarding-scores-storage.ts
+/**
+* A scores domain that accepts writes and keeps nothing.
+*
+* mastracode's `outcome` and `efficiency` scorers persist every result through
+* the scores domain (`validateAndSaveScore` → `getStore('scores')`), but nothing
+* in mastracode reads scores back. Writing them to libsql grew mastra.db without
+* bound, and an in-memory store would grow the heap for the life of the process
+* instead (each payload carries the system prompt, messages, input and output).
+* Disabling the domain is not an option: core throws
+* MASTRA_SCORES_STORAGE_NOT_AVAILABLE on every scorer run when it is missing.
+*/
+var DiscardingScoresStorage = class extends ScoresStorage {
+	async getScoreById() {
+		return null;
+	}
+	async saveScore(score) {
+		const now = /* @__PURE__ */ new Date();
+		return { score: {
+			...score,
+			id: score.id ?? crypto.randomUUID(),
+			createdAt: now,
+			updatedAt: now
+		} };
+	}
+	async listScoresByScorerId({ pagination }) {
+		return empty(pagination);
+	}
+	async listScoresByRunId({ pagination }) {
+		return empty(pagination);
+	}
+	async listScoresByEntityId({ pagination }) {
+		return empty(pagination);
+	}
+	async listScoresBySpan({ pagination }) {
+		return empty(pagination);
+	}
+};
+function empty(pagination) {
+	return {
+		pagination: {
+			total: 0,
+			page: pagination.page,
+			perPage: pagination.perPage,
+			hasMore: false
+		},
+		scores: []
+	};
+}
+//#endregion
+export { DiscardingScoresStorage };
+
+//# sourceMappingURL=discarding-scores-storage.js.map

package/dist/utils/discarding-scores-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discarding-scores-storage.js","names":[],"sources":["../../src/utils/discarding-scores-storage.ts"],"sourcesContent":["import type { ListScoresResponse, SaveScorePayload, ScoreRowData } from '@mastra/core/evals';\nimport { ScoresStorage } from '@mastra/core/storage';\nimport type { StoragePagination } from '@mastra/core/storage';\n\n/**\n * A scores domain that accepts writes and keeps nothing.\n *\n * mastracode's `outcome` and `efficiency` scorers persist every result through\n * the scores domain (`validateAndSaveScore` → `getStore('scores')`), but nothing\n * in mastracode reads scores back. Writing them to libsql grew mastra.db without\n * bound, and an in-memory store would grow the heap for the life of the process\n * instead (each payload carries the system prompt, messages, input and output).\n * Disabling the domain is not an option: core throws\n * MASTRA_SCORES_STORAGE_NOT_AVAILABLE on every scorer run when it is missing.\n */\nexport class DiscardingScoresStorage extends ScoresStorage {\n  async getScoreById(): Promise<ScoreRowData | null> {\n    return null;\n  }\n\n  async saveScore(score: SaveScorePayload): Promise<{ score: ScoreRowData }> {\n    const now = new Date();\n    return { score: { ...score, id: score.id ?? crypto.randomUUID(), createdAt: now, updatedAt: now } as ScoreRowData };\n  }\n\n  async listScoresByScorerId({ pagination }: { pagination: StoragePagination }): Promise<ListScoresResponse> {\n    return empty(pagination);\n  }\n\n  async listScoresByRunId({ pagination }: { pagination: StoragePagination }): Promise<ListScoresResponse> {\n    return empty(pagination);\n  }\n\n  async listScoresByEntityId({ pagination }: { pagination: StoragePagination }): Promise<ListScoresResponse> {\n    return empty(pagination);\n  }\n\n  async listScoresBySpan({ pagination }: { pagination: StoragePagination }): Promise<ListScoresResponse> {\n    return empty(pagination);\n  }\n}\n\nfunction empty(pagination: StoragePagination): ListScoresResponse {\n  return { pagination: { total: 0, page: pagination.page, perPage: pagination.perPage, hasMore: false }, scores: [] };\n}\n"],"mappings":";;;;;;;;;;;;;AAeA,IAAa,0BAAb,cAA6C,cAAc;CACzD,MAAM,eAA6C;EACjD,OAAO;CACT;CAEA,MAAM,UAAU,OAA2D;EACzE,MAAM,sBAAM,IAAI,KAAK;EACrB,OAAO,EAAE,OAAO;GAAE,GAAG;GAAO,IAAI,MAAM,MAAM,OAAO,WAAW;GAAG,WAAW;GAAK,WAAW;EAAI,EAAkB;CACpH;CAEA,MAAM,qBAAqB,EAAE,cAA8E;EACzG,OAAO,MAAM,UAAU;CACzB;CAEA,MAAM,kBAAkB,EAAE,cAA8E;EACtG,OAAO,MAAM,UAAU;CACzB;CAEA,MAAM,qBAAqB,EAAE,cAA8E;EACzG,OAAO,MAAM,UAAU;CACzB;CAEA,MAAM,iBAAiB,EAAE,cAA8E;EACrG,OAAO,MAAM,UAAU;CACzB;AACF;AAEA,SAAS,MAAM,YAAmD;CAChE,OAAO;EAAE,YAAY;GAAE,OAAO;GAAG,MAAM,WAAW;GAAM,SAAS,WAAW;GAAS,SAAS;EAAM;EAAG,QAAQ,CAAC;CAAE;AACpH"}

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