@aiderdesk/aiderdesk 0.68.0 → 0.69.0

package/out/runner.js

@@ -73,8 +73,6 @@ const clientBedrock = require("@aws-sdk/client-bedrock");
 const credentialProviders = require("@aws-sdk/credential-providers");
 const amazonBedrock = require("@ai-sdk/amazon-bedrock");
 const cerebras = require("@ai-sdk/cerebras");
-const aiSdkProviderClaudeCode = require("ai-sdk-provider-claude-code");
-const jsonSchemaToZod = require("@dmitryrechkin/json-schema-to-zod");
 const deepseek = require("@ai-sdk/deepseek");
 const google = require("@ai-sdk/google");
 const genai = require("@google/genai");
@@ -868,7 +866,6 @@ const CLOUDFLARED_BINARY_PATH = path.join(
   "bin",
   process.platform === "win32" ? "cloudflared.exe" : "cloudflared"
 );
-const CLAUDE_CODE_EXECUTABLE_PATH = path.join(RESOURCES_DIR, "app.asar.unpacked", "node_modules", "@anthropic-ai", "claude-agent-sdk", "cli.js");
 const eventTransport = new EventTransport();
 const logger = winston.createLogger({
   level: process.env.LOG_LEVEL || "info",
@@ -1497,11 +1494,9 @@ const AVAILABLE_PROVIDERS = [
   "alibaba-plan",
   "anthropic",
   "anthropic-compatible",
-  "auggie",
   "azure",
   "bedrock",
   "cerebras",
-  "claude-agent-sdk",
   "deepseek",
   "gemini",
   "gemini-cli",
@@ -1532,7 +1527,6 @@ const isOpenAiProvider = (provider) => provider.name === "openai";
 const isAzureProvider = (provider) => provider.name === "azure";
 const isAnthropicProvider = (provider) => provider.name === "anthropic";
 const isAnthropicCompatibleProvider = (provider) => provider.name === "anthropic-compatible";
-const isAuggieProvider = (provider) => provider.name === "auggie";
 const isKimiPlanProvider = (provider) => provider.name === "kimi-plan";
 const isAlibabaPlanProvider = (provider) => provider.name === "alibaba-plan";
 var GeminiVoiceModel = /* @__PURE__ */ ((GeminiVoiceModel2) => {
@@ -1545,7 +1539,6 @@ const isLmStudioProvider = (provider) => provider.name === "lmstudio";
 const isDeepseekProvider = (provider) => provider.name === "deepseek";
 const isGroqProvider = (provider) => provider.name === "groq";
 const isCerebrasProvider = (provider) => provider.name === "cerebras";
-const isClaudeAgentSdkProvider = (provider) => provider.name === "claude-agent-sdk";
 const isGeminiCliProvider = (provider) => provider.name === "gemini-cli";
 const isBedrockProvider = (provider) => provider.name === "bedrock";
 const isOpenAiCompatibleProvider = (provider) => provider.name === "openai-compatible";
@@ -1563,10 +1556,8 @@ const isSyntheticProvider = (provider) => provider.name === "synthetic";
 const DEFAULT_PROVIDER_MODELS = {
   "alibaba-plan": "qwen3-coder-plus",
   anthropic: "claude-sonnet-4-6",
-  auggie: "gpt-5-4",
   bedrock: "global.anthropic.claude-sonnet-4-6",
   cerebras: "qwen-3-235b-a22b-instruct-2507",
-  "claude-agent-sdk": "sonnet",
   deepseek: "deepseek-v4-pro",
   gemini: "gemini-pro-latest",
   "gemini-cli": "gemini-2.5-pro",
@@ -1639,6 +1630,7 @@ const DEFAULT_AGENT_PROFILE = {
   useMemoryTools: true,
   useSkillsTools: true,
   useExtensionTools: true,
+  disabledExtensionTools: [],
   customInstructions: "",
   enabledServers: [],
   subagent: {
@@ -1774,6 +1766,7 @@ const COMPACT_CONVERSATION_AGENT_PROFILE = {
   }
 };
 ({
+  ...DEFAULT_AGENT_PROFILE,
   toolApprovals: {
     ...DEFAULT_AGENT_PROFILE.toolApprovals,
     [`${POWER_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${POWER_TOOL_FILE_EDIT}`]: ToolApprovalState.Never,
@@ -1823,13 +1816,6 @@ const getDefaultProviderParams = (providerName) => {
         baseUrl: ""
       };
       break;
-    case "auggie":
-      provider = {
-        name: "auggie",
-        apiKey: "",
-        apiUrl: ""
-      };
-      break;
     case "gemini":
       provider = {
         name: "gemini",
@@ -2262,7 +2248,6 @@ const readApiKeyFromConfFile = (filePath, envVarName) => {
           GOOGLE_API_KEY: ["gemini", "google"],
           OPENAI_API_KEY: ["openai"],
           ANTHROPIC_API_KEY: ["anthropic", "anthropic-compatible"],
-          AUGMENT_API_TOKEN: ["auggie"],
           GROQ_API_KEY: ["groq"],
           ALIBABA_PLAN_API_KEY: ["alibaba-plan"],
           KIMI_PLAN_API_KEY: ["kimi-plan"],
@@ -3248,6 +3233,20 @@ const scrapeWeb = async (url, timeout = 6e4, abortSignal, format = "markdown") =
   const scraper = new WebScraper();
   return await scraper.scrape(url, timeout, abortSignal, format);
 };
+const coerceBoolean = zod.z.preprocess((val) => {
+  if (typeof val === "boolean") {
+    return val;
+  }
+  if (typeof val === "string") {
+    if (val.toLowerCase() === "true") {
+      return true;
+    }
+    if (val.toLowerCase() === "false") {
+      return false;
+    }
+  }
+  return val;
+}, zod.z.boolean());
 const THINKING_RESPONSE_STAR_TAG = "---\n► **THINKING**\n";
 const ANSWER_RESPONSE_START_TAG = "---\n► **ANSWER**\n";
 const extractPromptContextFromToolResult = (toolResult) => {
@@ -3484,8 +3483,8 @@ Include enough lines in each to uniquely match each set of lines that need to ch
 Do not use escape characters \\ in the string like \\n or \\" and others. Do not start the search term with a \\ character.`
       ),
       replacementText: zod.z.string().describe('The string to replace the searchTerm with. Do not use escape characters \\ in the string like \\n or \\" and others'),
-      isRegex: zod.z.boolean().optional().default(false).describe("Whether the searchTerm should be treated as a regular expression. Use regex only when it is really needed. Default: false."),
-      replaceAll: zod.z.boolean().optional().default(false).describe("Whether to replace all occurrences or just the first one. Default: false.")
+      isRegex: coerceBoolean.optional().default(false).describe("Whether the searchTerm should be treated as a regular expression. Use regex only when it is really needed. Default: false."),
+      replaceAll: coerceBoolean.optional().default(false).describe("Whether to replace all occurrences or just the first one. Default: false.")
     }),
     execute: async (input, { toolCallId }) => {
       const { filePath, searchTerm, replacementText, isRegex, replaceAll } = input;
@@ -3575,9 +3574,9 @@ Do not use escape characters \\ in the string like \\n or \\" and others. Do not
     description: POWER_TOOL_DESCRIPTIONS[POWER_TOOL_FILE_READ],
     inputSchema: zod.z.object({
       filePath: zod.z.string().describe("The path to the file to be read (relative to the <WorkingDirectory> or absolute if outside of the directory)."),
-      withLines: zod.z.boolean().optional().default(false).describe('Whether to return the file content with line numbers in format "lineNumber|content". Default: false.'),
-      lineOffset: zod.z.number().int().min(0).optional().default(0).describe("The starting line number (0-based) to begin reading from. Default: 0."),
-      lineLimit: zod.z.number().int().min(1).optional().default(1e3).describe("The maximum number of lines to read. Default: 1000.")
+      withLines: coerceBoolean.optional().default(false).describe('Whether to return the file content with line numbers in format "lineNumber|content". Default: false.'),
+      lineOffset: zod.z.coerce.number().int().min(0).optional().default(0).describe("The starting line number (0-based) to begin reading from. Default: 0."),
+      lineLimit: zod.z.coerce.number().int().min(1).optional().default(1e3).describe("The maximum number of lines to read. Default: 1000.")
     }),
     execute: async (input, { toolCallId }) => {
       const { filePath, withLines, lineOffset, lineLimit } = input;
@@ -3741,8 +3740,8 @@ Do not use escape characters \\ in the string like \\n or \\" and others. Do not
       filePattern: zod.z.string().describe("A glob pattern specifying the files to search within (e.g., src/**/*.tsx, *.py)."),
       searchTerm: zod.z.string().describe("The regular expression to search for within the files."),
       contextLines: zod.z.number().int().min(0).optional().default(0).describe("The number of lines of context to show before and after each matching line. Default: 0."),
-      caseSensitive: zod.z.boolean().optional().default(false).describe("Whether the search should be case sensitive. Default: false."),
-      maxResults: zod.z.number().int().min(1).optional().default(50).describe("Maximum number of results to return. Default: 50.")
+      caseSensitive: coerceBoolean.optional().default(false).describe("Whether the search should be case sensitive. Default: false."),
+      maxResults: zod.z.coerce.number().int().min(1).optional().default(50).describe("Maximum number of results to return. Default: 50.")
     }),
     execute: async (input, { toolCallId }) => {
       const { filePattern, searchTerm, contextLines, caseSensitive, maxResults } = input;
@@ -3909,7 +3908,7 @@ Do not use escape characters \\ in the string like \\n or \\" and others. Do not
     inputSchema: zod.z.object({
       command: zod.z.string().min(1).describe("The shell command to execute (e.g., ls -la, npm install)."),
       cwd: zod.z.string().optional().describe("The working directory for the command (relative to <WorkingDirectory>). Default: <WorkingDirectory>."),
-      timeout: zod.z.number().int().min(0).optional().default(12e4).describe("Timeout for the command execution in milliseconds. Default: 120000 ms.")
+      timeout: zod.z.coerce.number().int().min(0).optional().default(12e4).describe("Timeout for the command execution in milliseconds. Default: 120000 ms.")
     }),
     execute: async (input, { toolCallId }) => {
       const { command, cwd, timeout } = input;
@@ -4094,7 +4093,7 @@ Timeout: ${timeout}ms`;
     description: POWER_TOOL_DESCRIPTIONS[POWER_TOOL_FETCH],
     inputSchema: zod.z.object({
       url: zod.z.string().describe("The URL to fetch."),
-      timeout: zod.z.number().int().min(0).optional().default(6e4).describe("Timeout for the fetch operation in milliseconds. Default: 60000 ms."),
+      timeout: zod.z.coerce.number().int().min(0).optional().default(6e4).describe("Timeout for the fetch operation in milliseconds. Default: 60000 ms."),
       format: zod.z.enum(["markdown", "html", "raw"]).optional().default("markdown").describe(
         'Format of the response: "markdown" (default, converts HTML to markdown), "html" (returns raw HTML), "raw" (fetches raw content via HTTP, ideal for API responses or raw files).'
       )
@@ -4144,10 +4143,10 @@ Format: ${format}`;
     inputSchema: zod.z.object({
       query: zod.z.string().describe("Search query with Elasticsearch syntax. Use + for important terms."),
       path: zod.z.string().optional().default(task.getTaskDir()).describe('Absolute path to search in. For dependencies use "go:github.com/owner/repo", "js:package_name", or "rust:cargo_name" etc.'),
-      allowTests: zod.z.boolean().optional().default(false).describe("Allow test files in search results"),
-      exact: zod.z.boolean().optional().default(false).describe("Perform exact search without tokenization (case-insensitive)"),
-      maxResults: zod.z.number().optional().describe("Maximum number of results to return"),
-      maxTokens: zod.z.number().optional().default(5e3).describe("Maximum number of tokens to return"),
+      allowTests: coerceBoolean.optional().default(false).describe("Allow test files in search results"),
+      exact: coerceBoolean.optional().default(false).describe("Perform exact search without tokenization (case-insensitive)"),
+      maxResults: zod.z.coerce.number().optional().describe("Maximum number of results to return"),
+      maxTokens: zod.z.coerce.number().optional().default(5e3).describe("Maximum number of tokens to return"),
       language: zod.z.string().optional().describe("Limit search to files of a specific programming language")
     }),
     execute: async (input, { toolCallId }) => {
@@ -4259,7 +4258,7 @@ const createTodoToolset = (task, profile, promptContext) => {
       items: zod.z.array(
         zod.z.object({
           name: zod.z.string().describe("The name of the todo item."),
-          completed: zod.z.boolean().optional().default(false).describe("Whether the todo item is completed.")
+          completed: coerceBoolean.optional().default(false).describe("Whether the todo item is completed.")
         })
       ).describe("An array of todo items."),
       initialUserPrompt: zod.z.string().describe("The original user prompt that initiated the task.")
@@ -4313,7 +4312,7 @@ Items: ${JSON.stringify(items)}`;
     description: TODO_TOOL_DESCRIPTIONS[TODO_TOOL_UPDATE_ITEM_COMPLETION],
     inputSchema: zod.z.object({
       name: zod.z.string().describe("The name of the todo item to update."),
-      completed: zod.z.boolean().describe("The new completion status for the todo item.")
+      completed: coerceBoolean.describe("The new completion status for the todo item.")
     }),
     execute: async (input, { toolCallId }) => {
       const { name, completed } = input;
@@ -4378,8 +4377,8 @@ const createTasksToolset = (settings, task, profile, promptContext) => {
   const listTasksTool = ai.tool({
     description: TASKS_TOOL_DESCRIPTIONS[TASKS_TOOL_LIST_TASKS],
     inputSchema: zod.z.object({
-      offset: zod.z.number().optional().describe("The number of tasks to skip (for pagination)"),
-      limit: zod.z.number().optional().describe("The maximum number of tasks to return"),
+      offset: zod.z.coerce.number().optional().describe("The number of tasks to skip (for pagination)"),
+      limit: zod.z.coerce.number().optional().describe("The maximum number of tasks to return"),
       state: zod.z.string().optional().describe("Filter tasks by state (e.g., TODO, IN_PROGRESS, DONE)")
     }),
     execute: async (input, { toolCallId }) => {
@@ -4543,7 +4542,7 @@ const createTasksToolset = (settings, task, profile, promptContext) => {
       ),
       worktree: zod.z.boolean().optional().default(false).describe("If true, the task will be created in worktree mode. Use only when explicitly requested by the user."),
       executeAndWait: zod.z.boolean().optional().default(false).describe("If true, the task will be created and executed immediately and the tool will wait for it to complete before returning."),
-      executeInBackground: zod.z.boolean().optional().default(false).describe("If true, the task will be created and executed in the background.")
+      executeInBackground: coerceBoolean.optional().default(false).describe("If true, the task will be created and executed in the background.")
     }),
     execute: async (input, { toolCallId }) => {
       const { prompt, name, agentProfileId, modelId, mode = "agent", asSubtask = false, autonomyMode, worktree, executeAndWait, executeInBackground } = input;
@@ -4707,7 +4706,7 @@ Prompt: ${prompt}${executeAndWait ? "\nWait for completion: true" : "\nRun in ba
     inputSchema: zod.z.object({
       taskId: zod.z.string().describe("The ID of the task to search within"),
       query: zod.z.string().describe("Search query with Elasticsearch syntax. Use + for important terms."),
-      maxTokens: zod.z.number().optional().default(1e4).describe("Maximum number of tokens to return in the search results. Default: 10000")
+      maxTokens: zod.z.coerce.number().optional().default(1e4).describe("Maximum number of tokens to return in the search results. Default: 10000")
     }),
     execute: async (input, { toolCallId }) => {
       const { taskId, query, maxTokens } = input;
@@ -4784,7 +4783,7 @@ const createSearchParentTaskTool = (task, promptContext) => {
     description: TASKS_TOOL_DESCRIPTIONS[TASKS_TOOL_SEARCH_PARENT_TASK],
     inputSchema: zod.z.object({
       query: zod.z.string().describe("Search query with Elasticsearch syntax. Use + for important terms."),
-      maxTokens: zod.z.number().optional().default(1e4).describe("Maximum number of tokens to return in the search results. Default: 10000")
+      maxTokens: zod.z.coerce.number().optional().default(1e4).describe("Maximum number of tokens to return in the search results. Default: 10000")
     }),
     execute: async ({ query, maxTokens }, { toolCallId }) => {
       const parentTaskId = task.task.parentId;
@@ -4874,7 +4873,7 @@ const createAiderToolset = (task, profile, promptContext) => {
     description: AIDER_TOOL_DESCRIPTIONS[AIDER_TOOL_ADD_CONTEXT_FILES],
     inputSchema: zod.z.object({
       paths: zod.z.array(zod.z.string()).describe('One or more file paths to add to context. Relative to task directory (e.g. "src/file.ts") or absolute (e.g. "/tmp/log.txt" for read-only).'),
-      readOnly: zod.z.boolean().optional().describe("Whether the file(s) are read-only. Applies to all paths if true.")
+      readOnly: coerceBoolean.optional().describe("Whether the file(s) are read-only. Applies to all paths if true.")
     }),
     execute: async (input, { toolCallId }) => {
       const { paths, readOnly = false } = input;
@@ -5103,7 +5102,7 @@ const createMemoryToolset = (task, profile, memoryManager, promptContext) => {
     description: MEMORY_TOOL_DESCRIPTIONS[MEMORY_TOOL_RETRIEVE],
     inputSchema: zod.z.object({
       query: zod.z.string().describe("The search query to find relevant memories"),
-      limit: zod.z.number().optional().default(3).describe("Maximum number of memories to retrieve (default: 3)")
+      limit: zod.z.coerce.number().optional().default(3).describe("Maximum number of memories to retrieve (default: 3)")
     }),
     execute: async (input, { toolCallId }) => {
       const { query, limit } = input;
@@ -5170,7 +5169,7 @@ Timestamp: ${new Date(memory.timestamp).toLocaleString()}`;
     description: MEMORY_TOOL_DESCRIPTIONS[MEMORY_TOOL_LIST],
     inputSchema: zod.z.object({
       type: zod.z.enum(["task", "user-preference", "code-pattern"]).optional().describe("Filter by memory type"),
-      limit: zod.z.number().optional().default(20).describe("Maximum number of memories to list (default: 20)")
+      limit: zod.z.coerce.number().optional().default(20).describe("Maximum number of memories to list (default: 20)")
     }),
     execute: async (input, { toolCallId }) => {
       const { type, limit } = input;
@@ -6594,14 +6593,16 @@ ${file.content}</content-with-line-numbers>
         logger.debug("Adding file list for non-image files", {
           files: nonImageFiles.map((f) => f.path)
         });
+        const hasReadOnlyFiles = nonImageFiles.some((file) => file.readOnly);
         const fileList = nonImageFiles.map((file) => {
-          return `- ${file.path}`;
+          return `- ${file.path}${file.readOnly ? " (read-only)" : ""}`;
         }).join("\n");
+        const readOnlyNote = hasReadOnlyFiles ? "\n\nNote: Files marked as read-only must NOT be modified. Use them only for understanding context." : "";
         messages.push({
           role: "user",
           content: `The following files are currently in the working context:
 
-${fileList}`
+${fileList}${readOnlyNote}`
         });
         messages.push({
           role: "assistant",
@@ -6699,7 +6700,7 @@ ${fileList}`
     const providerTools = await this.modelManager.getProviderTools(provider, model);
     Object.assign(toolSet, providerTools);
     if (this.extensionManager.isInitialized() && profile.useExtensionTools !== false) {
-      const extensionTools = this.extensionManager.createExtensionToolset(task, mode, profile, toolSet, abortSignal);
+      const extensionTools = this.extensionManager.createExtensionToolset(task, mode, profile, toolSet, approvalManager, abortSignal);
       Object.assign(toolSet, extensionTools);
     }
     return this.wrapToolsWithHooks(task, profile, toolSet, abortSignal, promptContext);
@@ -7851,7 +7852,7 @@ ${fileList}`
     const processToolResult = (toolResult) => {
       const [serverName, toolName] = extractServerNameToolName(toolResult.toolName);
       const toolPromptContext = extractPromptContextFromToolResult(toolResult.output) ?? promptContext;
-      task.addToolMessage(toolResult.toolCallId, serverName, toolName, toolResult.input, JSON.stringify(toolResult.output), void 0, toolPromptContext);
+      task.addToolMessage(toolResult.toolCallId, serverName, toolName, toolResult.input, JSON.stringify(toolResult.output), usageReport, toolPromptContext);
     };
     for (let i = 0; i < content.length; i++) {
       let part = content[i];
@@ -8337,6 +8338,7 @@ class AgentProfileManager {
       maxIterations: loadedProfile.maxIterations ?? DEFAULT_AGENT_PROFILE.maxIterations,
       minTimeBetweenToolCalls: loadedProfile.minTimeBetweenToolCalls ?? DEFAULT_AGENT_PROFILE.minTimeBetweenToolCalls,
       enabledServers: loadedProfile.enabledServers ?? [],
+      disabledExtensionTools: loadedProfile.disabledExtensionTools ?? [],
       customInstructions: loadedProfile.customInstructions ?? "",
       toolApprovals: {
         ...loadedProfile.toolApprovals
@@ -9306,11 +9308,22 @@ const MergeWorktreeToMainSchema = zod.z.object({
   targetBranch: zod.z.string().optional(),
   commitMessage: zod.z.string().optional()
 });
-const MergeAndSwitchToLocalSchema = zod.z.object({
+const SwitchToLocalWorkingModeSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
   taskId: zod.z.string().min(1, "Task id is required"),
+  mergeBeforeSwitch: zod.z.boolean().optional(),
   targetBranch: zod.z.string().optional()
 });
+const SwitchToWorktreeWorkingModeSchema = zod.z.object({
+  projectDir: zod.z.string().min(1, "Project directory is required"),
+  taskId: zod.z.string().min(1, "Task id is required"),
+  carryOverUncommittedChanges: zod.z.boolean().optional(),
+  dropSourceChanges: zod.z.boolean().optional()
+});
+const LocalUncommittedFilesSchema = zod.z.object({
+  projectDir: zod.z.string().min(1, "Project directory is required"),
+  taskId: zod.z.string().min(1, "Task id is required")
+});
 const ApplyUncommittedChangesSchema = zod.z.object({
   projectDir: zod.z.string().min(1, "Project directory is required"),
   taskId: zod.z.string().min(1, "Task id is required"),
@@ -9761,15 +9774,39 @@ class ProjectApi extends BaseApi {
       })
     );
     router.post(
-      "/project/worktree/merge-and-switch-to-local",
+      "/project/switch-to-local-working-mode",
       this.handleRequest(async (req, res) => {
-        const parsed = this.validateRequest(MergeAndSwitchToLocalSchema, req.body, res);
+        const parsed = this.validateRequest(SwitchToLocalWorkingModeSchema, req.body, res);
         if (!parsed) {
           return;
         }
-        const { projectDir, taskId, targetBranch } = parsed;
-        await this.eventsHandler.mergeAndSwitchToLocal(projectDir, taskId, targetBranch);
-        res.status(200).json({ message: "Worktree merged and switched to local" });
+        const { projectDir, taskId, mergeBeforeSwitch, targetBranch } = parsed;
+        await this.eventsHandler.switchToLocalWorkingMode(projectDir, taskId, { mergeBeforeSwitch, targetBranch });
+        res.status(200).json({ message: "Switched to local working mode" });
+      })
+    );
+    router.post(
+      "/project/switch-to-worktree-working-mode",
+      this.handleRequest(async (req, res) => {
+        const parsed = this.validateRequest(SwitchToWorktreeWorkingModeSchema, req.body, res);
+        if (!parsed) {
+          return;
+        }
+        const { projectDir, taskId, carryOverUncommittedChanges, dropSourceChanges } = parsed;
+        await this.eventsHandler.switchToWorktreeWorkingMode(projectDir, taskId, { carryOverUncommittedChanges, dropSourceChanges });
+        res.status(200).json({ message: "Switched to worktree working mode" });
+      })
+    );
+    router.get(
+      "/project/local-uncommitted-files",
+      this.handleRequest(async (req, res) => {
+        const parsed = this.validateRequest(LocalUncommittedFilesSchema, req.query, res);
+        if (!parsed) {
+          return;
+        }
+        const { projectDir, taskId } = parsed;
+        const result = await this.eventsHandler.getLocalUncommittedFiles(projectDir, taskId);
+        res.status(200).json(result);
       })
     );
     router.post(
@@ -10713,6 +10750,9 @@ class TerminalApi extends BaseApi {
 const GetInstalledExtensionsSchema = zod.z.object({
   projectDir: zod.z.string().optional()
 });
+const GetExtensionToolsInfoSchema = zod.z.object({
+  projectDir: zod.z.string().optional()
+});
 const GetAvailableExtensionsSchema = zod.z.object({
   repositories: zod.z.string().optional(),
   // Comma-separated URLs
@@ -10751,6 +10791,18 @@ class ExtensionsApi extends BaseApi {
         res.status(200).json(extensions);
       })
     );
+    router.get(
+      "/extensions/tools-info",
+      this.handleRequest(async (req, res) => {
+        const parsed = this.validateRequest(GetExtensionToolsInfoSchema, req.query, res);
+        if (!parsed) {
+          return;
+        }
+        const { projectDir } = parsed;
+        const toolsInfo = this.eventsHandler.getExtensionToolsInfo(projectDir);
+        res.status(200).json(toolsInfo);
+      })
+    );
     router.get(
       "/extensions/available",
       this.handleRequest(async (req, res) => {
@@ -15646,7 +15698,7 @@ const smartCompactMessages = async (messages, protectedMessageCount = 10, compac
   result = compactFileReads(result, protectedMessageCount, compactionLevel);
   result = removeObsoleteSearches(result, protectedMessageCount, compactionLevel);
   result = compactSemanticSearches(result, protectedMessageCount, compactionLevel);
-  result = deduplicateBash(result, protectedMessageCount, compactionLevel);
+  result = compactBashOutputs(result, protectedMessageCount, compactionLevel);
   result = redactFetchOutputs(result, protectedMessageCount);
   result = await truncateNonPowerToolResults(result, protectedMessageCount, compactionLevel);
   result = mergeConsecutiveAssistantMessages(result);
@@ -16012,8 +16064,9 @@ const compactSemanticSearches = (messages, protectedMessageCount = 10, compactio
   }
   return messages;
 };
-const deduplicateBash = (messages, protectedMessageCount = 10, compactionLevel = 1) => {
+const compactBashOutputs = (messages, protectedMessageCount = 10, compactionLevel = 1) => {
   const protectedStart = getProtectedStartIndex(messages, protectedMessageCount);
+  logger.info(`Compacting bash outputs at level ${compactionLevel}`);
   const bashCommands = /* @__PURE__ */ new Map();
   for (let i = 0; i < protectedStart; i++) {
     const msg = messages[i];
@@ -16079,6 +16132,23 @@ const deduplicateBash = (messages, protectedMessageCount = 10, compactionLevel =
         };
         continue;
       }
+      if (part.output.type === "json" || part.output.type === "error-json") {
+        const value = part.output.value;
+        if (typeof value === "object" && value !== null) {
+          const obj = value;
+          const stdout = typeof obj.stdout === "string" ? obj.stdout : "";
+          const stderr = typeof obj.stderr === "string" ? obj.stderr : "";
+          const redactionMessage = "<output redacted due to compaction, run again if output is needed>";
+          const redactionThreshold = compactionLevel >= 2 ? 0 : 30;
+          if (stdout.length > redactionThreshold) {
+            obj.stdout = redactionMessage;
+          }
+          if (stderr.length > redactionThreshold) {
+            obj.stderr = redactionMessage;
+          }
+        }
+        continue;
+      }
       if (part.output.type !== "text") {
         continue;
       }
@@ -16819,6 +16889,7 @@ class Task {
       provider: this.task.provider || profile.provider,
       model: this.task.model || profile.model
     });
+    this.smartCompactionLevel = 1;
     const agentMessages = await this.agent.runAgent(
       this,
       profile,
@@ -17917,7 +17988,6 @@ ${contentText}</agent-response>`;
         lastAgentProviderMetadata: null
       });
     }
-    this.smartCompactionLevel = CompactionLevel.One;
     this.contextManager.clearMessages(true, createSnapshot);
     await this.runCommand("clear", addToHistory);
     this.eventManager.sendClearTask(this.project.baseDir, this.taskId, true, false);
@@ -18326,10 +18396,20 @@ ${contentText}</agent-response>`;
     await this.contextManager.backupContext();
     const messagesSinceLastCompaction = contextMessages.length - this.lastSmartCompactionMessageCount;
     if (messagesSinceLastCompaction <= 3) {
+      logger.info("Increasing compaction level to aggressive due to low message count since last compaction.", {
+        messagesSinceLastCompaction,
+        smartCompactionLevel: this.smartCompactionLevel
+      });
       this.smartCompactionLevel = Math.min(this.smartCompactionLevel + 1, CompactionLevel.Three);
-    } else if (messagesSinceLastCompaction > 5) {
-      this.smartCompactionLevel = CompactionLevel.One;
+    } else if (messagesSinceLastCompaction > 5 && this.smartCompactionLevel > CompactionLevel.One) {
+      logger.info("Decreasing compaction level to mild due to high message count since last compaction.", {
+        messagesSinceLastCompaction
+      });
+      this.smartCompactionLevel = Math.max(this.smartCompactionLevel - 1, CompactionLevel.One);
     }
+    logger.debug("Current compaction level:", {
+      smartCompactionLevel: this.smartCompactionLevel
+    });
     const compactedMessages = await smartCompactMessages(contextMessages, 10, this.smartCompactionLevel);
     this.lastSmartCompactionMessageCount = compactedMessages.length;
     this.contextManager.setContextMessages(compactedMessages);
@@ -18345,7 +18425,7 @@ ${contentText}</agent-response>`;
     if (!contextMessages) {
       contextMessages = await this.contextManager.getContextMessages();
     }
-    const userMessage = contextMessages[0];
+    const userMessage = contextMessages.find((msg) => msg.role === MessageRole.User);
     if (!userMessage) {
       this.addLogMessage("warning", "No conversation to compact.");
       return;
@@ -19025,46 +19105,96 @@ Only answer with the commit message, nothing else.`,
     await this.sendUpdatedFilesUpdated();
     await this.sendWorktreeIntegrationStatusUpdated();
   }
-  async mergeAndSwitchToLocal(targetBranch) {
-    if (!this.task.worktree) {
+  async switchToLocalWorkingMode(options) {
+    if (options?.mergeBeforeSwitch && !this.task.worktree) {
       throw new Error("No worktree exists for this task");
     }
-    logger.info("Merging worktree and switching to local mode", {
+    logger.info("Switching to local working mode", {
       baseDir: this.project.baseDir,
-      taskId: this.taskId
+      taskId: this.taskId,
+      mergeBeforeSwitch: options?.mergeBeforeSwitch ?? false
     });
     await this.waitForCurrentPromptToFinish();
-    try {
-      const effectiveTargetBranch = targetBranch || await this.worktreeManager.getProjectMainBranch(this.project.baseDir);
-      this.addLogMessage("loading", `Merging worktree to ${effectiveTargetBranch} branch and switching to local mode...`);
-      const settings = this.store.getSettings();
-      const symlinkFolders = settings.taskSettings.worktreeSymlinkFolders || [];
-      const mergeState = await this.worktreeManager.mergeWorktreeToMainWithUncommitted(
-        this.project.baseDir,
-        this.task.id,
-        this.task.worktree.path,
-        false,
-        this.task.name || `Task ${this.taskId} changes`,
-        targetBranch,
-        symlinkFolders
-      );
-      await this.saveTask({ lastMergeState: mergeState });
-      this.addLogMessage("info", `Successfully merged worktree to ${effectiveTargetBranch} branch`, true);
-      await this.updateTask({ workingMode: "local" });
-    } catch (error) {
-      logger.error("Failed to merge worktree and switch to local:", { error });
-      const isConflict = error instanceof GitError && (error.gitOutput?.toLowerCase().includes("resolve all conflicts") || error.message?.toLowerCase().includes("conflicts must be resolved first") || error.gitOutput?.toLowerCase().includes("conflicts must be resolved first"));
-      this.addLogMessage(
-        "error",
-        isConflict ? "worktree.mergeConflicts" : error instanceof GitError ? error.getErrorDetails() : `Failed to merge worktree: ${error instanceof Error ? error.message : String(error)}`,
-        true,
-        void 0,
-        isConflict ? ["rebase-worktree"] : void 0
-      );
-      await this.sendUpdatedFilesUpdated();
-      await this.sendWorktreeIntegrationStatusUpdated();
-      throw error;
+    if (options?.mergeBeforeSwitch && this.task.worktree) {
+      try {
+        const effectiveTargetBranch = options.targetBranch || await this.worktreeManager.getProjectMainBranch(this.project.baseDir);
+        this.addLogMessage("loading", `Merging worktree to ${effectiveTargetBranch} branch and switching to local mode...`);
+        const settings = this.store.getSettings();
+        const symlinkFolders = settings.taskSettings.worktreeSymlinkFolders || [];
+        const mergeState = await this.worktreeManager.mergeWorktreeToMainWithUncommitted(
+          this.project.baseDir,
+          this.task.id,
+          this.task.worktree.path,
+          false,
+          this.task.name || `Task ${this.taskId} changes`,
+          options.targetBranch,
+          symlinkFolders
+        );
+        await this.saveTask({ lastMergeState: mergeState });
+        this.addLogMessage("info", `Successfully merged worktree to ${effectiveTargetBranch} branch`, true);
+      } catch (error) {
+        logger.error("Failed to merge worktree and switch to local:", { error });
+        const isConflict = error instanceof GitError && (error.gitOutput?.toLowerCase().includes("resolve all conflicts") || error.message?.toLowerCase().includes("conflicts must be resolved first") || error.gitOutput?.toLowerCase().includes("conflicts must be resolved first"));
+        this.addLogMessage(
+          "error",
+          isConflict ? "worktree.mergeConflicts" : error instanceof GitError ? error.getErrorDetails() : `Failed to merge worktree: ${error instanceof Error ? error.message : String(error)}`,
+          true,
+          void 0,
+          isConflict ? ["rebase-worktree"] : void 0
+        );
+        await this.sendUpdatedFilesUpdated();
+        await this.sendWorktreeIntegrationStatusUpdated();
+        throw error;
+      }
     }
+    await this.updateTask({ workingMode: "local" });
+  }
+  async switchToWorktreeWorkingMode(options) {
+    logger.info("Switching to worktree working mode", {
+      baseDir: this.project.baseDir,
+      taskId: this.taskId,
+      carryOverUncommittedChanges: options?.carryOverUncommittedChanges ?? false,
+      dropSourceChanges: options?.dropSourceChanges ?? true
+    });
+    await this.waitForCurrentPromptToFinish();
+    let stashId = null;
+    const settings = this.store.getSettings();
+    const symlinkFolders = settings.taskSettings.worktreeSymlinkFolders || [];
+    if (options?.carryOverUncommittedChanges) {
+      const timestamp = Date.now();
+      const shortId = this.taskId.length > 24 ? this.taskId.substring(24) : this.taskId;
+      stashId = `local-${shortId}-to-worktree-${timestamp}`;
+      try {
+        const stashResult = await this.worktreeManager.stashUncommittedChanges(
+          stashId,
+          this.project.baseDir,
+          "Uncommitted changes to carry over to worktree",
+          symlinkFolders
+        );
+        if (!stashResult) {
+          stashId = null;
+        }
+      } catch (error) {
+        logger.error("Failed to stash uncommitted changes before worktree switch:", { error });
+        stashId = null;
+      }
+    }
+    await this.updateTask({ workingMode: "worktree" });
+    if (stashId && this.task.worktree) {
+      try {
+        await this.worktreeManager.applyStash(this.task.worktree.path, stashId);
+        if (!options?.dropSourceChanges) {
+          await this.worktreeManager.applyStash(this.project.baseDir, stashId);
+        }
+        await this.worktreeManager.dropStash(this.project.baseDir, stashId);
+      } catch (error) {
+        logger.error("Failed to apply stashed changes to worktree:", { error });
+      }
+    }
+    void this.sendUpdatedFilesUpdated();
+  }
+  async getLocalUncommittedFiles() {
+    return await this.worktreeManager.getUncommittedFiles(this.project.baseDir);
   }
   async applyUncommittedChanges(targetBranch) {
     if (!this.task.worktree) {
@@ -20876,132 +21006,6 @@ const anthropicCompatibleProviderStrategy = {
   // Cache control
   getCacheControl: getAnthropicCacheControl
 };
-const loadAuggieSdk = async () => import("@augmentcode/auggie-sdk");
-const AUGGIE_MODELS = [
-  {
-    id: "claude-haiku-4-5",
-    maxInputTokens: 2e5,
-    maxOutputTokensLimit: 8192
-  },
-  {
-    id: "claude-sonnet-4",
-    maxInputTokens: 2e5,
-    maxOutputTokensLimit: 16384
-  },
-  {
-    id: "claude-sonnet-4-5",
-    maxInputTokens: 2e5,
-    maxOutputTokensLimit: 16384
-  },
-  {
-    id: "claude-opus-4-5",
-    maxInputTokens: 2e5,
-    maxOutputTokensLimit: 32768
-  },
-  {
-    id: "claude-opus-4-6",
-    maxInputTokens: 2e5,
-    maxOutputTokensLimit: 32768
-  },
-  {
-    id: "claude-opus-4-7",
-    maxInputTokens: 2e5,
-    maxOutputTokensLimit: 32768
-  },
-  { id: "gpt-5-1", maxInputTokens: 2e5, maxOutputTokensLimit: 16384 },
-  { id: "gpt-5-2", maxInputTokens: 2e5, maxOutputTokensLimit: 16384 },
-  { id: "gpt-5-4", maxInputTokens: 2e5, maxOutputTokensLimit: 16384 }
-];
-const loadAuggieModels = async (profile, _settings) => {
-  if (!isAuggieProvider(profile.provider)) {
-    return {
-      models: [],
-      success: false
-    };
-  }
-  const models = AUGGIE_MODELS.map((model) => ({
-    id: model.id,
-    providerId: profile.id,
-    maxInputTokens: model.maxInputTokens,
-    maxOutputTokensLimit: model.maxOutputTokensLimit
-  }));
-  logger.info(`Loaded ${models.length} Auggie models for profile ${profile.id}`);
-  return { models, success: true };
-};
-const hasAuggieEnvVars = (settings) => {
-  if (getEffectiveEnvironmentVariable("AUGMENT_API_TOKEN", settings, void 0)?.value && getEffectiveEnvironmentVariable("AUGMENT_API_URL", settings, void 0)?.value) {
-    return true;
-  }
-  const auggieSessionFile = path.join(os.homedir(), ".augment", "session.json");
-  if (findExecutableInPath("auggie") && fs$1.existsSync(auggieSessionFile)) {
-    return true;
-  }
-  return false;
-};
-const getAuggieAiderMapping = (provider, modelId) => {
-  const auggieProvider = provider.provider;
-  const envVars = {};
-  if (auggieProvider.apiKey) {
-    envVars.AUGMENT_API_TOKEN = auggieProvider.apiKey;
-  }
-  if (auggieProvider.apiUrl) {
-    envVars.AUGMENT_API_URL = auggieProvider.apiUrl;
-  }
-  return {
-    modelName: `auggie/${modelId}`,
-    environmentVariables: envVars
-  };
-};
-const createAuggieLlm = async (profile, model, settings, projectDir) => {
-  const provider = profile.provider;
-  let apiKey = provider.apiKey;
-  let apiUrl = provider.apiUrl;
-  if (!apiKey) {
-    const effectiveVar = getEffectiveEnvironmentVariable("AUGMENT_API_TOKEN", settings, projectDir);
-    if (effectiveVar) {
-      apiKey = effectiveVar.value;
-      logger.debug(`Loaded AUGMENT_API_TOKEN from ${effectiveVar.source}`);
-    }
-  }
-  if (!apiUrl) {
-    const effectiveUrlVar = getEffectiveEnvironmentVariable("AUGMENT_API_URL", settings, projectDir);
-    if (effectiveUrlVar) {
-      apiUrl = effectiveUrlVar.value;
-      logger.debug(`Loaded AUGMENT_API_URL from ${effectiveUrlVar.source}`);
-    }
-  }
-  if (apiKey && !apiUrl) {
-    throw new Error("API URL is required when API key is provided.");
-  }
-  const { AugmentLanguageModel, resolveAugmentCredentials } = await loadAuggieSdk();
-  const AugmentLanguageModelCtor = AugmentLanguageModel;
-  if (apiKey && apiUrl) {
-    return new AugmentLanguageModelCtor(model.id, {
-      apiKey,
-      apiUrl
-    });
-  } else {
-    const credentials = await resolveAugmentCredentials();
-    return new AugmentLanguageModelCtor(model.id, credentials);
-  }
-};
-const getAuggieUsageReport = (_task, _provider, model) => {
-  return {
-    model: model.id,
-    sentTokens: 0,
-    receivedTokens: 0,
-    messageCost: 0,
-    agentTotalCost: 0
-  };
-};
-const auggieProviderStrategy = {
-  createLlm: createAuggieLlm,
-  getUsageReport: getAuggieUsageReport,
-  loadModels: loadAuggieModels,
-  hasEnvVars: hasAuggieEnvVars,
-  getAiderMapping: getAuggieAiderMapping,
-  getModelInfo: getDefaultModelInfo
-};
 const extractResourceNameFromEndpoint = (endpoint) => {
   try {
     const url = new URL(endpoint);
@@ -21427,199 +21431,6 @@ const cerebrasProviderStrategy = {
   getAiderMapping: getCerebrasAiderMapping,
   getModelInfo: getDefaultModelInfo
 };
-const loadClaudeAgentSdkModels = async (profile, _settings) => {
-  if (!isClaudeAgentSdkProvider(profile.provider)) {
-    return {
-      models: [],
-      success: false
-    };
-  }
-  try {
-    const models = [
-      {
-        id: "haiku",
-        providerId: profile.id,
-        maxInputTokens: 2e5,
-        maxOutputTokensLimit: 64e3
-      },
-      {
-        id: "sonnet",
-        providerId: profile.id,
-        maxInputTokens: 2e5,
-        maxOutputTokens: 64e3
-      },
-      {
-        id: "opus",
-        providerId: profile.id,
-        maxInputTokens: 2e5,
-        maxOutputTokensLimit: 64e3
-      }
-    ];
-    logger.info(`Loaded ${models.length} Claude Agent SDK models for profile ${profile.id}`);
-    return { models, success: true };
-  } catch (error) {
-    const errorMsg = typeof error === "string" ? error : error instanceof Error ? error.message : "Unknown error loading Claude Agent SDK models";
-    logger.error("Error loading Claude Agent SDK models:", error);
-    return { models: [], success: false, error: errorMsg };
-  }
-};
-const hasClaudeAgentSdkEnvVars = () => {
-  return findExecutableInPath("claude") !== null;
-};
-const getClaudeAgentSdkAiderMapping = (_provider, modelId) => {
-  return {
-    environmentVariables: {},
-    modelName: `claude-agent-sdk/${modelId}`
-  };
-};
-const normalizeAiSdkToolSet = (toolSet) => {
-  const normalizedToolSet = {};
-  for (const [toolName, toolDefinition] of Object.entries(toolSet)) {
-    let normalizedTool = { ...toolDefinition };
-    const inputSchema = toolDefinition.inputSchema;
-    if (inputSchema && typeof inputSchema === "object" && "jsonSchema" in inputSchema) {
-      const jsonSchemaObj = inputSchema.jsonSchema;
-      const schema = typeof jsonSchemaObj === "function" ? jsonSchemaObj() : jsonSchemaObj;
-      const zodShape = jsonSchemaToZod.JSONSchemaToZod.convert(schema);
-      normalizedTool = {
-        ...toolDefinition,
-        inputSchema: zodShape
-      };
-      logger.debug(`Converted JSONSchema to Zod for tool: ${toolName}`);
-    }
-    if (toolName === `${AIDER_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${AIDER_TOOL_RUN_PROMPT}`) {
-      const originalExecute = normalizedTool.execute;
-      if (!originalExecute) {
-        normalizedToolSet[toolName] = normalizedTool;
-        continue;
-      }
-      normalizedToolSet[toolName] = {
-        ...normalizedTool,
-        execute: async (args, options) => {
-          const result = await originalExecute(args, options);
-          if (result && typeof result === "object") {
-            delete result.responses;
-          }
-          return result;
-        }
-      };
-    } else if (toolName === `${SUBAGENTS_TOOL_GROUP_NAME}${TOOL_GROUP_NAME_SEPARATOR}${SUBAGENTS_TOOL_RUN_TASK}`) {
-      const originalExecute = normalizedTool.execute;
-      if (!originalExecute) {
-        normalizedToolSet[toolName] = normalizedTool;
-        continue;
-      }
-      normalizedToolSet[toolName] = {
-        ...normalizedTool,
-        execute: async (args, options) => {
-          const result = await originalExecute(args, options);
-          if (result && typeof result === "object") {
-            try {
-              const messages = result.messages;
-              if (Array.isArray(messages) && messages.length > 0) {
-                const lastMessage = messages[messages.length - 1];
-                return {
-                  messages: [lastMessage],
-                  promptContext: result.promptContext
-                };
-              }
-            } catch (error) {
-              logger.warn("Failed to optimize subagent result:", error);
-            }
-          }
-          return result;
-        }
-      };
-    } else {
-      normalizedToolSet[toolName] = normalizedTool;
-    }
-  }
-  return normalizedToolSet;
-};
-const createClaudeAgentSdkLlm = (_profile, model, _settings, _projectDir, toolSet, systemPrompt, providerMetadata) => {
-  const settings = {
-    env: {
-      // setting MAX_MCP_OUTPUT_TOKENS to a high number to avoid errors
-      MAX_MCP_OUTPUT_TOKENS: "9999999"
-    },
-    // for now only tools from AiderDesk are allowed
-    disallowedTools: [
-      "AskUserQuestion",
-      "Bash",
-      "TaskOutput",
-      "Edit",
-      "EnterPlanMode",
-      "ExitPlanMode",
-      "Glob",
-      "Grep",
-      "KillShell",
-      "MCPSearch",
-      "NotebookEdit",
-      "Read",
-      "Skill",
-      "Task",
-      "TaskCreate",
-      "TaskGet",
-      "TaskList",
-      "TaskUpdate",
-      "TodoWrite",
-      "WebFetch",
-      "WebSearch",
-      "Write",
-      "LSP"
-    ]
-  };
-  if (providerMetadata && typeof providerMetadata === "object" && "claude-code" in providerMetadata) {
-    const metadata = providerMetadata["claude-code"] || {};
-    settings.resume = metadata.sessionId;
-  }
-  if (!isDev() && isElectron()) {
-    settings.pathToClaudeCodeExecutable = CLAUDE_CODE_EXECUTABLE_PATH;
-  }
-  if (toolSet) {
-    logger.debug(`Adding ${Object.keys(toolSet).length} tools to Claude Agent SDK`, {
-      tools: Object.keys(toolSet)
-    });
-    settings.aiSdkTools = normalizeAiSdkToolSet(toolSet);
-    settings.allowedTools = ["mcp__ai-sdk"];
-  } else {
-    settings.allowedTools = [];
-  }
-  if (systemPrompt) {
-    settings.systemPrompt = systemPrompt;
-  }
-  return aiSdkProviderClaudeCode.claudeCode(model.id, settings);
-};
-const getClaudeAgentSdkUsageReport = (task, provider, model, _usage, providerMetadata) => {
-  const data = providerMetadata["claude-code"] || {};
-  const usage = data.lastMessageRawUsage || data.rawUsage || {};
-  logger.debug("Claude Agent SDK usage:", { usage: _usage, providerMetadata });
-  const sentTokens = usage.input_tokens || 0;
-  const receivedTokens = usage.output_tokens || 0;
-  const cacheWriteTokens = usage.cache_creation_input_tokens || 0;
-  const cacheReadTokens = usage.cache_read_input_tokens || 0;
-  const messageCost = calculateCost(model, sentTokens, receivedTokens, cacheReadTokens);
-  return {
-    model: `${provider.id}/${model.id}`,
-    sentTokens: sentTokens + cacheReadTokens,
-    receivedTokens: receivedTokens + cacheWriteTokens,
-    messageCost,
-    agentTotalCost: task.task.agentTotalCost + messageCost
-  };
-};
-const getClaudeAgentSdkProviderParameters = () => {
-  return {
-    system: void 0
-  };
-};
-const claudeAgentSdkProviderStrategy = {
-  createLlm: createClaudeAgentSdkLlm,
-  getUsageReport: getClaudeAgentSdkUsageReport,
-  loadModels: loadClaudeAgentSdkModels,
-  hasEnvVars: hasClaudeAgentSdkEnvVars,
-  getAiderMapping: getClaudeAgentSdkAiderMapping,
-  getProviderParameters: getClaudeAgentSdkProviderParameters
-};
 const loadDeepseekModels = async (profile, settings) => {
   if (!isDeepseekProvider(profile.provider)) {
     return { models: [], success: false };
@@ -22678,6 +22489,20 @@ const loadMinimaxModels = async (profile) => {
     };
   }
   const hardcodedModels = [
+    {
+      id: "MiniMax-M3",
+      providerId: profile.id,
+      maxInputTokens: 1e6,
+      maxOutputTokensLimit: 131072,
+      inputCostPerToken: 3e-7,
+      // 0.3 per 1M tokens
+      outputCostPerToken: 12e-7,
+      // 1.2 per 1M tokens
+      cacheReadInputTokenCost: 6e-8,
+      // 0.06 per 1M tokens
+      cacheWriteInputTokenCost: 375e-9
+      // 0.375 per 1M tokens
+    },
     {
       id: "MiniMax-M2.7",
       providerId: profile.id,
@@ -24396,7 +24221,7 @@ const zaiPlanProviderStrategy = {
 const MODELS_META_URL = "https://models.dev/api.json";
 const MODELS_FILE = path.join(AIDER_DESK_DATA_DIR, "models.json");
 const PROVIDER_MODELS_CACHE_FILE = path.join(AIDER_DESK_CACHE_DIR, "provider-models.json");
-const PROVIDER_MODELS_CACHE_VERSION = 1;
+const PROVIDER_MODELS_CACHE_VERSION = 2;
 class ModelManager {
   constructor(store, eventManager) {
     this.store = store;
@@ -24412,11 +24237,9 @@ class ModelManager {
   providerRegistry = {
     anthropic: anthropicProviderStrategy,
     "anthropic-compatible": anthropicCompatibleProviderStrategy,
-    auggie: auggieProviderStrategy,
     azure: azureProviderStrategy,
     bedrock: bedrockProviderStrategy,
     cerebras: cerebrasProviderStrategy,
-    "claude-agent-sdk": claudeAgentSdkProviderStrategy,
     deepseek: deepseekProviderStrategy,
     gemini: geminiProviderStrategy,
     "gemini-cli": geminiCliProviderStrategy,
@@ -25089,7 +24912,7 @@ class ModelManager {
       const { provider } = registered;
       this.providerRegistry[provider.provider.name] = {
         ...provider.strategy,
-        createLlm: (profile2, model, settings, projectDir) => provider.strategy.createLlm(profile2, model, settings, projectDir),
+        createLlm: (profile2, model, settings, projectDir, toolSet, systemPrompt, providerMetadata) => provider.strategy.createLlm(profile2, model, settings, projectDir, toolSet, systemPrompt, providerMetadata),
         getUsageReport: provider.strategy.getUsageReport || getDefaultUsageReport,
         getProviderOptions: provider.strategy.getProviderOptions ? (_provider, model) => provider.strategy.getProviderOptions(model) : void 0,
         getProviderTools: provider.strategy.getProviderTools ? (_provider, model) => provider.strategy.getProviderTools(model) : void 0,
@@ -25147,7 +24970,11 @@ class ModelManager {
     this.eventManager.sendProvidersUpdated(this.getProviders());
   }
   getProviders() {
-    return [...this.store.getProviders(), ...this.getExtensionProviderProfiles()];
+    const providersById = new Map(this.store.getProviders().map((p) => [p.id, p]));
+    for (const extensionProfile of this.getExtensionProviderProfiles()) {
+      providersById.set(extensionProfile.id, extensionProfile);
+    }
+    return [...providersById.values()];
   }
   getExtensionProviderProfiles() {
     return [...this.extensionProviders.values()].map((e) => e.profile);
@@ -27619,15 +27446,48 @@ class ExtensionManager {
       errors
     };
   }
+  getToolsInfo(projectDir) {
+    const allExtensions = this.registry.getExtensions(projectDir);
+    const extensions = this.filterEnabledExtensions(allExtensions);
+    const result = [];
+    for (const loaded of extensions) {
+      const { instance, metadata } = loaded;
+      if (!instance.getTools) {
+        continue;
+      }
+      try {
+        const context = new ExtensionContextImpl(loaded.id, metadata.name, this.store, this.modelManager, this.eventManager, this.memoryManager);
+        const tools = instance.getTools(context, "agent", DEFAULT_AGENT_PROFILE);
+        if (!Array.isArray(tools)) {
+          continue;
+        }
+        const toolInfos = tools.filter((tool) => tool.name && tool.description).map((tool) => ({ name: tool.name, description: tool.description }));
+        if (toolInfos.length > 0) {
+          result.push({
+            extensionId: loaded.id,
+            extensionName: metadata.name,
+            tools: toolInfos
+          });
+        }
+      } catch (error) {
+        logger.error(`[Extensions] Failed to get tools info from extension '${metadata.name}':`, error);
+      }
+    }
+    return result;
+  }
   getTools(task, mode, profile) {
     const collectedTools = [];
     const allExtensions = this.registry.getExtensions(task.getProjectDir());
     const extensions = this.filterEnabledExtensions(allExtensions);
+    const disabledExtensionTools = profile.disabledExtensionTools ?? [];
     for (const loaded of extensions) {
       const { instance, metadata } = loaded;
       if (!instance.getTools) {
         continue;
       }
+      if (disabledExtensionTools.includes(loaded.id)) {
+        continue;
+      }
       try {
         const context = new ExtensionContextImpl(
           loaded.id,
@@ -27650,6 +27510,10 @@ class ExtensionManager {
             logger.error(`[Extensions] Invalid tool '${tool.name}' from extension '${metadata.name}': ${validation.errors.join(", ")}`);
             continue;
           }
+          const fullToolId = `${loaded.id}${TOOL_GROUP_NAME_SEPARATOR}${tool.name}`;
+          if (profile.toolApprovals?.[fullToolId] === ToolApprovalState.Never || profile.toolApprovals?.[tool.name] === ToolApprovalState.Never) {
+            continue;
+          }
           collectedTools.push({
             extensionId: loaded.id,
             extensionName: metadata.name,
@@ -27673,11 +27537,12 @@ class ExtensionManager {
    * @param abortSignal - Optional AbortSignal for cancellation support
    * @returns A ToolSet containing all approved extension tools
    */
-  createExtensionToolset(task, mode, profile, allTools, abortSignal) {
+  createExtensionToolset(task, mode, profile, allTools, approvalManager, abortSignal) {
     const toolSet = {};
     const registeredTools = this.getTools(task, mode, profile);
     for (const { extensionId, extensionName, tool } of registeredTools) {
       const toolId = tool.name;
+      const fullToolId = `${extensionId}${TOOL_GROUP_NAME_SEPARATOR}${tool.name}`;
       const context = new ExtensionContextImpl(
         extensionId,
         extensionName,
@@ -27688,14 +27553,25 @@ class ExtensionManager {
         task.project,
         task
       );
-      if (profile.toolApprovals?.[toolId] === ToolApprovalState.Never) {
-        logger.debug(`[Extensions] Skipping tool '${tool.name}' (marked as Never approved)`);
-        continue;
-      }
       toolSet[toolId] = {
         description: tool.description,
         inputSchema: tool.inputSchema,
         execute: async (input, options) => {
+          const toolApproval = profile.toolApprovals?.[fullToolId];
+          logger.debug(
+            `[Extensions] Tool '${tool.name}' approval check: fullToolId='${fullToolId}', approval=${toolApproval}, allApprovals=${JSON.stringify(profile.toolApprovals)}`
+          );
+          if (toolApproval === ToolApprovalState.Ask) {
+            const questionKey = fullToolId;
+            const questionText = `Approve tool ${tool.name} from ${extensionName} extension?`;
+            const questionSubject = input ? JSON.stringify(input) : void 0;
+            const [isApproved, userInput] = await approvalManager.handleToolApproval(fullToolId, input, questionKey, questionText, questionSubject);
+            if (!isApproved) {
+              logger.warn(`Tool execution denied by user: ${fullToolId}`);
+              return `Tool execution denied by user.${userInput ? ` User input: ${userInput}` : ""}`;
+            }
+            logger.debug(`Tool execution approved: ${fullToolId}`);
+          }
           const allToolsInternal = Object.entries(allTools).reduce(
             (acc, [toolId2, tool2]) => {
               acc[toolId2] = {
@@ -28933,12 +28809,26 @@ class EventsHandler {
     }
     await task.mergeWorktreeToMain(squash, targetBranch, commitMessage);
   }
-  async mergeAndSwitchToLocal(baseDir, taskId, targetBranch) {
+  async switchToLocalWorkingMode(baseDir, taskId, options) {
+    const task = this.projectManager.getProject(baseDir).getTask(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    await task.switchToLocalWorkingMode(options);
+  }
+  async switchToWorktreeWorkingMode(baseDir, taskId, options) {
     const task = this.projectManager.getProject(baseDir).getTask(taskId);
     if (!task) {
       throw new Error(`Task ${taskId} not found`);
     }
-    await task.mergeAndSwitchToLocal(targetBranch);
+    await task.switchToWorktreeWorkingMode(options);
+  }
+  async getLocalUncommittedFiles(baseDir, taskId) {
+    const task = this.projectManager.getProject(baseDir).getTask(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+    return await task.getLocalUncommittedFiles();
   }
   async applyUncommittedChanges(baseDir, taskId, targetBranch) {
     const task = this.projectManager.getProject(baseDir).getTask(taskId);
@@ -29417,6 +29307,9 @@ ${error instanceof Error ? error.message : String(error)}`);
       readmeContent: ext.readmeContent
     }));
   }
+  getExtensionToolsInfo(projectDir) {
+    return this.extensionManager.getToolsInfo(projectDir);
+  }
   async getAvailableExtensions(repositories, forceRefresh, fetchOnly) {
     return await this.extensionManager.getAvailableExtensions(repositories, forceRefresh, fetchOnly);
   }
@@ -29452,6 +29345,7 @@ ${error instanceof Error ? error.message : String(error)}`);
     return filtered.map((c) => ({
       extensionId: c.extensionId,
       componentId: c.component.id,
+      name: c.component.name,
       placement: c.component.placement,
       jsx: c.component.jsx,
       loadData: c.component.loadData,
@@ -30791,6 +30685,9 @@ const migrateSettingsV19toV20 = (settings) => {
     }
   };
 };
+const migrateProvidersV20toV21 = (providers) => {
+  return providers.filter((p) => p.provider.name !== "claude-agent-sdk" && p.provider.name !== "auggie");
+};
 const DEFAULT_SETTINGS = {
   language: "en",
   startupMode: ProjectStartMode.Empty,
@@ -30870,7 +30767,7 @@ const DEFAULT_SETTINGS = {
 const compareBaseDirs = (baseDir1, baseDir2) => {
   return normalizeBaseDir(baseDir1) === normalizeBaseDir(baseDir2);
 };
-const CURRENT_SETTINGS_VERSION = 20;
+const CURRENT_SETTINGS_VERSION = 21;
 class Store {
   // @ts-expect-error expected to be initialized
   store;
@@ -31025,6 +30922,10 @@ class Store {
         settings = migrateSettingsV19toV20(settings);
         settingsVersion = 20;
       }
+      if (settingsVersion === 20) {
+        providers = migrateProvidersV20toV21(providers || []);
+        settingsVersion = 21;
+      }
       this.store.set("settings", settings);
       this.store.set("openProjects", openProjects || []);
       this.store.set("providers", providers || []);