mastracode 0.4.0 → 0.5.0

package/dist/{chunk-M5LKPQB4.js → chunk-WKPHD54B.js}

@@ -1,23 +1,21 @@
-import { setAuthStorage, setAuthStorage2, loadSettings, getDynamicModel, createViewTool, createGrepTool, createGlobTool, createExecuteCommandTool, createWriteFileTool, getAvailableModePacks, getAvailableOmPacks, resolveModelDefaults, resolveOmModel, mastra, exploreSubagent, planSubagent, stringReplaceLspTool, executeSubagent, releaseThreadLock, acquireThreadLock, resolveModel, astSmartEditTool, hasTavilyKey, createWebSearchTool, createWebExtractTool, requestSandboxAccessTool } from './chunk-REVOTI2T.js';
+import { setAuthStorage, setAuthStorage2, loadSettings, getDynamicModel, createViewTool, createGrepTool, createGlobTool, createExecuteCommandTool, createWriteFileTool, createStringReplaceLspTool, getAvailableModePacks, getAvailableOmPacks, resolveModelDefaults, resolveOmModel, mastra, exploreSubagent, planSubagent, executeSubagent, releaseThreadLock, acquireThreadLock, getDynamicWorkspace, resolveModel, getCustomProviderId, toCustomProviderModelId, saveSettings, hasTavilyKey, createWebSearchTool, createWebExtractTool, requestSandboxAccessTool } from './chunk-JI4M5525.js';
 import { AuthStorage, detectProject, getResourceIdOverride, getStorageConfig, getCurrentGitBranch, getOmScope, getDatabasePath } from './chunk-SM3QCOA7.js';
-import { getToolCategory } from './chunk-U5A7TFNT.js';
-import { Mastra } from '@mastra/core';
+import { getToolCategory, MC_TOOLS } from './chunk-CC2724NI.js';
 import { Agent } from '@mastra/core/agent';
 import { taskCheckTool, taskWriteTool, Harness } from '@mastra/core/harness';
-import { noopLogger } from '@mastra/core/logger';
-import * as fs4 from 'fs';
-import fs4__default, { readFileSync, existsSync } from 'fs';
+import { PROVIDER_REGISTRY, ModelsDevGateway, NetlifyGateway } from '@mastra/core/llm';
+import * as fs3 from 'fs';
+import fs3__default, { readFileSync, existsSync } from 'fs';
 import * as os from 'os';
 import os__default, { homedir } from 'os';
-import * as path from 'path';
-import path__default, { join } from 'path';
+import * as path3 from 'path';
+import path3__default, { join } from 'path';
 import { Memory } from '@mastra/memory';
 import { createAnthropic } from '@ai-sdk/anthropic';
-import { Workspace, LocalSandbox, LocalFilesystem } from '@mastra/core/workspace';
+import { createOpenAI } from '@ai-sdk/openai';
 import { spawn } from 'child_process';
 import { MCPClient } from '@mastra/mcp';
 import { z } from 'zod';
-import { ModelsDevGateway, NetlifyGateway } from '@mastra/core/llm';
 import { LibSQLStore } from '@mastra/libsql';
 import { PostgresStore } from '@mastra/pg';
 
@@ -326,80 +324,117 @@ ${sections.join("\n\n")}
 
 // src/agents/prompts/tool-guidance.ts
 function buildToolGuidance(modeId, options = {}) {
+  const denied = options.deniedTools ?? /* @__PURE__ */ new Set();
   const sections = [];
   sections.push(`# Tool Usage Rules
 
 IMPORTANT: You can ONLY call tools by their exact registered names listed below. Shell commands like \`git\`, \`npm\`, \`ls\`, etc. are NOT tools \u2014 they must be run via the \`execute_command\` tool.
 
 You have access to the following tools. Use the RIGHT tool for the job:`);
-  sections.push(`
-**view** \u2014 Read file contents or list directories
+  const readTools = [];
+  if (!denied.has(MC_TOOLS.VIEW)) {
+    readTools.push(`
+**${MC_TOOLS.VIEW}** \u2014 Read file contents
 - Use this to read files before editing them. NEVER propose changes to code you haven't read.
-- Use \`view_range\` for large files to read specific sections.
-- For directory listings, this shows 2 levels deep.
-- Example: To check lines 50-100 of a large file: \`view("src/big-file.ts", { view_range: [50, 100] })\`
-
-**search_content** \u2014 Search file contents using regex
-- Use this for ALL content search (finding functions, variables, error messages, imports, etc.)
-- NEVER use \`execute_command\` with grep, rg, or ag. Always use the search_content tool.
-- Supports regex patterns, file type filtering, and context lines.
-- Example: Find where a function is defined: \`search_content("function handleSubmit", { glob: "**/*.ts" })\`
-- Example: Find all imports of a module: \`search_content("from ['\\"]express['\\"]", { glob: "**/*.ts" })\`
-
-**find_files** \u2014 Find files by name pattern
-- Use this to find files matching a pattern (e.g., "**/*.ts", "src/**/test*").
-- NEVER use \`execute_command\` with find or ls for file search. Always use find_files.
-- Respects .gitignore automatically.
-- Example: Find all test files: \`find_files("**/*.test.ts")\`
-- Example: Find config files: \`find_files("**/config.{js,ts,json}")\`
-
-**execute_command** \u2014 Run shell commands
+- Use \`offset\` (1-indexed start line) and \`limit\` (number of lines) for large files.
+- Example: Read lines 50-100: \`{ path: "src/big-file.ts", offset: 50, limit: 51 }\`
+- To list directories, use \`${MC_TOOLS.FIND_FILES}\` instead.`);
+  }
+  if (!denied.has(MC_TOOLS.SEARCH_CONTENT)) {
+    readTools.push(`
+**${MC_TOOLS.SEARCH_CONTENT}** \u2014 Search file contents using regex
+- Preferred for content search (finding functions, variables, error messages, imports, etc.)
+- Use \`path\` to filter by directory or glob pattern. Supports \`contextLines\`, \`caseSensitive\`, and \`maxCount\`.
+- Example: Find a function: \`{ pattern: "function handleSubmit", path: "**/*.ts" }\`
+- Example: Find imports: \`{ pattern: "from ['\\"\\]express['\\"\\]", path: "**/*.ts" }\`
+- Respects .gitignore by default.`);
+  }
+  if (!denied.has(MC_TOOLS.FIND_FILES)) {
+    readTools.push(`
+**${MC_TOOLS.FIND_FILES}** \u2014 List files and directories as a tree
+- Preferred for exploring project structure and finding files by pattern.
+- Returns tree-style output. Respects .gitignore by default.
+- Example: List project root: \`{ path: "./" }\`
+- Example: Find test files: \`{ path: "./src", pattern: "**/*.test.ts" }\`
+- Example: Find config files: \`{ pattern: "*.config.{js,ts,json}" }\``);
+  }
+  if (!denied.has(MC_TOOLS.EXECUTE_COMMAND)) {
+    readTools.push(`
+**${MC_TOOLS.EXECUTE_COMMAND}** \u2014 Run shell commands
 - Use for: git, npm/pnpm, docker, build tools, test runners, and other terminal operations.
-- Do NOT use for: file reading (use view), file search (use search_content/find_files), file editing (use string_replace_lsp/write_file).
-- Commands have a 30-second default timeout. Use the \`timeout\` parameter for longer-running commands.
-- Pipe to \`| tail -N\` for commands with long output \u2014 the full output streams to the user, only the last N lines are returned to you. If you're building any kind of package you should be tailing.
+- Prefer dedicated tools for: file reading (${MC_TOOLS.VIEW}), file search (${MC_TOOLS.SEARCH_CONTENT}/${MC_TOOLS.FIND_FILES}), file editing (${MC_TOOLS.STRING_REPLACE_LSP}/${MC_TOOLS.WRITE_FILE}).
+- Commands have a 30-second default timeout. Use \`timeout\` for longer commands, \`cwd\` for working directory.
+- Use the \`tail\` parameter or pipe to \`| tail -N\` to limit output \u2014 the full output streams to the user, only the tail is returned to you. If you're building any kind of package you should be tailing.
 - Good: Run independent commands in parallel when possible.
-- Bad: Running \`cat file.txt\` \u2014 use the view tool instead.`);
+- Bad: Running \`cat file.txt\` \u2014 use the ${MC_TOOLS.VIEW} tool instead.`);
+  }
+  if (readTools.length > 0) {
+    sections.push(readTools.join("\n"));
+  }
   if (modeId !== "plan") {
-    sections.push(`
-**string_replace_lsp** \u2014 Edit files by replacing exact text
-- You MUST read a file with \`view\` before editing it.
-- \`old_str\` must be an exact match of existing text in the file.
-- Provide enough surrounding context in \`old_str\` to make it unique.
-- For creating new files, use \`write_file\` instead.
+    const writeTools = [];
+    if (!denied.has(MC_TOOLS.STRING_REPLACE_LSP)) {
+      writeTools.push(`
+**${MC_TOOLS.STRING_REPLACE_LSP}** \u2014 Edit files by replacing exact text
+- You MUST read a file with \`${MC_TOOLS.VIEW}\` before editing it.
+- \`old_string\` must be an exact match of existing text in the file.
+- Provide enough surrounding context in \`old_string\` to make it unique.
+- Use \`replace_all: true\` to replace all occurrences (default: false, requires unique match).
+- For creating new files, use \`${MC_TOOLS.WRITE_FILE}\` instead.
 - Good: Include 2-3 lines of surrounding context to ensure uniqueness.
-- Bad: Using just \`return true;\` \u2014 too common, will match multiple places.
-
-**write_file** \u2014 Create new files or overwrite existing ones
+- Bad: Using just \`return true;\` \u2014 too common, will match multiple places.`);
+    }
+    if (!denied.has(MC_TOOLS.WRITE_FILE)) {
+      writeTools.push(`
+**${MC_TOOLS.WRITE_FILE}** \u2014 Create new files or overwrite existing ones
 - Use this to create new files.
-- If overwriting an existing file, you MUST have read it first with \`view\`.
-- NEVER create files unless necessary. Prefer editing existing files.`);
+- If overwriting an existing file, you MUST have read it first with \`${MC_TOOLS.VIEW}\`.
+- Prefer editing existing files over creating new ones.`);
+    }
+    if (writeTools.length > 0) {
+      sections.push(writeTools.join("\n"));
+    }
   }
   if (options.hasWebSearch) {
-    sections.push(`
-**web_search** / **web_extract** \u2014 Search the web / extract page content
+    const webTools = [];
+    if (!denied.has("web_search")) webTools.push("**web_search**");
+    if (!denied.has("web_extract")) webTools.push("**web_extract**");
+    if (webTools.length > 0) {
+      sections.push(`
+${webTools.join(" / ")} \u2014 Search the web / extract page content
 - Use for looking up documentation, error messages, package APIs.`);
+    }
   }
-  sections.push(`
+  const taskTools = [];
+  if (!denied.has("task_write")) {
+    taskTools.push(`
 **task_write** \u2014 Track tasks for complex multi-step work
 - Use when a task requires 3 or more distinct steps or actions.
 - Pass the FULL task list each time (replaces previous list).
 - Mark tasks \`in_progress\` BEFORE starting work. Only ONE task should be \`in_progress\` at a time.
 - Mark tasks \`completed\` IMMEDIATELY after finishing each task. Do not batch completions.
-- Each task has: content (imperative form), status (pending|in_progress|completed), activeForm (present continuous form shown during execution).
-
+- Each task has: content (imperative form), status (pending|in_progress|completed), activeForm (present continuous form shown during execution).`);
+  }
+  if (!denied.has("task_check")) {
+    taskTools.push(`
 **task_check** \u2014 Check completion status of tasks
 - Use this BEFORE deciding you're done with a task to verify all tasks are completed.
 - Returns the number of completed, in progress, and pending tasks.
 - If any tasks remain incomplete, continue working on them.
-- IMPORTANT: Always check task completion before ending work on a complex task.
-
+- IMPORTANT: Always check task completion before ending work on a complex task.`);
+  }
+  if (!denied.has("ask_user")) {
+    taskTools.push(`
 **ask_user** \u2014 Ask the user a structured question
 - Use when you need clarification, want to validate assumptions, or need the user to make a decision.
 - Provide clear, specific questions. End with a question mark.
 - Include options (2-4 choices) for structured decisions. Omit options for open-ended questions.
 - Don't use this for simple yes/no \u2014 just ask in your text response.`);
-  if (modeId === "plan") {
+  }
+  if (taskTools.length > 0) {
+    sections.push(taskTools.join("\n"));
+  }
+  if (modeId === "plan" && !denied.has("submit_plan")) {
     sections.push(`
 **submit_plan** \u2014 Submit a completed implementation plan for user review
 - Call this tool when your plan is complete. Do NOT just describe your plan in text \u2014 you MUST call this tool.
@@ -407,10 +442,12 @@ You have access to the following tools. Use the RIGHT tool for the job:`);
 - On approval, the system automatically switches to the default mode so you can implement.
 - Takes two arguments: \`title\` (short descriptive title) and \`plan\` (full plan in markdown).`);
   }
-  sections.push(`
+  if (!denied.has("subagent")) {
+    sections.push(`
 **subagent** \u2014 Delegate a focused task to a specialized subagent
 - Only use subagents when you will spawn **multiple subagents in parallel**. If you only need one task done, do it yourself.
 - Subagent outputs are **untrusted**. Always review and verify the results.`);
+  }
   return sections.join("\n");
 }
 
@@ -423,7 +460,14 @@ var modePrompts = {
 function buildFullPrompt(ctx) {
   const modelId = ctx.state?.currentModelId;
   const hasWebSearch = hasTavilyKey() || !!modelId && modelId.startsWith("anthropic/");
-  const toolGuidance = buildToolGuidance(ctx.modeId, { hasWebSearch });
+  const deniedTools = /* @__PURE__ */ new Set();
+  const permRules = ctx.state?.permissionRules;
+  if (permRules?.tools) {
+    for (const [name, policy] of Object.entries(permRules.tools)) {
+      if (policy === "deny") deniedTools.add(name);
+    }
+  }
+  const toolGuidance = buildToolGuidance(ctx.modeId, { hasWebSearch, deniedTools });
   const baseCtx = {
     projectPath: ctx.workingDir,
     projectName: ctx.projectName || "unknown",
@@ -491,11 +535,11 @@ function getHarnessState(requestContext) {
 }
 function getObserverModel({ requestContext }) {
   const state = getHarnessState(requestContext);
-  return resolveModel(state?.observerModelId ?? DEFAULT_OM_MODEL_ID);
+  return resolveModel(state?.observerModelId ?? DEFAULT_OM_MODEL_ID, { remapForCodexOAuth: true });
 }
 function getReflectorModel({ requestContext }) {
   const state = getHarnessState(requestContext);
-  return resolveModel(state?.reflectorModelId ?? DEFAULT_OM_MODEL_ID);
+  return resolveModel(state?.reflectorModelId ?? DEFAULT_OM_MODEL_ID, { remapForCodexOAuth: true });
 }
 function getDynamicMemory(storage) {
   return ({ requestContext }) => {
@@ -518,19 +562,13 @@ function getDynamicMemory(storage) {
             bufferActivation: 2e3,
             model: getObserverModel,
             messageTokens: obsThreshold,
-            blockAfter: 2,
-            modelSettings: {
-              maxOutputTokens: 6e4
-            }
+            blockAfter: 2
           },
           reflection: {
             bufferActivation: 1 / 2,
             blockAfter: 1.1,
             model: getReflectorModel,
-            observationTokens: refThreshold,
-            modelSettings: {
-              maxOutputTokens: 6e4
-            }
+            observationTokens: refThreshold
           }
         }
       }
@@ -539,120 +577,48 @@ function getDynamicMemory(storage) {
     return cachedMemory;
   };
 }
-function createDynamicTools(mcpManager) {
+function createDynamicTools(mcpManager, extraTools) {
   return function getDynamicTools({ requestContext }) {
     const ctx = requestContext.get("harness");
     const state = ctx?.getState?.();
-    const modeId = ctx?.modeId ?? "build";
     const modelId = state?.currentModelId;
     const isAnthropicModel = modelId?.startsWith("anthropic/");
-    const projectPath = state?.projectPath ?? "";
-    const viewTool = createViewTool(projectPath);
-    const grepTool = createGrepTool(projectPath);
-    const globTool = createGlobTool(projectPath);
-    const executeCommandTool = createExecuteCommandTool(projectPath);
-    const writeFileTool = createWriteFileTool(projectPath);
+    const isOpenAIModel = modelId?.startsWith("openai/");
     const tools = {
-      view: viewTool,
-      search_content: grepTool,
-      find_files: globTool,
-      execute_command: executeCommandTool,
       request_sandbox_access: requestSandboxAccessTool
     };
-    if (modeId !== "plan") {
-      tools.string_replace_lsp = stringReplaceLspTool;
-      tools.ast_smart_edit = astSmartEditTool;
-      tools.write_file = writeFileTool;
-    }
     if (hasTavilyKey()) {
       tools.web_search = createWebSearchTool();
       tools.web_extract = createWebExtractTool();
     } else if (isAnthropicModel) {
       const anthropic = createAnthropic({});
       tools.web_search = anthropic.tools.webSearch_20250305();
+    } else if (isOpenAIModel) {
+      const openai = createOpenAI({});
+      tools.web_search = openai.tools.webSearch();
     }
     if (mcpManager) {
       const mcpTools = mcpManager.getTools();
       Object.assign(tools, mcpTools);
     }
-    return tools;
-  };
-}
-var mastraCodeLocalSkillsPath = path__default.join(process.cwd(), ".mastracode", "skills");
-var claudeLocalSkillsPath = path__default.join(process.cwd(), ".claude", "skills");
-var mastraCodeGlobalSkillsPath = path__default.join(os__default.homedir(), ".mastracode", "skills");
-var claudeGlobalSkillsPath = path__default.join(os__default.homedir(), ".claude", "skills");
-function collectSkillPaths(skillsDirs) {
-  const paths = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const skillsDir of skillsDirs) {
-    if (!fs4__default.existsSync(skillsDir)) continue;
-    const resolved = fs4__default.realpathSync(skillsDir);
-    if (!seen.has(resolved)) {
-      seen.add(resolved);
-      paths.push(skillsDir);
+    if (extraTools) {
+      const resolved = typeof extraTools === "function" ? extraTools({ requestContext }) : extraTools;
+      for (const [name, tool] of Object.entries(resolved)) {
+        if (!(name in tools)) {
+          tools[name] = tool;
+        }
+      }
     }
-    try {
-      const entries = fs4__default.readdirSync(skillsDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isSymbolicLink()) {
-          const linkPath = path__default.join(skillsDir, entry.name);
-          const realPath = fs4__default.realpathSync(linkPath);
-          const stat = fs4__default.statSync(realPath);
-          if (stat.isDirectory()) {
-            const realParent = path__default.dirname(realPath);
-            if (!seen.has(realParent)) {
-              seen.add(realParent);
-              paths.push(realParent);
-            }
-          }
+    const permissionRules = state?.permissionRules;
+    if (permissionRules?.tools) {
+      for (const [name, policy] of Object.entries(permissionRules.tools)) {
+        if (policy === "deny") {
+          delete tools[name];
         }
       }
-    } catch {
     }
-  }
-  return paths;
-}
-var skillPaths = collectSkillPaths([
-  mastraCodeLocalSkillsPath,
-  claudeLocalSkillsPath,
-  mastraCodeGlobalSkillsPath,
-  claudeGlobalSkillsPath
-]);
-function getDynamicWorkspace({ requestContext }) {
-  const ctx = requestContext.get("harness");
-  const state = ctx?.getState?.();
-  const projectPath = state?.projectPath;
-  if (!projectPath) {
-    throw new Error("Project path is required");
-  }
-  const sandboxPaths = state?.sandboxAllowedPaths ?? [];
-  const workspace = new Workspace({
-    id: "mastra-code-workspace",
-    name: "Mastra Code Workspace",
-    filesystem: new LocalFilesystem({
-      basePath: projectPath,
-      allowedPaths: skillPaths
-    }),
-    sandbox: new LocalSandbox({
-      workingDirectory: projectPath,
-      env: process.env
-    }),
-    // Disable workspace tools — built-in tools are used instead.
-    // Workspace tools use different output formats (e.g. → separator, offset/limit params)
-    // that the TUI renderers don't fully support yet.
-    // We will update to use workspace tools very soon - just disabling until then
-    tools: { enabled: false },
-    ...skillPaths.length > 0 ? { skills: skillPaths } : {}
-  });
-  workspace.filesystem.setAllowedPaths([...skillPaths, ...sandboxPaths.map((p) => path__default.resolve(p))]);
-  return workspace;
-}
-if (skillPaths.length > 0) {
-  console.info(`Skills loaded from:`);
-  for (const p of skillPaths) {
-    console.info(`  - ${p}`);
-  }
+    return tools;
+  };
 }
 var VALID_EVENTS = [
   "PreToolUse",
@@ -670,15 +636,15 @@ function loadHooksConfig(projectDir) {
   return mergeConfigs(globalConfig, projectConfig);
 }
 function getProjectHooksPath(projectDir) {
-  return path.join(projectDir, ".mastracode", "hooks.json");
+  return path3.join(projectDir, ".mastracode", "hooks.json");
 }
 function getGlobalHooksPath() {
-  return path.join(os.homedir(), ".mastracode", "hooks.json");
+  return path3.join(os.homedir(), ".mastracode", "hooks.json");
 }
 function loadSingleConfig(filePath) {
   try {
-    if (!fs4.existsSync(filePath)) return {};
-    const raw = fs4.readFileSync(filePath, "utf-8");
+    if (!fs3.existsSync(filePath)) return {};
+    const raw = fs3.readFileSync(filePath, "utf-8");
     return validateConfig(JSON.parse(raw));
   } catch {
     return {};
@@ -975,18 +941,18 @@ function loadMcpConfig(projectDir) {
   return mergeConfigs2(claudeConfig, globalConfig, projectConfig);
 }
 function getProjectMcpPath(projectDir) {
-  return path.join(projectDir, ".mastracode", "mcp.json");
+  return path3.join(projectDir, ".mastracode", "mcp.json");
 }
 function getGlobalMcpPath() {
-  return path.join(os.homedir(), ".mastracode", "mcp.json");
+  return path3.join(os.homedir(), ".mastracode", "mcp.json");
 }
 function getClaudeSettingsPath(projectDir) {
-  return path.join(projectDir, ".claude", "settings.local.json");
+  return path3.join(projectDir, ".claude", "settings.local.json");
 }
 function loadSingleConfig2(filePath) {
   try {
-    if (!fs4.existsSync(filePath)) return {};
-    const raw = fs4.readFileSync(filePath, "utf-8");
+    if (!fs3.existsSync(filePath)) return {};
+    const raw = fs3.readFileSync(filePath, "utf-8");
     return validateConfig2(JSON.parse(raw));
   } catch {
     return {};
@@ -995,8 +961,8 @@ function loadSingleConfig2(filePath) {
 function loadClaudeSettings(projectDir) {
   try {
     const filePath = getClaudeSettingsPath(projectDir);
-    if (!fs4.existsSync(filePath)) return {};
-    const raw = fs4.readFileSync(filePath, "utf-8");
+    if (!fs3.existsSync(filePath)) return {};
+    const raw = fs3.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed?.mcpServers && typeof parsed.mcpServers === "object") {
       return validateConfig2({ mcpServers: parsed.mcpServers });
@@ -1006,43 +972,97 @@ function loadClaudeSettings(projectDir) {
     return {};
   }
 }
+function classifyServerEntry(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { kind: "skip", reason: "Invalid entry: expected an object" };
+  }
+  const obj = raw;
+  const hasCommand = typeof obj.command === "string";
+  const hasUrl = typeof obj.url === "string";
+  if (hasCommand && hasUrl) {
+    return { kind: "skip", reason: 'Cannot specify both "command" and "url"' };
+  }
+  if (hasCommand) {
+    return { kind: "stdio" };
+  }
+  if (hasUrl) {
+    try {
+      new URL(obj.url);
+    } catch {
+      return { kind: "skip", reason: `Invalid URL: "${obj.url}"` };
+    }
+    return { kind: "http" };
+  }
+  return { kind: "skip", reason: 'Missing required field: "command" (stdio) or "url" (http)' };
+}
 function validateConfig2(raw) {
   if (!raw || typeof raw !== "object") return {};
   const obj = raw;
   if (!obj.mcpServers || typeof obj.mcpServers !== "object") return {};
   const servers = {};
+  const skippedServers = [];
   const rawServers = obj.mcpServers;
   for (const [name, entry] of Object.entries(rawServers)) {
-    if (isValidServerConfig(entry)) {
+    const classification = classifyServerEntry(entry);
+    if (classification.kind === "stdio") {
+      const e = entry;
+      servers[name] = {
+        command: e.command,
+        args: Array.isArray(e.args) ? e.args : void 0,
+        env: typeof e.env === "object" && e.env !== null ? e.env : void 0
+      };
+    } else if (classification.kind === "http") {
+      const e = entry;
       servers[name] = {
-        command: entry.command,
-        args: Array.isArray(entry.args) ? entry.args : void 0,
-        env: typeof entry.env === "object" && entry.env !== null ? entry.env : void 0
+        url: e.url,
+        headers: typeof e.headers === "object" && e.headers !== null ? e.headers : void 0
       };
+    } else {
+      skippedServers.push({ name, reason: classification.reason });
     }
   }
-  if (Object.keys(servers).length === 0) return {};
-  return { mcpServers: servers };
-}
-function isValidServerConfig(raw) {
-  if (!raw || typeof raw !== "object") return false;
-  const obj = raw;
-  return typeof obj.command === "string";
+  const result = {};
+  if (Object.keys(servers).length > 0) {
+    result.mcpServers = servers;
+  }
+  if (skippedServers.length > 0) {
+    result.skippedServers = skippedServers;
+  }
+  return result;
 }
 function mergeConfigs2(...configs) {
   const merged = {};
+  const allSkipped = [];
   for (const config of configs) {
     if (config.mcpServers) {
       for (const [name, server] of Object.entries(config.mcpServers)) {
         merged[name] = server;
       }
     }
+    if (config.skippedServers) {
+      allSkipped.push(...config.skippedServers);
+    }
+  }
+  const validNames = new Set(Object.keys(merged));
+  const filteredSkipped = allSkipped.filter((s) => !validNames.has(s.name));
+  const skippedMap = /* @__PURE__ */ new Map();
+  for (const s of filteredSkipped) {
+    skippedMap.set(s.name, s);
+  }
+  const result = {};
+  if (Object.keys(merged).length > 0) {
+    result.mcpServers = merged;
   }
-  if (Object.keys(merged).length === 0) return {};
-  return { mcpServers: merged };
+  if (skippedMap.size > 0) {
+    result.skippedServers = Array.from(skippedMap.values());
+  }
+  return result;
 }
 
 // src/mcp/manager.ts
+function getTransport(cfg) {
+  return "url" in cfg ? "http" : "stdio";
+}
 function createMcpManager(projectDir) {
   let config = loadMcpConfig(projectDir);
   let client = null;
@@ -1052,7 +1072,15 @@ function createMcpManager(projectDir) {
   function buildServerDefs(servers) {
     const defs = {};
     for (const [name, cfg] of Object.entries(servers)) {
-      defs[name] = { command: cfg.command, args: cfg.args, env: cfg.env };
+      if ("url" in cfg) {
+        const httpCfg = cfg;
+        defs[name] = {
+          url: new URL(httpCfg.url),
+          requestInit: httpCfg.headers ? { headers: httpCfg.headers } : void 0
+        };
+      } else {
+        defs[name] = { command: cfg.command, args: cfg.args, env: cfg.env };
+      }
     }
     return defs;
   }
@@ -1075,7 +1103,8 @@ function createMcpManager(projectDir) {
           name,
           connected: true,
           toolCount: serverToolNames.length,
-          toolNames: serverToolNames
+          toolNames: serverToolNames,
+          transport: getTransport(servers[name])
         });
       }
     } catch (error) {
@@ -1086,6 +1115,7 @@ function createMcpManager(projectDir) {
           connected: false,
           toolCount: 0,
           toolNames: [],
+          transport: getTransport(servers[name]),
           error: errMsg
         });
       }
@@ -1120,11 +1150,16 @@ function createMcpManager(projectDir) {
       return { ...tools };
     },
     hasServers() {
-      return config.mcpServers !== void 0 && Object.keys(config.mcpServers).length > 0;
+      const hasConfigured = config.mcpServers !== void 0 && Object.keys(config.mcpServers).length > 0;
+      const hasSkipped = config.skippedServers !== void 0 && config.skippedServers.length > 0;
+      return hasConfigured || hasSkipped;
     },
     getServerStatuses() {
       return Array.from(serverStatuses.values());
     },
+    getSkippedServers() {
+      return [...config.skippedServers ?? []];
+    },
     getConfigPaths() {
       return {
         project: getProjectMcpPath(projectDir),
@@ -1182,21 +1217,21 @@ var stateSchema = z.object({
     approvedAt: z.string()
   }).nullable().default(null)
 });
-var CACHE_DIR = path__default.join(os__default.homedir(), ".cache", "mastra");
-var CACHE_FILE = path__default.join(CACHE_DIR, "gateway-refresh-time");
-var GLOBAL_PROVIDER_REGISTRY_JSON = path__default.join(CACHE_DIR, "provider-registry.json");
-var GLOBAL_PROVIDER_TYPES_DTS = path__default.join(CACHE_DIR, "provider-types.generated.d.ts");
+var CACHE_DIR = path3__default.join(os__default.homedir(), ".cache", "mastra");
+var CACHE_FILE = path3__default.join(CACHE_DIR, "gateway-refresh-time");
+var GLOBAL_PROVIDER_REGISTRY_JSON = path3__default.join(CACHE_DIR, "provider-registry.json");
+var GLOBAL_PROVIDER_TYPES_DTS = path3__default.join(CACHE_DIR, "provider-types.generated.d.ts");
 var DEFAULT_SYNC_INTERVAL_MS = 5 * 60 * 1e3;
 var isSyncing = false;
 async function atomicWriteFile(filePath, content) {
   const randomSuffix = Math.random().toString(36).substring(2, 15);
   const tempPath = `${filePath}.${process.pid}.${Date.now()}.${randomSuffix}.tmp`;
   try {
-    await fs4__default.promises.writeFile(tempPath, content, "utf-8");
-    await fs4__default.promises.rename(tempPath, filePath);
+    await fs3__default.promises.writeFile(tempPath, content, "utf-8");
+    await fs3__default.promises.rename(tempPath, filePath);
   } catch (error) {
     try {
-      await fs4__default.promises.unlink(tempPath);
+      await fs3__default.promises.unlink(tempPath);
     } catch {
     }
     throw error;
@@ -1261,10 +1296,10 @@ export type ModelForProvider<P extends Provider> = ProviderModelsMap[P][number];
 }
 function getLastSyncTime() {
   try {
-    if (!fs4__default.existsSync(CACHE_FILE)) {
+    if (!fs3__default.existsSync(CACHE_FILE)) {
       return null;
     }
-    const timestamp = fs4__default.readFileSync(CACHE_FILE, "utf-8").trim();
+    const timestamp = fs3__default.readFileSync(CACHE_FILE, "utf-8").trim();
     return new Date(parseInt(timestamp, 10));
   } catch {
     return null;
@@ -1272,10 +1307,10 @@ function getLastSyncTime() {
 }
 function saveLastSyncTime(date) {
   try {
-    if (!fs4__default.existsSync(CACHE_DIR)) {
-      fs4__default.mkdirSync(CACHE_DIR, { recursive: true });
+    if (!fs3__default.existsSync(CACHE_DIR)) {
+      fs3__default.mkdirSync(CACHE_DIR, { recursive: true });
     }
-    fs4__default.writeFileSync(CACHE_FILE, date.getTime().toString(), "utf-8");
+    fs3__default.writeFileSync(CACHE_FILE, date.getTime().toString(), "utf-8");
   } catch (error) {
     console.warn("[GatewaySync] Failed to save sync time:", error);
   }
@@ -1296,7 +1331,7 @@ async function syncGateways(force = false) {
   isSyncing = true;
   try {
     const { providers, models } = await fetchProvidersFromGateways();
-    await fs4__default.promises.mkdir(CACHE_DIR, { recursive: true });
+    await fs3__default.promises.mkdir(CACHE_DIR, { recursive: true });
     const registryData = {
       providers,
       models,
@@ -1393,19 +1428,13 @@ async function createMastraCode(config) {
   const storageWarning = storageResult.warning;
   const memory = getDynamicMemory(storage);
   const mcpManager = config?.disableMcp ? void 0 : createMcpManager(project.rootPath);
-  const codeAgentInstance = new Agent({
+  const codeAgent = new Agent({
     id: "code-agent",
     name: "Code Agent",
     instructions: getDynamicInstructions,
     model: getDynamicModel,
-    tools: createDynamicTools(mcpManager)
-  });
-  const mastraInstance = new Mastra({
-    agents: { codeAgentInstance },
-    logger: noopLogger,
-    storage
+    tools: createDynamicTools(mcpManager, config?.extraTools)
   });
-  const codeAgent = mastraInstance.getAgent("codeAgentInstance");
   const hookManager = config?.disableHooks ? void 0 : new HookManager(project.rootPath, "session-init");
   if (hookManager?.hasHooks()) {
     const hookConfig = hookManager.getConfig();
@@ -1417,6 +1446,7 @@ async function createMastraCode(config) {
   const globTool = createGlobTool(project.rootPath);
   const executeCommandTool = createExecuteCommandTool(project.rootPath);
   const writeFileTool = createWriteFileTool(project.rootPath);
+  const stringReplaceLspTool = createStringReplaceLspTool(project.rootPath);
   const readOnlyTools = {
     view: viewTool,
     search_content: grepTool,
@@ -1490,6 +1520,18 @@ async function createMastraCode(config) {
     google: process.env.GOOGLE_GENERATIVE_AI_API_KEY ? "apikey" : false,
     deepseek: process.env.DEEPSEEK_API_KEY ? "apikey" : false
   };
+  try {
+    const registry = PROVIDER_REGISTRY;
+    for (const [provider, config2] of Object.entries(registry)) {
+      if (startupAccess[provider] && startupAccess[provider] !== false) continue;
+      const envVars = config2?.apiKeyEnvVar;
+      const envVarList = Array.isArray(envVars) ? envVars : envVars ? [envVars] : [];
+      if (envVarList.some((envVar) => process.env[envVar])) {
+        startupAccess[provider] = "apikey";
+      }
+    }
+  } catch {
+  }
   const builtinPacks = getAvailableModePacks(startupAccess);
   const builtinOmPacks = getAvailableOmPacks(startupAccess);
   const effectiveDefaults = resolveModelDefaults(globalSettings, builtinPacks);
@@ -1536,7 +1578,7 @@ async function createMastraCode(config) {
       ...globalInitialState,
       ...config?.initialState
     },
-    workspace: getDynamicWorkspace,
+    workspace: config?.workspace ?? getDynamicWorkspace,
     modes,
     heartbeatHandlers: config?.heartbeatHandlers ?? defaultHeartbeatHandlers,
     modelAuthChecker: (provider) => {
@@ -1544,9 +1586,41 @@ async function createMastraCode(config) {
       if (oauthId && authStorage.isLoggedIn(oauthId)) {
         return true;
       }
+      const customProvider = loadSettings().customProviders.find((entry) => {
+        return provider === getCustomProviderId(entry.name);
+      });
+      if (customProvider) {
+        return true;
+      }
       return void 0;
     },
     modelUseCountProvider: () => loadSettings().modelUseCounts,
+    modelUseCountTracker: (modelId) => {
+      try {
+        const settings = loadSettings();
+        settings.modelUseCounts[modelId] = (settings.modelUseCounts[modelId] ?? 0) + 1;
+        saveSettings(settings);
+      } catch (error) {
+        console.error("Failed to persist model usage count", error);
+      }
+    },
+    customModelCatalogProvider: () => {
+      const settings = loadSettings();
+      const customModels = [];
+      for (const provider of settings.customProviders) {
+        const providerId = getCustomProviderId(provider.name);
+        for (const modelName of provider.models) {
+          customModels.push({
+            id: toCustomProviderModelId(provider.name, modelName),
+            provider: providerId,
+            modelName,
+            hasApiKey: true,
+            apiKeyEnvVar: void 0
+          });
+        }
+      }
+      return customModels;
+    },
     threadLock: {
       acquire: acquireThreadLock,
       release: releaseThreadLock
@@ -1561,9 +1635,9 @@ async function createMastraCode(config) {
       }
     });
   }
-  return { harness, mcpManager, hookManager, authStorage, storageWarning };
+  return { harness, mcpManager, hookManager, authStorage, resolveModel, storageWarning };
 }
 
 export { createMastraCode };
-//# sourceMappingURL=chunk-M5LKPQB4.js.map
-//# sourceMappingURL=chunk-M5LKPQB4.js.map
+//# sourceMappingURL=chunk-WKPHD54B.js.map
+//# sourceMappingURL=chunk-WKPHD54B.js.map