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

package/dist/theme-palette.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Mastra brand palette (immutable — stays constant regardless of theme).
+ *
+ * Lives outside the TUI so non-TUI code (e.g. mode metadata colors in
+ * `createMastraCode`) can use brand colors without importing TUI modules.
+ * The TUI's `theme.ts` re-exports this and layers contrast adaptation on top.
+ */
+export declare const mastraBrand: {
+    readonly purple: "#7f45e0";
+    readonly green: "#16c858";
+    readonly orange: "#fdac53";
+    readonly pink: "#ff69cc";
+    readonly blue: "#2563eb";
+    readonly red: "#DC5663";
+    readonly yellow: "#e7e67b";
+};
+//# sourceMappingURL=theme-palette.d.ts.map

package/dist/theme-palette.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-palette.d.ts","sourceRoot":"","sources":["../src/theme-palette.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,WAAW;;;;;;;;CAQd,CAAC"}

package/dist/theme-palette.js

@@ -0,0 +1,21 @@
+//#region src/theme-palette.ts
+/**
+* Mastra brand palette (immutable — stays constant regardless of theme).
+*
+* Lives outside the TUI so non-TUI code (e.g. mode metadata colors in
+* `createMastraCode`) can use brand colors without importing TUI modules.
+* The TUI's `theme.ts` re-exports this and layers contrast adaptation on top.
+*/
+const mastraBrand = {
+	purple: "#7f45e0",
+	green: "#16c858",
+	orange: "#fdac53",
+	pink: "#ff69cc",
+	blue: "#2563eb",
+	red: "#DC5663",
+	yellow: "#e7e67b"
+};
+//#endregion
+export { mastraBrand };
+
+//# sourceMappingURL=theme-palette.js.map

package/dist/theme-palette.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-palette.js","names":[],"sources":["../src/theme-palette.ts"],"sourcesContent":["/**\n * Mastra brand palette (immutable — stays constant regardless of theme).\n *\n * Lives outside the TUI so non-TUI code (e.g. mode metadata colors in\n * `createMastraCode`) can use brand colors without importing TUI modules.\n * The TUI's `theme.ts` re-exports this and layers contrast adaptation on top.\n */\nexport const mastraBrand = {\n  purple: '#7f45e0', // #b588fe brand is too washed out for terminal\n  green: '#16c858', // brand green (dark mode primary)\n  orange: '#fdac53',\n  pink: '#ff69cc',\n  blue: '#2563eb', // #6ccdfb brand is to washed out\n  red: '#DC5663', // #ff4758 too intense\n  yellow: '#e7e67b',\n} as const;\n"],"mappings":";;;;;;;;AAOA,MAAa,cAAc;CACzB,QAAQ;CACR,OAAO;CACP,QAAQ;CACR,MAAM;CACN,MAAM;CACN,KAAK;CACL,QAAQ;AACV"}

package/dist/thinking-catalog.d.ts

@@ -0,0 +1,4 @@
+import type { ThinkingLevelSetting } from './thinking.js';
+export declare function runCatalogThinkingLevel(modelId: string, level: ThinkingLevelSetting): ThinkingLevelSetting;
+export declare function getCatalogThinkingLevels(modelId: string): ThinkingLevelSetting[];
+//# sourceMappingURL=thinking-catalog.d.ts.map

package/dist/thinking-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-catalog.d.ts","sourceRoot":"","sources":["../src/thinking-catalog.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,oBAAoB,GAAG,oBAAoB,CAE1G;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAEhF"}

package/dist/thinking-catalog.js

@@ -0,0 +1,13 @@
+import { getAvailableThinkingLevelsForModel, runThinkingLevel } from "./thinking.js";
+import { getModelReasoningOptions } from "@mastra/core/llm";
+//#region src/thinking-catalog.ts
+function runCatalogThinkingLevel(modelId, level) {
+	return runThinkingLevel(modelId, level, getModelReasoningOptions(modelId));
+}
+function getCatalogThinkingLevels(modelId) {
+	return getAvailableThinkingLevelsForModel(modelId, getModelReasoningOptions(modelId));
+}
+//#endregion
+export { getCatalogThinkingLevels, runCatalogThinkingLevel };
+
+//# sourceMappingURL=thinking-catalog.js.map

package/dist/thinking-catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-catalog.js","names":[],"sources":["../src/thinking-catalog.ts"],"sourcesContent":["import { getModelReasoningOptions } from '@mastra/core/llm';\nimport { getAvailableThinkingLevelsForModel, runThinkingLevel } from './thinking.js';\nimport type { ThinkingLevelSetting } from './thinking.js';\n\nexport function runCatalogThinkingLevel(modelId: string, level: ThinkingLevelSetting): ThinkingLevelSetting {\n  return runThinkingLevel(modelId, level, getModelReasoningOptions(modelId));\n}\n\nexport function getCatalogThinkingLevels(modelId: string): ThinkingLevelSetting[] {\n  return getAvailableThinkingLevelsForModel(modelId, getModelReasoningOptions(modelId));\n}\n"],"mappings":";;;AAIA,SAAgB,wBAAwB,SAAiB,OAAmD;CAC1G,OAAO,iBAAiB,SAAS,OAAO,yBAAyB,OAAO,CAAC;AAC3E;AAEA,SAAgB,yBAAyB,SAAyC;CAChF,OAAO,mCAAmC,SAAS,yBAAyB,OAAO,CAAC;AACtF"}

package/dist/thinking.d.ts

@@ -0,0 +1,37 @@
+import type { ModelReasoningOption } from '@mastra/core/llm';
+export type ThinkingLevelSetting = 'off' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+export type ActiveThinkingLevel = Exclude<ThinkingLevelSetting, 'off'>;
+export type ThinkingLevelSource = 'mode-default' | 'global';
+export interface ThinkingDefaults {
+    globalDefault: ThinkingLevelSetting;
+    modeDefaults: Readonly<Record<string, ThinkingLevelSetting>>;
+}
+export declare const THINKING_LEVEL_VALUES: ThinkingLevelSetting[];
+export declare const THINK_COMMAND_DESCRIPTOR: {
+    name: string;
+    args: string;
+    description: string;
+};
+export type ThinkCommandAction = {
+    kind: 'status';
+} | {
+    kind: 'clear';
+} | {
+    kind: 'set';
+    level: ThinkingLevelSetting;
+} | {
+    kind: 'invalid';
+    value: string;
+    levels: readonly ThinkingLevelSetting[];
+};
+export declare function isThinkingLevelSetting(value: unknown): value is ThinkingLevelSetting;
+export declare function supportsMaxReasoningEffort(modelId: string): boolean;
+export declare function requestableReasoningOptions(modelId: string, reasoningOptions: readonly ModelReasoningOption[] | undefined): readonly ModelReasoningOption[] | undefined;
+export declare function runThinkingLevel(modelId: string, level: ThinkingLevelSetting, reasoningOptions: readonly ModelReasoningOption[] | undefined): ThinkingLevelSetting;
+export declare function getAvailableThinkingLevelsForModel(modelId: string, reasoningOptions?: readonly ModelReasoningOption[]): ThinkingLevelSetting[];
+export declare function parseThinkCommand(input: string, levels?: readonly ThinkingLevelSetting[]): ThinkCommandAction;
+export declare function resolveDefaultThinkingLevel(defaults: ThinkingDefaults, mode?: string | null): {
+    level: ThinkingLevelSetting;
+    source: ThinkingLevelSource;
+};
+//# sourceMappingURL=thinking.d.ts.map

package/dist/thinking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking.d.ts","sourceRoot":"","sources":["../src/thinking.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAc7D,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAEvF,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;AAEvE,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,QAAQ,CAAC;AAE5D,MAAM,WAAW,gBAAgB;IAC/B,aAAa,EAAE,oBAAoB,CAAC;IACpC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC;CAC9D;AAED,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,EAAqD,CAAC;AAI9G,eAAO,MAAM,wBAAwB;;;;CAIpC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,oBAAoB,CAAA;CAAE,GAC5C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,SAAS,oBAAoB,EAAE,CAAA;CAAE,CAAC;AAIhF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAEpF;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAOnE;AAoBD,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,SAAS,oBAAoB,EAAE,GAAG,SAAS,GAC5D,SAAS,oBAAoB,EAAE,GAAG,SAAS,CAY7C;AAwCD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,oBAAoB,EAC3B,gBAAgB,EAAE,SAAS,oBAAoB,EAAE,GAAG,SAAS,GAC5D,oBAAoB,CAatB;AAED,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,MAAM,EACf,gBAAgB,CAAC,EAAE,SAAS,oBAAoB,EAAE,GACjD,oBAAoB,EAAE,CAExB;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,SAAS,oBAAoB,EAA0B,GAC9D,kBAAkB,CAMpB;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,GACnB;IAAE,KAAK,EAAE,oBAAoB,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAG9D"}

package/dist/thinking.js

@@ -0,0 +1,137 @@
+import { ANTHROPIC_THINKING_BUDGET_TOKENS, getAnthropicThinkingCapability, supportsAnthropicXhighEffort } from "./providers/anthropic-thinking.js";
+import { runGeminiThinkingLevel } from "./providers/google-thinking.js";
+import { normalizeAnthropicModelId, stripMastraGatewayPrefix } from "./providers/model-ids.js";
+import { isRoutedWithoutThinking, isThinkingAdapterProvider, thinkingRequestFormatFor } from "./providers/thinking-request.js";
+//#region src/thinking.ts
+const THINKING_LEVEL_VALUES = [
+	"off",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const ACTIVE_THINKING_LEVELS = [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const THINK_COMMAND_DESCRIPTOR = {
+	name: "think",
+	args: "[status|default|off|low|medium|high|xhigh|max]",
+	description: "Show or set session thinking level"
+};
+const GPT_VERSION_RE = /^gpt-(\d+)(?:\.(\d+))?/;
+function isThinkingLevelSetting(value) {
+	return typeof value === "string" && THINKING_LEVEL_VALUES.some((level) => level === value);
+}
+function supportsMaxReasoningEffort(modelId) {
+	const bareModelId = modelId.startsWith("openai/") ? modelId.slice(7) : modelId;
+	const match = GPT_VERSION_RE.exec(bareModelId);
+	if (!match) return false;
+	const major = Number(match[1]);
+	const minor = Number(match[2] ?? 0);
+	return major > 5 || major === 5 && minor >= 6;
+}
+function splitProvider(modelId) {
+	const routedModelId = stripMastraGatewayPrefix(modelId);
+	const slash = routedModelId.indexOf("/");
+	if (slash === -1) return {
+		provider: "",
+		bareModelId: routedModelId
+	};
+	return {
+		provider: routedModelId.slice(0, slash),
+		bareModelId: routedModelId.slice(slash + 1)
+	};
+}
+function offeredEffortLevels(reasoningOptions) {
+	const effortValues = reasoningOptions?.flatMap((option) => option.type === "effort" ? option.values : []) ?? [];
+	return ACTIVE_THINKING_LEVELS.filter((level) => effortValues.includes(level));
+}
+const TOGGLE_ON_LEVEL = "high";
+function onlyTogglesThinking(reasoningOptions) {
+	return !!reasoningOptions?.length && reasoningOptions.every((option) => option.type === "toggle");
+}
+function requestableReasoningOptions(modelId, reasoningOptions) {
+	if (isRoutedWithoutThinking(modelId)) return [];
+	if (!reasoningOptions) return reasoningOptions;
+	const format = thinkingRequestFormatFor(modelId);
+	if (!format) return isThinkingAdapterProvider(splitProvider(modelId).provider) ? reasoningOptions : [];
+	const acceptedEfforts = format.sendEffort ? format.acceptedEfforts ?? ACTIVE_THINKING_LEVELS : [];
+	return reasoningOptions.flatMap((option) => {
+		if (option.type === "toggle") return format.enableThinking ? [option] : [];
+		if (option.type !== "effort") return [];
+		const values = option.values.filter((value) => acceptedEfforts.some((effort) => effort === value));
+		return values.length ? [{
+			type: "effort",
+			values
+		}] : [];
+	});
+}
+function closestOfferedEffort(level, reasoningOptions) {
+	const offered = offeredEffortLevels(reasoningOptions);
+	const requestedRank = ACTIVE_THINKING_LEVELS.indexOf(level);
+	return offered.filter((candidate) => ACTIVE_THINKING_LEVELS.indexOf(candidate) <= requestedRank).at(-1) ?? offered[0];
+}
+function lowestLevelWithSameBudget(level) {
+	const budget = ANTHROPIC_THINKING_BUDGET_TOKENS[level];
+	return ACTIVE_THINKING_LEVELS.find((candidate) => ANTHROPIC_THINKING_BUDGET_TOKENS[candidate] === budget) ?? level;
+}
+function runAnthropicThinkingLevel(modelId, level, reasoningOptions) {
+	const capability = getAnthropicThinkingCapability(modelId);
+	if (capability === "none") return "off";
+	if (capability === "budget") return lowestLevelWithSameBudget(level);
+	const offeredEffort = closestOfferedEffort(level, reasoningOptions);
+	if (offeredEffort) return offeredEffort;
+	return level === "xhigh" && !supportsAnthropicXhighEffort(modelId) ? "high" : level;
+}
+function runOpenAIThinkingLevel(modelId, level, reasoningOptions) {
+	const offeredEffort = closestOfferedEffort(level, reasoningOptions);
+	if (offeredEffort) return offeredEffort;
+	return level === "max" && !supportsMaxReasoningEffort(modelId) ? "xhigh" : level;
+}
+function runThinkingLevel(modelId, level, reasoningOptions) {
+	if (level === "off") return "off";
+	const { provider, bareModelId } = splitProvider(modelId);
+	if (provider === "google") return runGeminiThinkingLevel(bareModelId, level);
+	if (provider === "anthropic") return runAnthropicThinkingLevel(normalizeAnthropicModelId(bareModelId), level, reasoningOptions);
+	const requestable = requestableReasoningOptions(modelId, reasoningOptions);
+	if (requestable?.length === 0) return "off";
+	if (onlyTogglesThinking(requestable)) return TOGGLE_ON_LEVEL;
+	if (provider === "openai") return runOpenAIThinkingLevel(bareModelId, level, requestable);
+	return closestOfferedEffort(level, requestable) ?? level;
+}
+function getAvailableThinkingLevelsForModel(modelId, reasoningOptions) {
+	return THINKING_LEVEL_VALUES.filter((level) => runThinkingLevel(modelId, level, reasoningOptions) === level);
+}
+function parseThinkCommand(input, levels = THINKING_LEVEL_VALUES) {
+	const value = input.trim().toLowerCase();
+	if (!value || value === "status") return { kind: "status" };
+	if (value === "default" || value === "clear") return { kind: "clear" };
+	const level = levels.find((candidate) => candidate === value);
+	return level ? {
+		kind: "set",
+		level
+	} : {
+		kind: "invalid",
+		value,
+		levels
+	};
+}
+function resolveDefaultThinkingLevel(defaults, mode) {
+	const modeLevel = mode ? defaults.modeDefaults[mode] : void 0;
+	return modeLevel ? {
+		level: modeLevel,
+		source: "mode-default"
+	} : {
+		level: defaults.globalDefault,
+		source: "global"
+	};
+}
+//#endregion
+export { THINKING_LEVEL_VALUES, THINK_COMMAND_DESCRIPTOR, getAvailableThinkingLevelsForModel, isThinkingLevelSetting, parseThinkCommand, requestableReasoningOptions, resolveDefaultThinkingLevel, runThinkingLevel, supportsMaxReasoningEffort };
+
+//# sourceMappingURL=thinking.js.map

package/dist/thinking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking.js","names":[],"sources":["../src/thinking.ts"],"sourcesContent":["import type { ModelReasoningOption } from '@mastra/core/llm';\nimport {\n  ANTHROPIC_THINKING_BUDGET_TOKENS,\n  getAnthropicThinkingCapability,\n  supportsAnthropicXhighEffort,\n} from './providers/anthropic-thinking.js';\nimport { runGeminiThinkingLevel } from './providers/google-thinking.js';\nimport { normalizeAnthropicModelId, stripMastraGatewayPrefix } from './providers/model-ids.js';\nimport {\n  isRoutedWithoutThinking,\n  isThinkingAdapterProvider,\n  thinkingRequestFormatFor,\n} from './providers/thinking-request.js';\n\nexport type ThinkingLevelSetting = 'off' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';\n\nexport type ActiveThinkingLevel = Exclude<ThinkingLevelSetting, 'off'>;\n\nexport type ThinkingLevelSource = 'mode-default' | 'global';\n\nexport interface ThinkingDefaults {\n  globalDefault: ThinkingLevelSetting;\n  modeDefaults: Readonly<Record<string, ThinkingLevelSetting>>;\n}\n\nexport const THINKING_LEVEL_VALUES: ThinkingLevelSetting[] = ['off', 'low', 'medium', 'high', 'xhigh', 'max'];\n\nconst ACTIVE_THINKING_LEVELS: ActiveThinkingLevel[] = ['low', 'medium', 'high', 'xhigh', 'max'];\n\nexport const THINK_COMMAND_DESCRIPTOR = {\n  name: 'think',\n  args: '[status|default|off|low|medium|high|xhigh|max]',\n  description: 'Show or set session thinking level',\n};\n\nexport type ThinkCommandAction =\n  | { kind: 'status' }\n  | { kind: 'clear' }\n  | { kind: 'set'; level: ThinkingLevelSetting }\n  | { kind: 'invalid'; value: string; levels: readonly ThinkingLevelSetting[] };\n\nconst GPT_VERSION_RE = /^gpt-(\\d+)(?:\\.(\\d+))?/;\n\nexport function isThinkingLevelSetting(value: unknown): value is ThinkingLevelSetting {\n  return typeof value === 'string' && THINKING_LEVEL_VALUES.some(level => level === value);\n}\n\nexport function supportsMaxReasoningEffort(modelId: string): boolean {\n  const bareModelId = modelId.startsWith('openai/') ? modelId.slice('openai/'.length) : modelId;\n  const match = GPT_VERSION_RE.exec(bareModelId);\n  if (!match) return false;\n  const major = Number(match[1]);\n  const minor = Number(match[2] ?? 0);\n  return major > 5 || (major === 5 && minor >= 6);\n}\n\nfunction splitProvider(modelId: string): { provider: string; bareModelId: string } {\n  const routedModelId = stripMastraGatewayPrefix(modelId);\n  const slash = routedModelId.indexOf('/');\n  if (slash === -1) return { provider: '', bareModelId: routedModelId };\n  return { provider: routedModelId.slice(0, slash), bareModelId: routedModelId.slice(slash + 1) };\n}\n\nfunction offeredEffortLevels(reasoningOptions: readonly ModelReasoningOption[] | undefined): ActiveThinkingLevel[] {\n  const effortValues = reasoningOptions?.flatMap(option => (option.type === 'effort' ? option.values : [])) ?? [];\n  return ACTIVE_THINKING_LEVELS.filter(level => effortValues.includes(level));\n}\n\nconst TOGGLE_ON_LEVEL: ActiveThinkingLevel = 'high';\n\nfunction onlyTogglesThinking(reasoningOptions: readonly ModelReasoningOption[] | undefined): boolean {\n  return !!reasoningOptions?.length && reasoningOptions.every(option => option.type === 'toggle');\n}\n\nexport function requestableReasoningOptions(\n  modelId: string,\n  reasoningOptions: readonly ModelReasoningOption[] | undefined,\n): readonly ModelReasoningOption[] | undefined {\n  if (isRoutedWithoutThinking(modelId)) return [];\n  if (!reasoningOptions) return reasoningOptions;\n  const format = thinkingRequestFormatFor(modelId);\n  if (!format) return isThinkingAdapterProvider(splitProvider(modelId).provider) ? reasoningOptions : [];\n  const acceptedEfforts = format.sendEffort ? (format.acceptedEfforts ?? ACTIVE_THINKING_LEVELS) : [];\n  return reasoningOptions.flatMap((option): ModelReasoningOption[] => {\n    if (option.type === 'toggle') return format.enableThinking ? [option] : [];\n    if (option.type !== 'effort') return [];\n    const values = option.values.filter(value => acceptedEfforts.some(effort => effort === value));\n    return values.length ? [{ type: 'effort', values }] : [];\n  });\n}\n\nfunction closestOfferedEffort(\n  level: ActiveThinkingLevel,\n  reasoningOptions: readonly ModelReasoningOption[] | undefined,\n): ActiveThinkingLevel | undefined {\n  const offered = offeredEffortLevels(reasoningOptions);\n  const requestedRank = ACTIVE_THINKING_LEVELS.indexOf(level);\n  const atOrBelow = offered.filter(candidate => ACTIVE_THINKING_LEVELS.indexOf(candidate) <= requestedRank);\n  return atOrBelow.at(-1) ?? offered[0];\n}\n\nfunction lowestLevelWithSameBudget(level: ActiveThinkingLevel): ActiveThinkingLevel {\n  const budget = ANTHROPIC_THINKING_BUDGET_TOKENS[level];\n  return ACTIVE_THINKING_LEVELS.find(candidate => ANTHROPIC_THINKING_BUDGET_TOKENS[candidate] === budget) ?? level;\n}\n\nfunction runAnthropicThinkingLevel(\n  modelId: string,\n  level: ActiveThinkingLevel,\n  reasoningOptions: readonly ModelReasoningOption[] | undefined,\n): ThinkingLevelSetting {\n  const capability = getAnthropicThinkingCapability(modelId);\n  if (capability === 'none') return 'off';\n  if (capability === 'budget') return lowestLevelWithSameBudget(level);\n  const offeredEffort = closestOfferedEffort(level, reasoningOptions);\n  if (offeredEffort) return offeredEffort;\n  return level === 'xhigh' && !supportsAnthropicXhighEffort(modelId) ? 'high' : level;\n}\n\nfunction runOpenAIThinkingLevel(\n  modelId: string,\n  level: ActiveThinkingLevel,\n  reasoningOptions: readonly ModelReasoningOption[] | undefined,\n): ActiveThinkingLevel {\n  const offeredEffort = closestOfferedEffort(level, reasoningOptions);\n  if (offeredEffort) return offeredEffort;\n  return level === 'max' && !supportsMaxReasoningEffort(modelId) ? 'xhigh' : level;\n}\n\nexport function runThinkingLevel(\n  modelId: string,\n  level: ThinkingLevelSetting,\n  reasoningOptions: readonly ModelReasoningOption[] | undefined,\n): ThinkingLevelSetting {\n  if (level === 'off') return 'off';\n  const { provider, bareModelId } = splitProvider(modelId);\n  if (provider === 'google') return runGeminiThinkingLevel(bareModelId, level);\n  if (provider === 'anthropic') {\n    return runAnthropicThinkingLevel(normalizeAnthropicModelId(bareModelId), level, reasoningOptions);\n  }\n  const requestable = requestableReasoningOptions(modelId, reasoningOptions);\n  const listedWithoutReasoningControls = requestable?.length === 0;\n  if (listedWithoutReasoningControls) return 'off';\n  if (onlyTogglesThinking(requestable)) return TOGGLE_ON_LEVEL;\n  if (provider === 'openai') return runOpenAIThinkingLevel(bareModelId, level, requestable);\n  return closestOfferedEffort(level, requestable) ?? level;\n}\n\nexport function getAvailableThinkingLevelsForModel(\n  modelId: string,\n  reasoningOptions?: readonly ModelReasoningOption[],\n): ThinkingLevelSetting[] {\n  return THINKING_LEVEL_VALUES.filter(level => runThinkingLevel(modelId, level, reasoningOptions) === level);\n}\n\nexport function parseThinkCommand(\n  input: string,\n  levels: readonly ThinkingLevelSetting[] = THINKING_LEVEL_VALUES,\n): ThinkCommandAction {\n  const value = input.trim().toLowerCase();\n  if (!value || value === 'status') return { kind: 'status' };\n  if (value === 'default' || value === 'clear') return { kind: 'clear' };\n  const level = levels.find(candidate => candidate === value);\n  return level ? { kind: 'set', level } : { kind: 'invalid', value, levels };\n}\n\nexport function resolveDefaultThinkingLevel(\n  defaults: ThinkingDefaults,\n  mode?: string | null,\n): { level: ThinkingLevelSetting; source: ThinkingLevelSource } {\n  const modeLevel = mode ? defaults.modeDefaults[mode] : undefined;\n  return modeLevel ? { level: modeLevel, source: 'mode-default' } : { level: defaults.globalDefault, source: 'global' };\n}\n"],"mappings":"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"}

package/dist/tool-names.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Mastracode tool name constants.
+ *
+ * These are the names exposed to the LLM via workspace tool name remapping.
+ * Used throughout mastracode for permissions, TUI rendering, tool guidance,
+ * subagent allowedTools, etc.
+ *
+ * The workspace tools get remapped from their core names (e.g. `mastra_workspace_read_file`)
+ * to these names (e.g. `view`) via the `name` property in workspace tool config.
+ */
+export declare const MC_TOOLS: {
+    readonly VIEW: "view";
+    readonly WRITE_FILE: "write_file";
+    readonly STRING_REPLACE_LSP: "string_replace_lsp";
+    readonly FIND_FILES: "find_files";
+    readonly DELETE_FILE: "delete_file";
+    readonly FILE_STAT: "file_stat";
+    readonly MKDIR: "mkdir";
+    readonly SEARCH_CONTENT: "search_content";
+    readonly AST_SMART_EDIT: "ast_smart_edit";
+    readonly EXECUTE_COMMAND: "execute_command";
+    readonly GET_PROCESS_OUTPUT: "get_process_output";
+    readonly KILL_PROCESS: "kill_process";
+    readonly LSP_INSPECT: "lsp_inspect";
+    readonly NOTIFICATION_INBOX: "notification_inbox";
+    readonly AGENT_CONNECTIONS_LIST: "agent_connections_list";
+    readonly AGENT_CONNECT: "agent_connect";
+    readonly AGENT_DISCONNECT: "agent_disconnect";
+    readonly AGENT_SIGNAL_SEND: "agent_signal_send";
+};
+/**
+ * Workspace tool name remapping config.
+ * Maps core workspace tool constants to mastracode's tool names.
+ * Pass this (or spread it) into `Workspace({ tools: ... })`.
+ */
+export declare const TOOL_NAME_OVERRIDES: {
+    readonly mastra_workspace_read_file: {
+        readonly name: "view";
+    };
+    readonly mastra_workspace_write_file: {
+        readonly name: "write_file";
+    };
+    readonly mastra_workspace_edit_file: {
+        readonly name: "string_replace_lsp";
+    };
+    readonly mastra_workspace_list_files: {
+        readonly name: "find_files";
+    };
+    readonly mastra_workspace_delete: {
+        readonly name: "delete_file";
+    };
+    readonly mastra_workspace_file_stat: {
+        readonly name: "file_stat";
+    };
+    readonly mastra_workspace_mkdir: {
+        readonly name: "mkdir";
+    };
+    readonly mastra_workspace_grep: {
+        readonly name: "search_content";
+    };
+    readonly mastra_workspace_ast_edit: {
+        readonly name: "ast_smart_edit";
+    };
+    readonly mastra_workspace_execute_command: {
+        readonly name: "execute_command";
+    };
+    readonly mastra_workspace_get_process_output: {
+        readonly name: "get_process_output";
+    };
+    readonly mastra_workspace_kill_process: {
+        readonly name: "kill_process";
+    };
+    readonly mastra_workspace_lsp_inspect: {
+        readonly name: "lsp_inspect";
+    };
+};
+//# sourceMappingURL=tool-names.d.ts.map

package/dist/tool-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-names.d.ts","sourceRoot":"","sources":["../src/tool-names.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;CAgCX,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CActB,CAAC"}

package/dist/tool-names.js

@@ -0,0 +1,56 @@
+import { WORKSPACE_TOOLS } from "@mastra/core/workspace";
+//#region src/tool-names.ts
+/**
+* Mastracode tool name constants.
+*
+* These are the names exposed to the LLM via workspace tool name remapping.
+* Used throughout mastracode for permissions, TUI rendering, tool guidance,
+* subagent allowedTools, etc.
+*
+* The workspace tools get remapped from their core names (e.g. `mastra_workspace_read_file`)
+* to these names (e.g. `view`) via the `name` property in workspace tool config.
+*/
+const MC_TOOLS = {
+	VIEW: "view",
+	WRITE_FILE: "write_file",
+	STRING_REPLACE_LSP: "string_replace_lsp",
+	FIND_FILES: "find_files",
+	DELETE_FILE: "delete_file",
+	FILE_STAT: "file_stat",
+	MKDIR: "mkdir",
+	SEARCH_CONTENT: "search_content",
+	AST_SMART_EDIT: "ast_smart_edit",
+	EXECUTE_COMMAND: "execute_command",
+	GET_PROCESS_OUTPUT: "get_process_output",
+	KILL_PROCESS: "kill_process",
+	LSP_INSPECT: "lsp_inspect",
+	NOTIFICATION_INBOX: "notification_inbox",
+	AGENT_CONNECTIONS_LIST: "agent_connections_list",
+	AGENT_CONNECT: "agent_connect",
+	AGENT_DISCONNECT: "agent_disconnect",
+	AGENT_SIGNAL_SEND: "agent_signal_send"
+};
+/**
+* Workspace tool name remapping config.
+* Maps core workspace tool constants to mastracode's tool names.
+* Pass this (or spread it) into `Workspace({ tools: ... })`.
+*/
+const TOOL_NAME_OVERRIDES = {
+	[WORKSPACE_TOOLS.FILESYSTEM.READ_FILE]: { name: MC_TOOLS.VIEW },
+	[WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE]: { name: MC_TOOLS.WRITE_FILE },
+	[WORKSPACE_TOOLS.FILESYSTEM.EDIT_FILE]: { name: MC_TOOLS.STRING_REPLACE_LSP },
+	[WORKSPACE_TOOLS.FILESYSTEM.LIST_FILES]: { name: MC_TOOLS.FIND_FILES },
+	[WORKSPACE_TOOLS.FILESYSTEM.DELETE]: { name: MC_TOOLS.DELETE_FILE },
+	[WORKSPACE_TOOLS.FILESYSTEM.FILE_STAT]: { name: MC_TOOLS.FILE_STAT },
+	[WORKSPACE_TOOLS.FILESYSTEM.MKDIR]: { name: MC_TOOLS.MKDIR },
+	[WORKSPACE_TOOLS.FILESYSTEM.GREP]: { name: MC_TOOLS.SEARCH_CONTENT },
+	[WORKSPACE_TOOLS.FILESYSTEM.AST_EDIT]: { name: MC_TOOLS.AST_SMART_EDIT },
+	[WORKSPACE_TOOLS.SANDBOX.EXECUTE_COMMAND]: { name: MC_TOOLS.EXECUTE_COMMAND },
+	[WORKSPACE_TOOLS.SANDBOX.GET_PROCESS_OUTPUT]: { name: MC_TOOLS.GET_PROCESS_OUTPUT },
+	[WORKSPACE_TOOLS.SANDBOX.KILL_PROCESS]: { name: MC_TOOLS.KILL_PROCESS },
+	[WORKSPACE_TOOLS.LSP.LSP_INSPECT]: { name: MC_TOOLS.LSP_INSPECT }
+};
+//#endregion
+export { MC_TOOLS, TOOL_NAME_OVERRIDES };
+
+//# sourceMappingURL=tool-names.js.map

package/dist/tool-names.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-names.js","names":[],"sources":["../src/tool-names.ts"],"sourcesContent":["/**\n * Mastracode tool name constants.\n *\n * These are the names exposed to the LLM via workspace tool name remapping.\n * Used throughout mastracode for permissions, TUI rendering, tool guidance,\n * subagent allowedTools, etc.\n *\n * The workspace tools get remapped from their core names (e.g. `mastra_workspace_read_file`)\n * to these names (e.g. `view`) via the `name` property in workspace tool config.\n */\n\nimport { WORKSPACE_TOOLS } from '@mastra/core/workspace';\n\nexport const MC_TOOLS = {\n  // Filesystem\n  VIEW: 'view',\n  WRITE_FILE: 'write_file',\n  STRING_REPLACE_LSP: 'string_replace_lsp',\n  FIND_FILES: 'find_files',\n  DELETE_FILE: 'delete_file',\n  FILE_STAT: 'file_stat',\n  MKDIR: 'mkdir',\n\n  // Search\n  SEARCH_CONTENT: 'search_content',\n\n  // Code intelligence\n  AST_SMART_EDIT: 'ast_smart_edit',\n\n  // Sandbox\n  EXECUTE_COMMAND: 'execute_command',\n  GET_PROCESS_OUTPUT: 'get_process_output',\n  KILL_PROCESS: 'kill_process',\n\n  // Code intelligence\n  LSP_INSPECT: 'lsp_inspect',\n\n  // Notifications\n  NOTIFICATION_INBOX: 'notification_inbox',\n\n  // Agent connections\n  AGENT_CONNECTIONS_LIST: 'agent_connections_list',\n  AGENT_CONNECT: 'agent_connect',\n  AGENT_DISCONNECT: 'agent_disconnect',\n  AGENT_SIGNAL_SEND: 'agent_signal_send',\n} as const;\n\n/**\n * Workspace tool name remapping config.\n * Maps core workspace tool constants to mastracode's tool names.\n * Pass this (or spread it) into `Workspace({ tools: ... })`.\n */\nexport const TOOL_NAME_OVERRIDES = {\n  [WORKSPACE_TOOLS.FILESYSTEM.READ_FILE]: { name: MC_TOOLS.VIEW },\n  [WORKSPACE_TOOLS.FILESYSTEM.WRITE_FILE]: { name: MC_TOOLS.WRITE_FILE },\n  [WORKSPACE_TOOLS.FILESYSTEM.EDIT_FILE]: { name: MC_TOOLS.STRING_REPLACE_LSP },\n  [WORKSPACE_TOOLS.FILESYSTEM.LIST_FILES]: { name: MC_TOOLS.FIND_FILES },\n  [WORKSPACE_TOOLS.FILESYSTEM.DELETE]: { name: MC_TOOLS.DELETE_FILE },\n  [WORKSPACE_TOOLS.FILESYSTEM.FILE_STAT]: { name: MC_TOOLS.FILE_STAT },\n  [WORKSPACE_TOOLS.FILESYSTEM.MKDIR]: { name: MC_TOOLS.MKDIR },\n  [WORKSPACE_TOOLS.FILESYSTEM.GREP]: { name: MC_TOOLS.SEARCH_CONTENT },\n  [WORKSPACE_TOOLS.FILESYSTEM.AST_EDIT]: { name: MC_TOOLS.AST_SMART_EDIT },\n  [WORKSPACE_TOOLS.SANDBOX.EXECUTE_COMMAND]: { name: MC_TOOLS.EXECUTE_COMMAND },\n  [WORKSPACE_TOOLS.SANDBOX.GET_PROCESS_OUTPUT]: { name: MC_TOOLS.GET_PROCESS_OUTPUT },\n  [WORKSPACE_TOOLS.SANDBOX.KILL_PROCESS]: { name: MC_TOOLS.KILL_PROCESS },\n  [WORKSPACE_TOOLS.LSP.LSP_INSPECT]: { name: MC_TOOLS.LSP_INSPECT },\n} as const;\n"],"mappings":";;;;;;;;;;;;AAaA,MAAa,WAAW;CAEtB,MAAM;CACN,YAAY;CACZ,oBAAoB;CACpB,YAAY;CACZ,aAAa;CACb,WAAW;CACX,OAAO;CAGP,gBAAgB;CAGhB,gBAAgB;CAGhB,iBAAiB;CACjB,oBAAoB;CACpB,cAAc;CAGd,aAAa;CAGb,oBAAoB;CAGpB,wBAAwB;CACxB,eAAe;CACf,kBAAkB;CAClB,mBAAmB;AACrB;;;;;;AAOA,MAAa,sBAAsB;EAChC,gBAAgB,WAAW,YAAY,EAAE,MAAM,SAAS,KAAK;EAC7D,gBAAgB,WAAW,aAAa,EAAE,MAAM,SAAS,WAAW;EACpE,gBAAgB,WAAW,YAAY,EAAE,MAAM,SAAS,mBAAmB;EAC3E,gBAAgB,WAAW,aAAa,EAAE,MAAM,SAAS,WAAW;EACpE,gBAAgB,WAAW,SAAS,EAAE,MAAM,SAAS,YAAY;EACjE,gBAAgB,WAAW,YAAY,EAAE,MAAM,SAAS,UAAU;EAClE,gBAAgB,WAAW,QAAQ,EAAE,MAAM,SAAS,MAAM;EAC1D,gBAAgB,WAAW,OAAO,EAAE,MAAM,SAAS,eAAe;EAClE,gBAAgB,WAAW,WAAW,EAAE,MAAM,SAAS,eAAe;EACtE,gBAAgB,QAAQ,kBAAkB,EAAE,MAAM,SAAS,gBAAgB;EAC3E,gBAAgB,QAAQ,qBAAqB,EAAE,MAAM,SAAS,mBAAmB;EACjF,gBAAgB,QAAQ,eAAe,EAAE,MAAM,SAAS,aAAa;EACrE,gBAAgB,IAAI,cAAc,EAAE,MAAM,SAAS,YAAY;AAClE"}

package/dist/tools/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tool exports for Mastra Code
+ */
+export { createConfiguredWebTools, createParallelWebExtractTool, createParallelWebSearchTool, createWebExtractTool, createWebSearchTool, hasParallelKey, hasTavilyKey, resolveWebSearchProvider, } from './web-search.js';
+export { requestSandboxAccessTool } from './request-sandbox-access.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,wBAAwB,EACxB,4BAA4B,EAC5B,2BAA2B,EAC3B,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,YAAY,EACZ,wBAAwB,GACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/tools/index.js

@@ -0,0 +1,3 @@
+import { createConfiguredWebTools, createParallelWebExtractTool, createParallelWebSearchTool, createWebExtractTool, createWebSearchTool, hasParallelKey, hasTavilyKey, resolveWebSearchProvider } from "./web-search.js";
+import { requestSandboxAccessTool } from "./request-sandbox-access.js";
+export { createConfiguredWebTools, createParallelWebExtractTool, createParallelWebSearchTool, createWebExtractTool, createWebSearchTool, hasParallelKey, hasTavilyKey, requestSandboxAccessTool, resolveWebSearchProvider };

package/dist/tools/request-sandbox-access.d.ts

@@ -0,0 +1,6 @@
+/**
+ * request_access tool — requests permission to access a directory outside the project root.
+ * The user can approve or deny the request via TUI dialog.
+ */
+export declare const requestSandboxAccessTool: import("@mastra/core/tools").Tool<unknown, unknown, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, string, unknown>;
+//# sourceMappingURL=request-sandbox-access.d.ts.map

package/dist/tools/request-sandbox-access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-sandbox-access.d.ts","sourceRoot":"","sources":["../../src/tools/request-sandbox-access.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA2BH,eAAO,MAAM,wBAAwB,sKA6F5B,CAAC"}

package/dist/tools/request-sandbox-access.js

@@ -0,0 +1,80 @@
+import { getAllowedPathsFromContext, isPathAllowed } from "./utils.js";
+import * as path$1 from "path";
+import * as os$1 from "os";
+import { LocalFilesystem } from "@mastra/core/workspace";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+//#region src/tools/request-sandbox-access.ts
+/**
+* request_access tool — requests permission to access a directory outside the project root.
+* The user can approve or deny the request via TUI dialog.
+*/
+function expandTilde(p) {
+	if (p === "~") return os$1.homedir();
+	if (p.startsWith("~/") || p.startsWith("~\\")) return path$1.join(os$1.homedir(), p.slice(2));
+	return p;
+}
+const requestSandboxAccessTool = createTool({
+	id: "request_access",
+	description: `Request permission to access a directory outside the current project. Use this when you need to read or write files in a directory that is not within the project root. The user will be prompted to approve or deny the request.`,
+	inputSchema: z.object({
+		path: z.string().min(1).describe("The absolute path to the directory you need access to."),
+		reason: z.string().min(1).describe("Brief explanation of why you need access to this directory.")
+	}),
+	suspendSchema: z.object({
+		kind: z.literal("sandbox_access_request"),
+		path: z.string(),
+		reason: z.string()
+	}),
+	resumeSchema: z.union([z.string(), z.array(z.string())]),
+	execute: async ({ path: requestedPath, reason }, context) => {
+		try {
+			const agentControllerCtx = context?.requestContext?.get("controller");
+			const projectRoot = agentControllerCtx?.getState()?.projectPath ?? process.cwd();
+			const expanded = expandTilde(requestedPath);
+			const absolutePath = path$1.isAbsolute(expanded) ? expanded : path$1.resolve(projectRoot, expanded);
+			if (isPathAllowed(absolutePath, projectRoot, getAllowedPathsFromContext(context))) return {
+				content: `Access already granted: "${absolutePath}" is within the project root or allowed paths.`,
+				isError: false
+			};
+			const suspend = context?.agent?.suspend ?? context?.suspend;
+			const resumeData = context?.agent?.resumeData ?? context?.resumeData;
+			if (resumeData === void 0) {
+				if (!suspend) return {
+					content: `Cannot request sandbox access: interactive context not available. The user should manually run /sandbox add ${absolutePath}`,
+					isError: true
+				};
+				await suspend({
+					kind: "sandbox_access_request",
+					path: absolutePath,
+					reason
+				});
+				return;
+			}
+			const answerText = Array.isArray(resumeData) ? resumeData.join(", ") : String(resumeData);
+			if (answerText.toLowerCase().startsWith("y") || answerText.toLowerCase() === "approve") {
+				const currentAllowed = (agentControllerCtx?.getState())?.sandboxAllowedPaths ?? [];
+				const nextAllowed = currentAllowed.includes(absolutePath) ? currentAllowed : [...currentAllowed, absolutePath];
+				if (!currentAllowed.includes(absolutePath)) await agentControllerCtx?.setState({ sandboxAllowedPaths: nextAllowed });
+				const fs = agentControllerCtx?.workspace?.filesystem ?? context?.workspace?.filesystem;
+				if (fs instanceof LocalFilesystem) fs.setAllowedPaths((prev) => [...prev, absolutePath]);
+				return {
+					content: `Access granted: "${absolutePath}" has been added to allowed paths. You can now access files in this directory.`,
+					isError: false
+				};
+			} else return {
+				content: `Access denied: The user declined access to "${absolutePath}".`,
+				isError: false
+			};
+		} catch (error) {
+			return {
+				content: `Failed to request sandbox access: ${error instanceof Error ? error.message : "Unknown error"}`,
+				isError: true
+			};
+		}
+	}
+});
+//#endregion
+export { requestSandboxAccessTool };
+
+//# sourceMappingURL=request-sandbox-access.js.map

package/dist/tools/request-sandbox-access.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-sandbox-access.js","names":["os","path"],"sources":["../../src/tools/request-sandbox-access.ts"],"sourcesContent":["/**\n * request_access tool — requests permission to access a directory outside the project root.\n * The user can approve or deny the request via TUI dialog.\n */\n\nimport * as os from 'node:os';\nimport * as path from 'node:path';\nimport type { AgentControllerRequestContext } from '@mastra/core/agent-controller';\nimport { createTool } from '@mastra/core/tools';\nimport { LocalFilesystem } from '@mastra/core/workspace';\nimport { z } from 'zod';\nimport type { MastraCodeState } from '../schema.js';\nimport { isPathAllowed, getAllowedPathsFromContext } from './utils.js';\n\nfunction expandTilde(p: string): string {\n  if (p === '~') return os.homedir();\n  if (p.startsWith('~/') || p.startsWith('~\\\\')) return path.join(os.homedir(), p.slice(2));\n  return p;\n}\n\ntype RequestSandboxAccessInput = {\n  path: string;\n  reason: string;\n};\n\nconst requestSandboxAccessInputSchema = z.object({\n  path: z.string().min(1).describe('The absolute path to the directory you need access to.'),\n  reason: z.string().min(1).describe('Brief explanation of why you need access to this directory.'),\n});\n\nexport const requestSandboxAccessTool = createTool({\n  id: 'request_access',\n  description: `Request permission to access a directory outside the current project. Use this when you need to read or write files in a directory that is not within the project root. The user will be prompted to approve or deny the request.`,\n  inputSchema: requestSandboxAccessInputSchema,\n  suspendSchema: z.object({\n    kind: z.literal('sandbox_access_request'),\n    path: z.string(),\n    reason: z.string(),\n  }),\n  resumeSchema: z.union([z.string(), z.array(z.string())]),\n  execute: async ({ path: requestedPath, reason }: RequestSandboxAccessInput, context: any) => {\n    try {\n      const agentControllerCtx = context?.requestContext?.get('controller') as\n        | AgentControllerRequestContext<MastraCodeState>\n        | undefined;\n\n      // Resolve to absolute path (expand ~ first since Node path APIs don't handle it)\n      const projectRoot = agentControllerCtx?.getState()?.projectPath ?? process.cwd();\n      const expanded = expandTilde(requestedPath);\n      const absolutePath = path.isAbsolute(expanded) ? expanded : path.resolve(projectRoot, expanded);\n\n      // Check if already allowed\n      const allowedPaths = getAllowedPathsFromContext(context);\n      if (isPathAllowed(absolutePath, projectRoot, allowedPaths)) {\n        return {\n          content: `Access already granted: \"${absolutePath}\" is within the project root or allowed paths.`,\n          isError: false,\n        };\n      }\n\n      const suspend = context?.agent?.suspend ?? context?.suspend;\n      const resumeData = context?.agent?.resumeData ?? context?.resumeData;\n\n      // First pass: pause via the native tool-suspension primitive so the host can\n      // prompt the user. The suspend payload carries the request details; the host\n      // resumes with the user's answer as resume data.\n      if (resumeData === undefined) {\n        if (!suspend) {\n          return {\n            content: `Cannot request sandbox access: interactive context not available. The user should manually run /sandbox add ${absolutePath}`,\n            isError: true,\n          };\n        }\n        await suspend({ kind: 'sandbox_access_request', path: absolutePath, reason });\n        return;\n      }\n\n      const answerText = Array.isArray(resumeData) ? resumeData.join(', ') : String(resumeData);\n      const approved = answerText.toLowerCase().startsWith('y') || answerText.toLowerCase() === 'approve';\n      if (approved) {\n        // Persist to controller state first (and await it) so the value is\n        // committed before the next tool call re-derives the workspace's\n        // allowed paths from state. The workspace factory rebuilds the\n        // filesystem allowlist from `sandboxAllowedPaths` on every call\n        // (getDynamicWorkspace), so an unawaited setState would let that\n        // rebuild clobber the in-turn widen below before the grant lands.\n        const controllerState = agentControllerCtx?.getState();\n        const currentAllowed = (controllerState?.sandboxAllowedPaths as string[] | undefined) ?? [];\n        const nextAllowed = currentAllowed.includes(absolutePath) ? currentAllowed : [...currentAllowed, absolutePath];\n        if (!currentAllowed.includes(absolutePath)) {\n          await agentControllerCtx?.setState({\n            sandboxAllowedPaths: nextAllowed,\n          });\n        }\n\n        // Also update the live workspace filesystem immediately so tools in\n        // the same turn (e.g. `view`) can access the path without waiting for\n        // a fresh workspace build. The resolved workspace is carried on the\n        // controller request context — the tool-execution context does not expose\n        // it — so read the filesystem from there.\n        const fs = agentControllerCtx?.workspace?.filesystem ?? context?.workspace?.filesystem;\n        if (fs instanceof LocalFilesystem) {\n          fs.setAllowedPaths((prev: readonly string[]) => [...prev, absolutePath]);\n        }\n\n        return {\n          content: `Access granted: \"${absolutePath}\" has been added to allowed paths. You can now access files in this directory.`,\n          isError: false,\n        };\n      } else {\n        return {\n          content: `Access denied: The user declined access to \"${absolutePath}\".`,\n          isError: false,\n        };\n      }\n    } catch (error) {\n      const msg = error instanceof Error ? error.message : 'Unknown error';\n      return {\n        content: `Failed to request sandbox access: ${msg}`,\n        isError: true,\n      };\n    }\n  },\n} as any);\n"],"mappings":";;;;;;;;;;;AAcA,SAAS,YAAY,GAAmB;CACtC,IAAI,MAAM,KAAK,OAAOA,KAAG,QAAQ;CACjC,IAAI,EAAE,WAAW,IAAI,KAAK,EAAE,WAAW,KAAK,GAAG,OAAOC,OAAK,KAAKD,KAAG,QAAQ,GAAG,EAAE,MAAM,CAAC,CAAC;CACxF,OAAO;AACT;AAYA,MAAa,2BAA2B,WAAW;CACjD,IAAI;CACJ,aAAa;CACb,aARsC,EAAE,OAAO;EAC/C,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,wDAAwD;EACzF,QAAQ,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,6DAA6D;CAClG,CAKe;CACb,eAAe,EAAE,OAAO;EACtB,MAAM,EAAE,QAAQ,wBAAwB;EACxC,MAAM,EAAE,OAAO;EACf,QAAQ,EAAE,OAAO;CACnB,CAAC;CACD,cAAc,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACvD,SAAS,OAAO,EAAE,MAAM,eAAe,UAAqC,YAAiB;EAC3F,IAAI;GACF,MAAM,qBAAqB,SAAS,gBAAgB,IAAI,YAAY;GAKpE,MAAM,cAAc,oBAAoB,SAAS,CAAC,EAAE,eAAe,QAAQ,IAAI;GAC/E,MAAM,WAAW,YAAY,aAAa;GAC1C,MAAM,eAAeC,OAAK,WAAW,QAAQ,IAAI,WAAWA,OAAK,QAAQ,aAAa,QAAQ;GAI9F,IAAI,cAAc,cAAc,aADX,2BAA2B,OACQ,CAAC,GACvD,OAAO;IACL,SAAS,4BAA4B,aAAa;IAClD,SAAS;GACX;GAGF,MAAM,UAAU,SAAS,OAAO,WAAW,SAAS;GACpD,MAAM,aAAa,SAAS,OAAO,cAAc,SAAS;GAK1D,IAAI,eAAe,KAAA,GAAW;IAC5B,IAAI,CAAC,SACH,OAAO;KACL,SAAS,+GAA+G;KACxH,SAAS;IACX;IAEF,MAAM,QAAQ;KAAE,MAAM;KAA0B,MAAM;KAAc;IAAO,CAAC;IAC5E;GACF;GAEA,MAAM,aAAa,MAAM,QAAQ,UAAU,IAAI,WAAW,KAAK,IAAI,IAAI,OAAO,UAAU;GAExF,IADiB,WAAW,YAAY,CAAC,CAAC,WAAW,GAAG,KAAK,WAAW,YAAY,MAAM,WAC5E;IAQZ,MAAM,kBADkB,oBAAoB,SAAS,EAAA,EACZ,uBAAgD,CAAC;IAC1F,MAAM,cAAc,eAAe,SAAS,YAAY,IAAI,iBAAiB,CAAC,GAAG,gBAAgB,YAAY;IAC7G,IAAI,CAAC,eAAe,SAAS,YAAY,GACvC,MAAM,oBAAoB,SAAS,EACjC,qBAAqB,YACvB,CAAC;IAQH,MAAM,KAAK,oBAAoB,WAAW,cAAc,SAAS,WAAW;IAC5E,IAAI,cAAc,iBAChB,GAAG,iBAAiB,SAA4B,CAAC,GAAG,MAAM,YAAY,CAAC;IAGzE,OAAO;KACL,SAAS,oBAAoB,aAAa;KAC1C,SAAS;IACX;GACF,OACE,OAAO;IACL,SAAS,+CAA+C,aAAa;IACrE,SAAS;GACX;EAEJ,SAAS,OAAO;GAEd,OAAO;IACL,SAAS,qCAFC,iBAAiB,QAAQ,MAAM,UAAU;IAGnD,SAAS;GACX;EACF;CACF;AACF,CAAQ"}

package/dist/tools/utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Check whether `targetPath` falls inside `projectRoot` or any of the
+ * additional `allowedPaths`.  All arguments are expected to be absolute.
+ *
+ * Returns `true` when access should be **allowed**.
+ */
+export declare function isPathAllowed(targetPath: string, projectRoot: string, allowedPaths?: string[]): boolean;
+/**
+ * Read allowed paths from the Mastra controller runtime context.
+ * Combines skill paths (computed dynamically from projectPath and configDir)
+ * with user-approved sandbox paths from controller state so that both parent
+ * and subagent tools have the same access.
+ * Returns default skill paths when the context is unavailable (e.g. in tests).
+ */
+export declare function getAllowedPathsFromContext(toolContext: {
+    requestContext?: {
+        get: (key: string) => unknown;
+    };
+} | undefined): string[];
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/tools/utils.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAE,MAAM,EAAO,GAAG,OAAO,CAK3G;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE;IAAE,cAAc,CAAC,EAAE;QAAE,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;KAAE,CAAA;CAAE,GAAG,SAAS,GAC9E,MAAM,EAAE,CAgBV"}

package/dist/tools/utils.js

@@ -0,0 +1,32 @@
+import "../constants.js";
+import { buildSkillPaths } from "../agents/workspace.js";
+import * as path$1 from "path";
+//#region src/tools/utils.ts
+/**
+* Check whether `targetPath` falls inside `projectRoot` or any of the
+* additional `allowedPaths`.  All arguments are expected to be absolute.
+*
+* Returns `true` when access should be **allowed**.
+*/
+function isPathAllowed(targetPath, projectRoot, allowedPaths = []) {
+	const resolved = path$1.resolve(targetPath);
+	return [projectRoot, ...allowedPaths].map((p) => path$1.resolve(p)).some((root) => resolved === root || resolved.startsWith(root + path$1.sep));
+}
+/**
+* Read allowed paths from the Mastra controller runtime context.
+* Combines skill paths (computed dynamically from projectPath and configDir)
+* with user-approved sandbox paths from controller state so that both parent
+* and subagent tools have the same access.
+* Returns default skill paths when the context is unavailable (e.g. in tests).
+*/
+function getAllowedPathsFromContext(toolContext) {
+	const agentControllerCtx = toolContext?.requestContext?.get("controller");
+	const state = agentControllerCtx?.getState?.() ?? agentControllerCtx?.session?.state?.get?.();
+	const skillPaths = buildSkillPaths(state?.projectPath ? path$1.resolve(state.projectPath) : process.cwd(), state?.configDir ?? ".mastracode");
+	const sandboxPaths = state?.sandboxAllowedPaths ?? [];
+	return [...skillPaths, ...sandboxPaths];
+}
+//#endregion
+export { getAllowedPathsFromContext, isPathAllowed };
+
+//# sourceMappingURL=utils.js.map

package/dist/tools/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["path"],"sources":["../../src/tools/utils.ts"],"sourcesContent":["import * as path from 'node:path';\nimport { buildSkillPaths } from '../agents/workspace.js';\nimport { DEFAULT_CONFIG_DIR } from '../constants.js';\n\n/**\n * Check whether `targetPath` falls inside `projectRoot` or any of the\n * additional `allowedPaths`.  All arguments are expected to be absolute.\n *\n * Returns `true` when access should be **allowed**.\n */\nexport function isPathAllowed(targetPath: string, projectRoot: string, allowedPaths: string[] = []): boolean {\n  const resolved = path.resolve(targetPath);\n  const roots = [projectRoot, ...allowedPaths].map(p => path.resolve(p));\n\n  return roots.some(root => resolved === root || resolved.startsWith(root + path.sep));\n}\n\n/**\n * Read allowed paths from the Mastra controller runtime context.\n * Combines skill paths (computed dynamically from projectPath and configDir)\n * with user-approved sandbox paths from controller state so that both parent\n * and subagent tools have the same access.\n * Returns default skill paths when the context is unavailable (e.g. in tests).\n */\nexport function getAllowedPathsFromContext(\n  toolContext: { requestContext?: { get: (key: string) => unknown } } | undefined,\n): string[] {\n  const agentControllerCtx = toolContext?.requestContext?.get('controller') as\n    | {\n        getState?: () => { sandboxAllowedPaths?: string[]; projectPath?: string; configDir?: string };\n        session?: {\n          state?: { get?: () => { sandboxAllowedPaths?: string[]; projectPath?: string; configDir?: string } };\n        };\n      }\n    | undefined;\n  const state = agentControllerCtx?.getState?.() ?? agentControllerCtx?.session?.state?.get?.();\n  const projectPath = state?.projectPath ? path.resolve(state.projectPath) : process.cwd();\n  const configDir = state?.configDir ?? DEFAULT_CONFIG_DIR;\n  const skillPaths = buildSkillPaths(projectPath, configDir);\n  const sandboxPaths = state?.sandboxAllowedPaths ?? [];\n\n  return [...skillPaths, ...sandboxPaths];\n}\n"],"mappings":";;;;;;;;;;AAUA,SAAgB,cAAc,YAAoB,aAAqB,eAAyB,CAAC,GAAY;CAC3G,MAAM,WAAWA,OAAK,QAAQ,UAAU;CAGxC,OAFc,CAAC,aAAa,GAAG,YAAY,CAAC,CAAC,KAAI,MAAKA,OAAK,QAAQ,CAAC,CAEzD,CAAC,CAAC,MAAK,SAAQ,aAAa,QAAQ,SAAS,WAAW,OAAOA,OAAK,GAAG,CAAC;AACrF;;;;;;;;AASA,SAAgB,2BACd,aACU;CACV,MAAM,qBAAqB,aAAa,gBAAgB,IAAI,YAAY;CAQxE,MAAM,QAAQ,oBAAoB,WAAW,KAAK,oBAAoB,SAAS,OAAO,MAAM;CAG5F,MAAM,aAAa,gBAFC,OAAO,cAAcA,OAAK,QAAQ,MAAM,WAAW,IAAI,QAAQ,IAAI,GACrE,OAAO,aAAA,aACgC;CACzD,MAAM,eAAe,OAAO,uBAAuB,CAAC;CAEpD,OAAO,CAAC,GAAG,YAAY,GAAG,YAAY;AACxC"}