@mastra/code-sdk 0.0.0-livekit-beta-v3-20260709031728

package/dist/schema.js

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import { DEFAULT_CONFIG_DIR, DEFAULT_OM_MODEL_ID } from "./constants.js";
+const stateSchema = z.object({
+  // Session-scoped selection.
+  // validates state against this schema, so they MUST be declared here — Zod
+  // strips unknown keys on parse, which would otherwise silently discard the
+  // seeded model and leave the controller with no model selected.
+  currentModelId: z.string().optional(),
+  modeId: z.string().optional(),
+  subagentModelId: z.string().optional(),
+  projectPath: z.string().optional(),
+  projectName: z.string().optional(),
+  githubProjectId: z.string().optional(),
+  sandboxId: z.string().optional(),
+  sandboxWorkdir: z.string().optional(),
+  worktreePath: z.string().optional(),
+  branch: z.string().optional(),
+  configDir: z.string().default(DEFAULT_CONFIG_DIR),
+  homeDir: z.string().optional(),
+  gitBranch: z.string().optional(),
+  lastCommand: z.string().optional(),
+  // Observational Memory model settings
+  observerModelId: z.string().default(DEFAULT_OM_MODEL_ID),
+  reflectorModelId: z.string().default(DEFAULT_OM_MODEL_ID),
+  // Observational Memory threshold settings
+  observationThreshold: z.number().default(3e4),
+  reflectionThreshold: z.number().default(4e4),
+  // Whether observations and reflections use the terse caveman-style instruction.
+  // Off by default — caveman style is opt-in via `/om` settings; observers and
+  // reflectors fall back to their built-in (prose) behavior unless enabled.
+  cavemanObservations: z.boolean().default(false),
+  // Whether OM forwards image/file attachment parts to the Observer LLM.
+  // 'auto' (default) checks the provider capabilities registry to decide.
+  // true/false forces the setting regardless of model capabilities.
+  observeAttachments: z.union([z.literal("auto"), z.boolean()]).default("auto"),
+  // Observational Memory scope — 'thread' (per-conversation) or 'resource' (shared across threads)
+  omScope: z.enum(["thread", "resource"]).optional(),
+  // Thinking level for model reasoning effort
+  thinkingLevel: z.enum(["off", "low", "medium", "high", "xhigh"]).default("off"),
+  // YOLO mode — auto-approve all tool calls
+  yolo: z.boolean().default(false),
+  // Permission rules — per-category and per-tool approval policies
+  permissionRules: z.object({
+    categories: z.record(z.string(), z.enum(["allow", "ask", "deny"])).default({}),
+    tools: z.record(z.string(), z.enum(["allow", "ask", "deny"])).default({})
+  }).default({ categories: {}, tools: {} }),
+  // Smart editing mode — use AST-based analysis for code edits
+  smartEditing: z.boolean().default(true),
+  // Notification mode — alert when TUI needs user attention
+  notifications: z.enum(["bell", "system", "both", "off"]).default("off"),
+  // Task list (ephemeral per-thread, cleared on thread switch/creation)
+  tasks: z.array(
+    z.object({
+      id: z.string().optional(),
+      content: z.string(),
+      status: z.enum(["pending", "in_progress", "completed"]),
+      activeForm: z.string()
+    })
+  ).default([]),
+  // Sandbox allowed paths (per-thread, absolute paths allowed in addition to project root)
+  sandboxAllowedPaths: z.array(z.string()).default([]),
+  // Asset directories contributed by active plugins.
+  pluginSkillPaths: z.array(z.string()).default([]),
+  pluginCommandPaths: z.array(z.string()).default([]),
+  pluginInstructions: z.array(z.string()).default([]),
+  // Active plan (set when a plan is approved in Plan mode)
+  activePlan: z.object({
+    title: z.string(),
+    plan: z.string(),
+    approvedAt: z.string()
+  }).nullable().default(null),
+  // Active browser settings (tracks what's actually running vs. what's in the settings file)
+  activeBrowserSettings: z.object({
+    enabled: z.boolean(),
+    provider: z.enum(["stagehand", "agent-browser"]),
+    headless: z.boolean().optional(),
+    viewport: z.object({
+      width: z.number(),
+      height: z.number()
+    }).optional(),
+    cdpUrl: z.string().optional(),
+    stagehand: z.object({
+      env: z.enum(["LOCAL", "BROWSERBASE"]),
+      apiKey: z.string().optional(),
+      projectId: z.string().optional()
+    }).optional()
+  }).optional()
+});
+export {
+  stateSchema
+};
+//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema.ts"],"sourcesContent":["import { z } from 'zod';\nimport { DEFAULT_CONFIG_DIR, DEFAULT_OM_MODEL_ID } from './constants.js';\n\nexport type PermissionPolicy = 'allow' | 'ask' | 'deny';\n\nexport type MastraCodeSessionState = {\n  currentModelId: string;\n  modeId: string;\n};\n\nexport type MastraCodeComposedState = MastraCodeState & MastraCodeSessionState;\n\nexport interface MastraCodeState {\n  [key: string]: unknown;\n  [key: `subagentModelId_${string}`]: string | undefined;\n  subagentModelId?: string;\n  projectPath?: string;\n  projectName?: string;\n  /** When set, this project is a GitHub/cloud-sandbox-backed project. */\n  githubProjectId?: string;\n  /** Persisted sandbox id for reattaching the project's cloud workspace. */\n  sandboxId?: string;\n  /** Path inside the sandbox the repo is cloned into. */\n  sandboxWorkdir?: string;\n  /** Active git worktree path inside the sandbox for the current unit of work. */\n  worktreePath?: string;\n  /** Active feature branch checked out in the worktree. */\n  branch?: string;\n  configDir: string;\n  homeDir?: string;\n  gitBranch?: string;\n  lastCommand?: string;\n  observerModelId: string;\n  reflectorModelId: string;\n  observationThreshold: number;\n  reflectionThreshold: number;\n  cavemanObservations: boolean;\n  observeAttachments: 'auto' | boolean;\n  omScope?: 'thread' | 'resource';\n  thinkingLevel: 'off' | 'low' | 'medium' | 'high' | 'xhigh';\n  yolo: boolean;\n  permissionRules: {\n    categories: Record<string, PermissionPolicy>;\n    tools: Record<string, PermissionPolicy>;\n  };\n  smartEditing: boolean;\n  notifications: 'bell' | 'system' | 'both' | 'off';\n  tasks: Array<{\n    id?: string;\n    content: string;\n    status: 'pending' | 'in_progress' | 'completed';\n    activeForm: string;\n  }>;\n  sandboxAllowedPaths: string[];\n  pluginSkillPaths: string[];\n  pluginCommandPaths: string[];\n  pluginInstructions: string[];\n  activePlan: {\n    title: string;\n    plan: string;\n    approvedAt: string;\n  } | null;\n  activeBrowserSettings?: {\n    enabled: boolean;\n    provider: 'stagehand' | 'agent-browser';\n    headless?: boolean;\n    viewport?: {\n      width: number;\n      height: number;\n    };\n    cdpUrl?: string;\n    stagehand?: {\n      env: 'LOCAL' | 'BROWSERBASE';\n      apiKey?: string;\n      projectId?: string;\n    };\n  };\n}\n\nexport const stateSchema = z.object({\n  // Session-scoped selection.\n  // validates state against this schema, so they MUST be declared here — Zod\n  // strips unknown keys on parse, which would otherwise silently discard the\n  // seeded model and leave the controller with no model selected.\n  currentModelId: z.string().optional(),\n  modeId: z.string().optional(),\n  subagentModelId: z.string().optional(),\n  projectPath: z.string().optional(),\n  projectName: z.string().optional(),\n  githubProjectId: z.string().optional(),\n  sandboxId: z.string().optional(),\n  sandboxWorkdir: z.string().optional(),\n  worktreePath: z.string().optional(),\n  branch: z.string().optional(),\n  configDir: z.string().default(DEFAULT_CONFIG_DIR),\n  homeDir: z.string().optional(),\n  gitBranch: z.string().optional(),\n  lastCommand: z.string().optional(),\n  // Observational Memory model settings\n  observerModelId: z.string().default(DEFAULT_OM_MODEL_ID),\n  reflectorModelId: z.string().default(DEFAULT_OM_MODEL_ID),\n  // Observational Memory threshold settings\n  observationThreshold: z.number().default(30_000),\n  reflectionThreshold: z.number().default(40_000),\n  // Whether observations and reflections use the terse caveman-style instruction.\n  // Off by default — caveman style is opt-in via `/om` settings; observers and\n  // reflectors fall back to their built-in (prose) behavior unless enabled.\n  cavemanObservations: z.boolean().default(false),\n  // Whether OM forwards image/file attachment parts to the Observer LLM.\n  // 'auto' (default) checks the provider capabilities registry to decide.\n  // true/false forces the setting regardless of model capabilities.\n  observeAttachments: z.union([z.literal('auto'), z.boolean()]).default('auto'),\n  // Observational Memory scope — 'thread' (per-conversation) or 'resource' (shared across threads)\n  omScope: z.enum(['thread', 'resource']).optional(),\n  // Thinking level for model reasoning effort\n  thinkingLevel: z.enum(['off', 'low', 'medium', 'high', 'xhigh']).default('off'),\n  // YOLO mode — auto-approve all tool calls\n  yolo: z.boolean().default(false),\n  // Permission rules — per-category and per-tool approval policies\n  permissionRules: z\n    .object({\n      categories: z.record(z.string(), z.enum(['allow', 'ask', 'deny'])).default({}),\n      tools: z.record(z.string(), z.enum(['allow', 'ask', 'deny'])).default({}),\n    })\n    .default({ categories: {}, tools: {} }),\n  // Smart editing mode — use AST-based analysis for code edits\n  smartEditing: z.boolean().default(true),\n  // Notification mode — alert when TUI needs user attention\n  notifications: z.enum(['bell', 'system', 'both', 'off']).default('off'),\n  // Task list (ephemeral per-thread, cleared on thread switch/creation)\n  tasks: z\n    .array(\n      z.object({\n        id: z.string().optional(),\n        content: z.string(),\n        status: z.enum(['pending', 'in_progress', 'completed']),\n        activeForm: z.string(),\n      }),\n    )\n    .default([]),\n  // Sandbox allowed paths (per-thread, absolute paths allowed in addition to project root)\n  sandboxAllowedPaths: z.array(z.string()).default([]),\n  // Asset directories contributed by active plugins.\n  pluginSkillPaths: z.array(z.string()).default([]),\n  pluginCommandPaths: z.array(z.string()).default([]),\n  pluginInstructions: z.array(z.string()).default([]),\n  // Active plan (set when a plan is approved in Plan mode)\n  activePlan: z\n    .object({\n      title: z.string(),\n      plan: z.string(),\n      approvedAt: z.string(),\n    })\n    .nullable()\n    .default(null),\n  // Active browser settings (tracks what's actually running vs. what's in the settings file)\n  activeBrowserSettings: z\n    .object({\n      enabled: z.boolean(),\n      provider: z.enum(['stagehand', 'agent-browser']),\n      headless: z.boolean().optional(),\n      viewport: z\n        .object({\n          width: z.number(),\n          height: z.number(),\n        })\n        .optional(),\n      cdpUrl: z.string().optional(),\n      stagehand: z\n        .object({\n          env: z.enum(['LOCAL', 'BROWSERBASE']),\n          apiKey: z.string().optional(),\n          projectId: z.string().optional(),\n        })\n        .optional(),\n    })\n    .optional(),\n});\n"],"mappings":"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","names":[]}

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,17 @@
+const mastraBrand = {
+  purple: "#7f45e0",
+  // #b588fe brand is too washed out for terminal
+  green: "#16c858",
+  // brand green (dark mode primary)
+  orange: "#fdac53",
+  pink: "#ff69cc",
+  blue: "#2563eb",
+  // #6ccdfb brand is to washed out
+  red: "#DC5663",
+  // #ff4758 too intense
+  yellow: "#e7e67b"
+};
+export {
+  mastraBrand
+};
+//# sourceMappingURL=theme-palette.js.map

package/dist/theme-palette.js.map

@@ -0,0 +1 @@
+{"version":3,"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":"AAOO,MAAM,cAAc;AAAA,EACzB,QAAQ;AAAA;AAAA,EACR,OAAO;AAAA;AAAA,EACP,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,MAAM;AAAA;AAAA,EACN,KAAK;AAAA;AAAA,EACL,QAAQ;AACV;","names":[]}

package/dist/tool-names.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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";
+};
+/**
+ * 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;;;;;;;;;;;;;;;CA0BX,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CActB,CAAC"}

package/dist/tool-names.js

@@ -0,0 +1,43 @@
+import { WORKSPACE_TOOLS } from "@mastra/core/workspace";
+const MC_TOOLS = {
+  // Filesystem
+  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
+  SEARCH_CONTENT: "search_content",
+  // Code intelligence
+  AST_SMART_EDIT: "ast_smart_edit",
+  // Sandbox
+  EXECUTE_COMMAND: "execute_command",
+  GET_PROCESS_OUTPUT: "get_process_output",
+  KILL_PROCESS: "kill_process",
+  // Code intelligence
+  LSP_INSPECT: "lsp_inspect",
+  // Notifications
+  NOTIFICATION_INBOX: "notification_inbox"
+};
+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 }
+};
+export {
+  MC_TOOLS,
+  TOOL_NAME_OVERRIDES
+};
+//# sourceMappingURL=tool-names.js.map

package/dist/tool-names.js.map

@@ -0,0 +1 @@
+{"version":3,"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} 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":"AAWA,SAAS,uBAAuB;AAEzB,MAAM,WAAW;AAAA;AAAA,EAEtB,MAAM;AAAA,EACN,YAAY;AAAA,EACZ,oBAAoB;AAAA,EACpB,YAAY;AAAA,EACZ,aAAa;AAAA,EACb,WAAW;AAAA,EACX,OAAO;AAAA;AAAA,EAGP,gBAAgB;AAAA;AAAA,EAGhB,gBAAgB;AAAA;AAAA,EAGhB,iBAAiB;AAAA,EACjB,oBAAoB;AAAA,EACpB,cAAc;AAAA;AAAA,EAGd,aAAa;AAAA;AAAA,EAGb,oBAAoB;AACtB;AAOO,MAAM,sBAAsB;AAAA,EACjC,CAAC,gBAAgB,WAAW,SAAS,GAAG,EAAE,MAAM,SAAS,KAAK;AAAA,EAC9D,CAAC,gBAAgB,WAAW,UAAU,GAAG,EAAE,MAAM,SAAS,WAAW;AAAA,EACrE,CAAC,gBAAgB,WAAW,SAAS,GAAG,EAAE,MAAM,SAAS,mBAAmB;AAAA,EAC5E,CAAC,gBAAgB,WAAW,UAAU,GAAG,EAAE,MAAM,SAAS,WAAW;AAAA,EACrE,CAAC,gBAAgB,WAAW,MAAM,GAAG,EAAE,MAAM,SAAS,YAAY;AAAA,EAClE,CAAC,gBAAgB,WAAW,SAAS,GAAG,EAAE,MAAM,SAAS,UAAU;AAAA,EACnE,CAAC,gBAAgB,WAAW,KAAK,GAAG,EAAE,MAAM,SAAS,MAAM;AAAA,EAC3D,CAAC,gBAAgB,WAAW,IAAI,GAAG,EAAE,MAAM,SAAS,eAAe;AAAA,EACnE,CAAC,gBAAgB,WAAW,QAAQ,GAAG,EAAE,MAAM,SAAS,eAAe;AAAA,EACvE,CAAC,gBAAgB,QAAQ,eAAe,GAAG,EAAE,MAAM,SAAS,gBAAgB;AAAA,EAC5E,CAAC,gBAAgB,QAAQ,kBAAkB,GAAG,EAAE,MAAM,SAAS,mBAAmB;AAAA,EAClF,CAAC,gBAAgB,QAAQ,YAAY,GAAG,EAAE,MAAM,SAAS,aAAa;AAAA,EACtE,CAAC,gBAAgB,IAAI,WAAW,GAAG,EAAE,MAAM,SAAS,YAAY;AAClE;","names":[]}

package/dist/tools/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tool exports for Mastra Code
+ */
+export { createWebSearchTool, createWebExtractTool, hasTavilyKey } 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,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC1F,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/tools/index.js

@@ -0,0 +1,9 @@
+import { createWebSearchTool, createWebExtractTool, hasTavilyKey } from "./web-search.js";
+import { requestSandboxAccessTool } from "./request-sandbox-access.js";
+export {
+  createWebExtractTool,
+  createWebSearchTool,
+  hasTavilyKey,
+  requestSandboxAccessTool
+};
+//# sourceMappingURL=index.js.map

package/dist/tools/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tools/index.ts"],"sourcesContent":["/**\n * Tool exports for Mastra Code\n */\n\nexport { createWebSearchTool, createWebExtractTool, hasTavilyKey } from './web-search.js';\nexport { requestSandboxAccessTool } from './request-sandbox-access.js';\n"],"mappings":"AAIA,SAAS,qBAAqB,sBAAsB,oBAAoB;AACxE,SAAS,gCAAgC;","names":[]}

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,88 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import { createTool } from "@mastra/core/tools";
+import { LocalFilesystem } from "@mastra/core/workspace";
+import { z } from "zod";
+import { isPathAllowed, getAllowedPathsFromContext } from "./utils.js";
+function expandTilde(p) {
+  if (p === "~") return os.homedir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+const requestSandboxAccessInputSchema = 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.")
+});
+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: requestSandboxAccessInputSchema,
+  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 expanded = expandTilde(requestedPath);
+      const absolutePath = path.isAbsolute(expanded) ? expanded : path.resolve(process.cwd(), expanded);
+      const projectRoot = process.cwd();
+      const allowedPaths = getAllowedPathsFromContext(context);
+      if (isPathAllowed(absolutePath, projectRoot, allowedPaths)) {
+        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);
+      const approved = answerText.toLowerCase().startsWith("y") || answerText.toLowerCase() === "approve";
+      if (approved) {
+        const controllerState = agentControllerCtx?.getState();
+        const currentAllowed = controllerState?.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) {
+      const msg = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: `Failed to request sandbox access: ${msg}`,
+        isError: true
+      };
+    }
+  }
+});
+export {
+  requestSandboxAccessTool
+};
+//# sourceMappingURL=request-sandbox-access.js.map

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

@@ -0,0 +1 @@
+{"version":3,"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 expanded = expandTilde(requestedPath);\n      const absolutePath = path.isAbsolute(expanded) ? expanded : path.resolve(process.cwd(), expanded);\n\n      // Check if already allowed\n      const projectRoot = process.cwd();\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":"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","names":[]}

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,22 @@
+import * as path from "node:path";
+import { buildSkillPaths } from "../agents/workspace.js";
+import { DEFAULT_CONFIG_DIR } from "../constants.js";
+function isPathAllowed(targetPath, projectRoot, allowedPaths = []) {
+  const resolved = path.resolve(targetPath);
+  const roots = [projectRoot, ...allowedPaths].map((p) => path.resolve(p));
+  return roots.some((root) => resolved === root || resolved.startsWith(root + path.sep));
+}
+function getAllowedPathsFromContext(toolContext) {
+  const agentControllerCtx = toolContext?.requestContext?.get("controller");
+  const state = agentControllerCtx?.getState?.() ?? agentControllerCtx?.session?.state?.get?.();
+  const projectPath = state?.projectPath ? path.resolve(state.projectPath) : process.cwd();
+  const configDir = state?.configDir ?? DEFAULT_CONFIG_DIR;
+  const skillPaths = buildSkillPaths(projectPath, configDir);
+  const sandboxPaths = state?.sandboxAllowedPaths ?? [];
+  return [...skillPaths, ...sandboxPaths];
+}
+export {
+  getAllowedPathsFromContext,
+  isPathAllowed
+};
+//# sourceMappingURL=utils.js.map

package/dist/tools/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"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":"AAAA,YAAY,UAAU;AACtB,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AAQ5B,SAAS,cAAc,YAAoB,aAAqB,eAAyB,CAAC,GAAY;AAC3G,QAAM,WAAW,KAAK,QAAQ,UAAU;AACxC,QAAM,QAAQ,CAAC,aAAa,GAAG,YAAY,EAAE,IAAI,OAAK,KAAK,QAAQ,CAAC,CAAC;AAErE,SAAO,MAAM,KAAK,UAAQ,aAAa,QAAQ,SAAS,WAAW,OAAO,KAAK,GAAG,CAAC;AACrF;AASO,SAAS,2BACd,aACU;AACV,QAAM,qBAAqB,aAAa,gBAAgB,IAAI,YAAY;AAQxE,QAAM,QAAQ,oBAAoB,WAAW,KAAK,oBAAoB,SAAS,OAAO,MAAM;AAC5F,QAAM,cAAc,OAAO,cAAc,KAAK,QAAQ,MAAM,WAAW,IAAI,QAAQ,IAAI;AACvF,QAAM,YAAY,OAAO,aAAa;AACtC,QAAM,aAAa,gBAAgB,aAAa,SAAS;AACzD,QAAM,eAAe,OAAO,uBAAuB,CAAC;AAEpD,SAAO,CAAC,GAAG,YAAY,GAAG,YAAY;AACxC;","names":[]}

package/dist/tools/web-search.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Check whether a Tavily API key is available in the environment.
+ * Used by main.ts to decide whether to include Tavily tools or fall back
+ * to Anthropic's native web search.
+ */
+export declare function hasTavilyKey(): boolean;
+/**
+ * Wraps the @mastra/tavily search tool with mastracode-specific behavior:
+ * relevance filtering, markdown string formatting, and token truncation.
+ * The underlying Tavily tool handles client init, input validation, and the API call.
+ */
+export declare function createWebSearchTool(): import("@mastra/core/tools").Tool<{
+    query: string;
+    searchDepth?: "basic" | "advanced" | "fast" | "ultra-fast" | undefined;
+    maxResults?: number | undefined;
+    includeAnswer?: boolean | "basic" | "advanced" | undefined;
+    includeImages?: boolean | undefined;
+    includeImageDescriptions?: boolean | undefined;
+    includeRawContent?: false | "markdown" | "text" | undefined;
+    includeDomains?: string[] | undefined;
+    excludeDomains?: string[] | undefined;
+    timeRange?: "day" | "week" | "month" | "year" | undefined;
+}, unknown, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "web-search", unknown>;
+/**
+ * Wraps the @mastra/tavily extract tool with mastracode-specific behavior:
+ * markdown string formatting and token truncation.
+ */
+export declare function createWebExtractTool(): import("@mastra/core/tools").Tool<{
+    urls: string[];
+    extractDepth?: "basic" | "advanced" | undefined;
+    query?: string | undefined;
+    includeImages?: boolean | undefined;
+    format?: "markdown" | "text" | undefined;
+}, unknown, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, "web-extract", unknown>;
+//# sourceMappingURL=web-search.d.ts.map

package/dist/tools/web-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-search.d.ts","sourceRoot":"","sources":["../../src/tools/web-search.ts"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAEtC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB;;;;;;;;;;;mIA8BlC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB;;;;;;oIAwBnC"}

package/dist/tools/web-search.js

@@ -0,0 +1,65 @@
+import { createTool } from "@mastra/core/tools";
+import { createTavilySearchTool, createTavilyExtractTool } from "@mastra/tavily";
+import { truncateStringForTokenEstimate } from "../utils/token-estimator.js";
+const MAX_WEB_SEARCH_TOKENS = 2e3;
+const MAX_WEB_EXTRACT_TOKENS = 2e3;
+const MIN_RELEVANCE_SCORE = 0.25;
+function hasTavilyKey() {
+  return !!process.env.TAVILY_API_KEY;
+}
+function createWebSearchTool() {
+  const tavilySearchTool = createTavilySearchTool();
+  return createTool({
+    id: "web-search",
+    description: tavilySearchTool.description,
+    inputSchema: tavilySearchTool.inputSchema,
+    execute: async (input, context) => {
+      const output = await tavilySearchTool.execute(input, context);
+      const parts = [];
+      if (output.answer) {
+        parts.push(`Answer: ${output.answer}`);
+      }
+      const filtered = output.results.filter((r) => (r.score ?? 1) >= MIN_RELEVANCE_SCORE);
+      for (const r of filtered) {
+        parts.push(`## ${r.title}
+${r.url}
+${r.content}`);
+      }
+      const images = (output.images || []).map((img) => img.url).filter(Boolean);
+      if (images.length > 0) {
+        parts.push(`Images:
+${images.join("\n")}`);
+      }
+      const text = parts.join("\n\n");
+      return truncateStringForTokenEstimate(text, MAX_WEB_SEARCH_TOKENS);
+    }
+  });
+}
+function createWebExtractTool() {
+  const tavilyExtractTool = createTavilyExtractTool();
+  return createTool({
+    id: "web-extract",
+    description: tavilyExtractTool.description,
+    inputSchema: tavilyExtractTool.inputSchema,
+    execute: async (input, context) => {
+      const output = await tavilyExtractTool.execute(input, context);
+      const parts = [];
+      for (const r of output.results) {
+        parts.push(`## ${r.url}
+${r.rawContent}`);
+      }
+      for (const r of output.failedResults) {
+        parts.push(`## ${r.url}
+Error: ${r.error}`);
+      }
+      const text = parts.join("\n\n");
+      return truncateStringForTokenEstimate(text, MAX_WEB_EXTRACT_TOKENS);
+    }
+  });
+}
+export {
+  createWebExtractTool,
+  createWebSearchTool,
+  hasTavilyKey
+};
+//# sourceMappingURL=web-search.js.map

package/dist/tools/web-search.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tools/web-search.ts"],"sourcesContent":["import { createTool } from '@mastra/core/tools';\nimport { createTavilySearchTool, createTavilyExtractTool } from '@mastra/tavily';\n\nimport { truncateStringForTokenEstimate } from '../utils/token-estimator.js';\n\nconst MAX_WEB_SEARCH_TOKENS = 2_000;\nconst MAX_WEB_EXTRACT_TOKENS = 2_000;\n\nconst MIN_RELEVANCE_SCORE = 0.25;\n\n/**\n * Check whether a Tavily API key is available in the environment.\n * Used by main.ts to decide whether to include Tavily tools or fall back\n * to Anthropic's native web search.\n */\nexport function hasTavilyKey(): boolean {\n  return !!process.env.TAVILY_API_KEY;\n}\n\n/**\n * Wraps the @mastra/tavily search tool with mastracode-specific behavior:\n * relevance filtering, markdown string formatting, and token truncation.\n * The underlying Tavily tool handles client init, input validation, and the API call.\n */\nexport function createWebSearchTool() {\n  const tavilySearchTool = createTavilySearchTool();\n\n  return createTool({\n    id: 'web-search',\n    description: tavilySearchTool.description!,\n    inputSchema: tavilySearchTool.inputSchema!,\n    execute: async (input, context) => {\n      const output: any = await tavilySearchTool.execute!(input as any, context as any);\n\n      const parts: string[] = [];\n\n      if (output.answer) {\n        parts.push(`Answer: ${output.answer}`);\n      }\n\n      const filtered = output.results.filter((r: any) => (r.score ?? 1) >= MIN_RELEVANCE_SCORE);\n      for (const r of filtered) {\n        parts.push(`## ${r.title}\\n${r.url}\\n${r.content}`);\n      }\n\n      const images = (output.images || []).map((img: any) => img.url).filter(Boolean);\n      if (images.length > 0) {\n        parts.push(`Images:\\n${images.join('\\n')}`);\n      }\n\n      const text = parts.join('\\n\\n');\n      return truncateStringForTokenEstimate(text, MAX_WEB_SEARCH_TOKENS);\n    },\n  });\n}\n\n/**\n * Wraps the @mastra/tavily extract tool with mastracode-specific behavior:\n * markdown string formatting and token truncation.\n */\nexport function createWebExtractTool() {\n  const tavilyExtractTool = createTavilyExtractTool();\n\n  return createTool({\n    id: 'web-extract',\n    description: tavilyExtractTool.description!,\n    inputSchema: tavilyExtractTool.inputSchema!,\n    execute: async (input, context) => {\n      const output: any = await tavilyExtractTool.execute!(input as any, context as any);\n\n      const parts: string[] = [];\n\n      for (const r of output.results) {\n        parts.push(`## ${r.url}\\n${r.rawContent}`);\n      }\n\n      for (const r of output.failedResults) {\n        parts.push(`## ${r.url}\\nError: ${r.error}`);\n      }\n\n      const text = parts.join('\\n\\n');\n      return truncateStringForTokenEstimate(text, MAX_WEB_EXTRACT_TOKENS);\n    },\n  });\n}\n"],"mappings":"AAAA,SAAS,kBAAkB;AAC3B,SAAS,wBAAwB,+BAA+B;AAEhE,SAAS,sCAAsC;AAE/C,MAAM,wBAAwB;AAC9B,MAAM,yBAAyB;AAE/B,MAAM,sBAAsB;AAOrB,SAAS,eAAwB;AACtC,SAAO,CAAC,CAAC,QAAQ,IAAI;AACvB;AAOO,SAAS,sBAAsB;AACpC,QAAM,mBAAmB,uBAAuB;AAEhD,SAAO,WAAW;AAAA,IAChB,IAAI;AAAA,IACJ,aAAa,iBAAiB;AAAA,IAC9B,aAAa,iBAAiB;AAAA,IAC9B,SAAS,OAAO,OAAO,YAAY;AACjC,YAAM,SAAc,MAAM,iBAAiB,QAAS,OAAc,OAAc;AAEhF,YAAM,QAAkB,CAAC;AAEzB,UAAI,OAAO,QAAQ;AACjB,cAAM,KAAK,WAAW,OAAO,MAAM,EAAE;AAAA,MACvC;AAEA,YAAM,WAAW,OAAO,QAAQ,OAAO,CAAC,OAAY,EAAE,SAAS,MAAM,mBAAmB;AACxF,iBAAW,KAAK,UAAU;AACxB,cAAM,KAAK,MAAM,EAAE,KAAK;AAAA,EAAK,EAAE,GAAG;AAAA,EAAK,EAAE,OAAO,EAAE;AAAA,MACpD;AAEA,YAAM,UAAU,OAAO,UAAU,CAAC,GAAG,IAAI,CAAC,QAAa,IAAI,GAAG,EAAE,OAAO,OAAO;AAC9E,UAAI,OAAO,SAAS,GAAG;AACrB,cAAM,KAAK;AAAA,EAAY,OAAO,KAAK,IAAI,CAAC,EAAE;AAAA,MAC5C;AAEA,YAAM,OAAO,MAAM,KAAK,MAAM;AAC9B,aAAO,+BAA+B,MAAM,qBAAqB;AAAA,IACnE;AAAA,EACF,CAAC;AACH;AAMO,SAAS,uBAAuB;AACrC,QAAM,oBAAoB,wBAAwB;AAElD,SAAO,WAAW;AAAA,IAChB,IAAI;AAAA,IACJ,aAAa,kBAAkB;AAAA,IAC/B,aAAa,kBAAkB;AAAA,IAC/B,SAAS,OAAO,OAAO,YAAY;AACjC,YAAM,SAAc,MAAM,kBAAkB,QAAS,OAAc,OAAc;AAEjF,YAAM,QAAkB,CAAC;AAEzB,iBAAW,KAAK,OAAO,SAAS;AAC9B,cAAM,KAAK,MAAM,EAAE,GAAG;AAAA,EAAK,EAAE,UAAU,EAAE;AAAA,MAC3C;AAEA,iBAAW,KAAK,OAAO,eAAe;AACpC,cAAM,KAAK,MAAM,EAAE,GAAG;AAAA,SAAY,EAAE,KAAK,EAAE;AAAA,MAC7C;AAEA,YAAM,OAAO,MAAM,KAAK,MAAM;AAC9B,aAAO,+BAA+B,MAAM,sBAAsB;AAAA,IACpE;AAAA,EACF,CAAC;AACH;","names":[]}

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