@shareai-lab/kode 1.2.0 → 2.0.2

package/dist/chunk-6DRDLOLP.js

@@ -0,0 +1,2613 @@
+import { createRequire as __kodeCreateRequire } from "node:module";
+const require = __kodeCreateRequire(import.meta.url);
+import {
+  AskUserQuestionTool,
+  BashTool,
+  Cost,
+  EnterPlanModeTool,
+  ExitPlanModeTool,
+  FileEditTool,
+  FileReadTool,
+  FileWriteTool,
+  GlobTool,
+  GrepTool,
+  KillShellTool,
+  NotebookEditTool,
+  SkillTool,
+  SlashCommandTool,
+  TodoWriteTool,
+  WebFetchTool,
+  WebSearchTool,
+  applyMarkdown,
+  countTokens,
+  getAbsolutePath,
+  getAgentPrompt,
+  getMaxThinkingTokens,
+  hasPermissionsToUseTool,
+  hasReadPermission,
+  query
+} from "./chunk-HSPVVDIW.js";
+import {
+  FallbackToolUseRejectedMessage,
+  MCPTool,
+  getClients,
+  getMCPTools
+} from "./chunk-7CQVZNQV.js";
+import {
+  queryLLM
+} from "./chunk-67PY5IX6.js";
+import {
+  generateAgentId
+} from "./chunk-IE2CG2TV.js";
+import {
+  getActiveAgents,
+  getAgentByType,
+  getAvailableAgentTypes
+} from "./chunk-OZNRLY3E.js";
+import {
+  INTERRUPT_MESSAGE,
+  createAssistantMessage,
+  createUserMessage,
+  getLastAssistantMessageId
+} from "./chunk-2KWKUXLT.js";
+import {
+  getModelManager
+} from "./chunk-Z33T5YN5.js";
+import {
+  getContext
+} from "./chunk-OIFQB3S4.js";
+import {
+  getTheme
+} from "./chunk-SDGKPKDK.js";
+import {
+  debug
+} from "./chunk-QYFKRZQC.js";
+import {
+  BunShell,
+  getCwd,
+  getMessagesPath,
+  getNextAvailableLogSidechainNumber,
+  logError,
+  overwriteLog,
+  readTaskOutput
+} from "./chunk-MN77D2F7.js";
+import {
+  formatDuration,
+  formatNumber
+} from "./chunk-EZXMVTDU.js";
+
+// src/tools/index.ts
+import { memoize as memoize2 } from "lodash-es";
+
+// src/tools/ai/AskExpertModelTool/AskExpertModelTool.tsx
+import * as React from "react";
+import { Box, Text } from "ink";
+import { z } from "zod";
+
+// src/utils/session/expertChatStorage.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+function getExpertChatDirectory() {
+  const configDir = process.env.KODE_CONFIG_DIR ?? process.env.ANYKODE_CONFIG_DIR ?? join(homedir(), ".kode");
+  const expertChatDir = join(configDir, "expert-chats");
+  if (!existsSync(expertChatDir)) {
+    mkdirSync(expertChatDir, { recursive: true });
+  }
+  return expertChatDir;
+}
+function getSessionFilePath(sessionId) {
+  return join(getExpertChatDirectory(), `${sessionId}.json`);
+}
+function createExpertChatSession(expertModel) {
+  const sessionId = randomUUID().slice(0, 5);
+  const session = {
+    sessionId,
+    expertModel,
+    messages: [],
+    createdAt: Date.now(),
+    lastUpdated: Date.now()
+  };
+  saveExpertChatSession(session);
+  return session;
+}
+function loadExpertChatSession(sessionId) {
+  const filePath = getSessionFilePath(sessionId);
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    logError(error);
+    debug.warn("EXPERT_CHAT_SESSION_LOAD_FAILED", {
+      sessionId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function saveExpertChatSession(session) {
+  const filePath = getSessionFilePath(session.sessionId);
+  try {
+    session.lastUpdated = Date.now();
+    writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
+  } catch (error) {
+    logError(error);
+    debug.warn("EXPERT_CHAT_SESSION_SAVE_FAILED", {
+      sessionId: session.sessionId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
+  }
+}
+function addMessageToSession(sessionId, role, content) {
+  const session = loadExpertChatSession(sessionId);
+  if (!session) {
+    return null;
+  }
+  session.messages.push({ role, content });
+  saveExpertChatSession(session);
+  return session;
+}
+function getSessionMessages(sessionId) {
+  const session = loadExpertChatSession(sessionId);
+  return session?.messages || [];
+}
+
+// src/tools/ai/AskExpertModelTool/AskExpertModelTool.tsx
+var inputSchema = z.strictObject({
+  question: z.string().describe(
+    "COMPLETE SELF-CONTAINED QUESTION: Must include full background context, relevant details, and a clear independent question. The expert model will receive ONLY this content with no access to previous conversation or external context. Structure as: 1) Background/Context 2) Specific situation/problem 3) Clear question. Ensure the expert can fully understand and respond without needing additional information."
+  ),
+  expert_model: z.string().describe(
+    "The expert model to use (e.g., gpt-5, claude-3-5-sonnet-20241022)"
+  ),
+  chat_session_id: z.string().describe(
+    'Chat session ID: use "new" for new session or existing session ID'
+  )
+});
+var AskExpertModelTool = {
+  name: "AskExpertModel",
+  async description() {
+    return "Consult external AI models for expert opinions and analysis";
+  },
+  async prompt() {
+    return `Ask a question to a specific external AI model for expert analysis.
+
+This tool allows you to consult different AI models for their unique perspectives and expertise.
+
+CRITICAL REQUIREMENT FOR QUESTION PARAMETER:
+The question MUST be completely self-contained and include:
+1. FULL BACKGROUND CONTEXT - All relevant information the expert needs
+2. SPECIFIC SITUATION - Clear description of the current scenario/problem
+3. INDEPENDENT QUESTION - What exactly you want the expert to analyze/answer
+
+The expert model receives ONLY your question content with NO access to:
+- Previous conversation history (unless using existing session)  
+- Current codebase or file context
+- User's current task or project details
+
+IMPORTANT: This tool is for asking questions to models, not for task execution.
+- Use when you need a specific model's opinion or analysis
+- Use when you want to compare different models' responses
+- Use the @ask-[model] format when available
+
+The expert_model parameter accepts:
+- OpenAI: gpt-4, gpt-5, o1-preview
+- Messages API: claude-3-5-sonnet, claude-3-opus  
+- Others: kimi, gemini-pro, mixtral
+
+Example of well-structured question:
+"Background: I'm working on a React TypeScript application with performance issues. The app renders a large list of 10,000 items using a simple map() function, causing UI freezing.
+
+Current situation: Users report 3-5 second delays when scrolling through the list. The component re-renders the entire list on every state change.
+
+Question: What are the most effective React optimization techniques for handling large lists, and how should I prioritize implementing virtualization vs memoization vs other approaches?"`;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  inputSchema,
+  userFacingName() {
+    return "AskExpertModel";
+  },
+  async isEnabled() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  async validateInput({ question, expert_model, chat_session_id }, context) {
+    if (!question.trim()) {
+      return { result: false, message: "Question cannot be empty" };
+    }
+    if (!expert_model.trim()) {
+      return { result: false, message: "Expert model must be specified" };
+    }
+    if (!chat_session_id.trim()) {
+      return {
+        result: false,
+        message: 'Chat session ID must be specified (use "new" for new session)'
+      };
+    }
+    try {
+      const modelManager = getModelManager();
+      let currentModel;
+      if (context?.agentId && context?.options?.model) {
+        currentModel = context.options.model;
+      } else {
+        currentModel = modelManager.getModelName("main") || "";
+      }
+      const normalizedExpert = expert_model.toLowerCase().replace(/[^a-z0-9]/g, "");
+      const normalizedCurrent = currentModel.toLowerCase().replace(/[^a-z0-9]/g, "");
+      if (normalizedExpert === normalizedCurrent) {
+        return {
+          result: false,
+          message: `You are already running as ${currentModel}. Consulting the same model would be redundant. Please choose a different model or handle the task directly.`
+        };
+      }
+    } catch (e) {
+      debug.error("AskExpertModel", {
+        message: "Could not determine current model",
+        error: e
+      });
+    }
+    try {
+      const modelManager = getModelManager();
+      const modelResolution = modelManager.resolveModelWithInfo(expert_model);
+      if (!modelResolution.success) {
+        const availableModels = modelManager.getAllAvailableModelNames();
+        if (availableModels.length > 0) {
+          return {
+            result: false,
+            message: `Model '${expert_model}' is not configured. Available models: ${availableModels.join(", ")}. Check if any available model closely matches the user's request (e.g., 'kimi' matches 'kimi-k2-0711-preview'). If there's a strong match, auto retry using the correct model name. If no close match exists, inform the user that '${expert_model}' needs to be configured using /model command.`
+          };
+        } else {
+          return {
+            result: false,
+            message: `Model '${expert_model}' not found and no models are currently configured in the system. Inform the user that models need to be configured first using the /model command.`
+          };
+        }
+      }
+    } catch (error) {
+      logError(error);
+      return {
+        result: false,
+        message: `Failed to validate expert model '${expert_model}'. Please check your model configuration.`
+      };
+    }
+    return { result: true };
+  },
+  renderToolUseMessage({ question, expert_model, chat_session_id }, { verbose }) {
+    if (!question || !expert_model) return null;
+    const isNewSession = chat_session_id === "new";
+    const sessionDisplay = isNewSession ? "new session" : `session ${chat_session_id.substring(0, 5)}...`;
+    const theme = getTheme();
+    if (verbose) {
+      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { bold: true, color: "yellow" }, expert_model), /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, sessionDisplay), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { color: theme.text }, question.length > 300 ? question.substring(0, 300) + "..." : question)));
+    }
+    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { bold: true, color: "yellow" }, expert_model, " "), /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText, dimColor: true }, "(", sessionDisplay, ")"));
+  },
+  renderToolResultMessage(content) {
+    const verbose = true;
+    const theme = getTheme();
+    if (typeof content === "object" && content && "expertAnswer" in content) {
+      const expertResult = content;
+      const isError = expertResult.expertAnswer.startsWith("Error") || expertResult.expertAnswer.includes("failed");
+      const isInterrupted = expertResult.chatSessionId === "interrupted";
+      if (isInterrupted) {
+        return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, "Consultation interrupted"));
+      }
+      const answerText = verbose ? expertResult.expertAnswer.trim() : expertResult.expertAnswer.length > 500 ? expertResult.expertAnswer.substring(0, 500) + "..." : expertResult.expertAnswer.trim();
+      if (isError) {
+        return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { color: "red" }, answerText));
+      }
+      return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, { bold: true, color: theme.text }, "Response from ", expertResult.expertModelName, ":"), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { color: theme.text }, applyMarkdown(answerText))), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText, dimColor: true }, "Session: ", expertResult.chatSessionId.substring(0, 8))));
+    }
+    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "row" }, /* @__PURE__ */ React.createElement(Text, { color: theme.secondaryText }, "Consultation completed"));
+  },
+  renderResultForAssistant(output) {
+    return `[Expert consultation completed]
+Expert Model: ${output.expertModelName}
+Session ID: ${output.chatSessionId}
+To continue this conversation with context preservation, use this Session ID in your next AskExpertModel call to maintain the full conversation history and context.
+
+${output.expertAnswer}`;
+  },
+  renderToolUseRejectedMessage() {
+    return /* @__PURE__ */ React.createElement(FallbackToolUseRejectedMessage, null);
+  },
+  async *call({ question, expert_model, chat_session_id }, { abortController, readFileTimestamps }) {
+    const expertModel = expert_model;
+    let sessionId;
+    let isInterrupted = false;
+    const abortListener = () => {
+      isInterrupted = true;
+    };
+    abortController.signal.addEventListener("abort", abortListener);
+    try {
+      if (abortController.signal.aborted) {
+        return yield* this.handleInterrupt();
+      }
+      if (chat_session_id === "new") {
+        try {
+          const session = createExpertChatSession(expertModel);
+          sessionId = session.sessionId;
+        } catch (error) {
+          logError(error);
+          throw new Error("Failed to create new chat session");
+        }
+      } else {
+        sessionId = chat_session_id;
+        try {
+          const session = loadExpertChatSession(sessionId);
+          if (!session) {
+            const newSession = createExpertChatSession(expertModel);
+            sessionId = newSession.sessionId;
+          }
+        } catch (error) {
+          logError(error);
+          try {
+            const newSession = createExpertChatSession(expertModel);
+            sessionId = newSession.sessionId;
+          } catch (createError) {
+            logError(createError);
+            throw new Error("Unable to create or load chat session");
+          }
+        }
+      }
+      if (isInterrupted || abortController.signal.aborted) {
+        return yield* this.handleInterrupt();
+      }
+      let historyMessages;
+      try {
+        historyMessages = getSessionMessages(sessionId);
+      } catch (error) {
+        logError(error);
+        historyMessages = [];
+      }
+      const messages = [...historyMessages, { role: "user", content: question }];
+      let systemMessages;
+      try {
+        systemMessages = messages.map(
+          (msg) => msg.role === "user" ? createUserMessage(msg.content) : createAssistantMessage(msg.content)
+        );
+      } catch (error) {
+        logError(error);
+        throw new Error("Failed to prepare conversation messages");
+      }
+      if (isInterrupted || abortController.signal.aborted) {
+        return yield* this.handleInterrupt();
+      }
+      yield {
+        type: "progress",
+        content: createAssistantMessage(
+          `Connecting to ${expertModel}... (timeout: 5 minutes)`
+        )
+      };
+      let response;
+      try {
+        const modelManager = getModelManager();
+        const modelResolution = modelManager.resolveModelWithInfo(expertModel);
+        debug.api("EXPERT_MODEL_RESOLUTION", {
+          requestedModel: expertModel,
+          success: modelResolution.success,
+          profileName: modelResolution.profile?.name,
+          profileModelName: modelResolution.profile?.modelName,
+          provider: modelResolution.profile?.provider,
+          isActive: modelResolution.profile?.isActive,
+          error: modelResolution.error
+        });
+        const timeoutMs = 3e5;
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(
+              new Error(
+                `Expert model query timed out after ${timeoutMs / 1e3}s`
+              )
+            );
+          }, timeoutMs);
+        });
+        response = await Promise.race([
+          queryLLM(
+            systemMessages,
+            [],
+            0,
+            [],
+            abortController.signal,
+            {
+              safeMode: false,
+              model: expertModel,
+              prependCLISysprompt: false
+            }
+          ),
+          timeoutPromise
+        ]);
+      } catch (error) {
+        logError(error);
+        if (error.name === "AbortError" || abortController.signal?.aborted || isInterrupted) {
+          return yield* this.handleInterrupt();
+        }
+        if (error.message?.includes("timed out")) {
+          throw new Error(
+            `Expert model '${expertModel}' timed out after 5 minutes.
+
+Suggestions:
+  - The model might be experiencing high load
+  - Try a different model or retry later
+  - Consider breaking down your question into smaller parts`
+          );
+        }
+        if (error.message?.includes("rate limit")) {
+          throw new Error(
+            `Rate limit exceeded for ${expertModel}.
+
+Please wait a moment and try again, or use a different model.`
+          );
+        }
+        if (error.message?.includes("invalid api key")) {
+          throw new Error(
+            `Invalid API key for ${expertModel}.
+
+Please check your model configuration with /model command.`
+          );
+        }
+        if (error.message?.includes("model not found") || error.message?.includes("Failed to resolve model")) {
+          try {
+            const modelManager = getModelManager();
+            const availableModels = modelManager.getAllAvailableModelNames();
+            if (availableModels.length > 0) {
+              throw new Error(
+                `Model '${expertModel}' is not configured. Available models: ${availableModels.join(", ")}. Check if any available model closely matches the user's request (e.g., 'kimi' matches 'kimi-k2-0711-preview'). If there's a strong match, auto retry using the correct model name. If no close match exists, inform the user that '${expertModel}' needs to be configured using /model command.`
+              );
+            } else {
+              throw new Error(
+                `Model '${expertModel}' not found and no models are currently configured in the system. Inform the user that models need to be configured first using the /model command.`
+              );
+            }
+          } catch (modelError) {
+            throw new Error(
+              `Model '${expertModel}' not found. Please check model configuration or inform user about the issue.`
+            );
+          }
+        }
+        throw new Error(
+          `Expert model query failed: ${error.message || "Unknown error"}`
+        );
+      }
+      let expertAnswer;
+      try {
+        if (!response?.message?.content) {
+          throw new Error("No content in expert response");
+        }
+        expertAnswer = response.message.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+        if (!expertAnswer.trim()) {
+          throw new Error("Expert response was empty");
+        }
+      } catch (error) {
+        logError(error);
+        throw new Error("Failed to process expert response");
+      }
+      try {
+        addMessageToSession(sessionId, "user", question);
+        addMessageToSession(sessionId, "assistant", expertAnswer);
+      } catch (error) {
+        logError(error);
+      }
+      const result = {
+        chatSessionId: sessionId,
+        expertModelName: expertModel,
+        expertAnswer
+      };
+      yield {
+        type: "result",
+        data: result,
+        resultForAssistant: this.renderResultForAssistant(result)
+      };
+    } catch (error) {
+      if (error.name === "AbortError" || abortController.signal?.aborted || isInterrupted) {
+        return yield* this.handleInterrupt();
+      }
+      logError(error);
+      const errorSessionId = sessionId || "error-session";
+      const errorMessage = error.message || "Expert consultation failed with unknown error";
+      const result = {
+        chatSessionId: errorSessionId,
+        expertModelName: expertModel,
+        expertAnswer: `\u274C ${errorMessage}`
+      };
+      yield {
+        type: "result",
+        data: result,
+        resultForAssistant: this.renderResultForAssistant(result)
+      };
+    } finally {
+      abortController.signal.removeEventListener("abort", abortListener);
+    }
+  },
+  async *handleInterrupt() {
+    yield {
+      type: "result",
+      data: {
+        chatSessionId: "interrupted",
+        expertModelName: "cancelled",
+        expertAnswer: INTERRUPT_MESSAGE
+      },
+      resultForAssistant: INTERRUPT_MESSAGE
+    };
+  }
+};
+
+// src/tools/system/TaskOutputTool/TaskOutputTool.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import React2 from "react";
+import { z as z2 } from "zod";
+
+// src/utils/session/backgroundTasks.ts
+var backgroundTasks = /* @__PURE__ */ new Map();
+function getBackgroundAgentTaskSnapshot(agentId) {
+  const task = backgroundTasks.get(agentId);
+  if (!task) return void 0;
+  const { abortController: _abortController, done: _done, ...snapshot } = task;
+  return snapshot;
+}
+function upsertBackgroundAgentTask(task) {
+  backgroundTasks.set(task.agentId, task);
+}
+async function waitForBackgroundAgentTask(agentId, waitUpToMs, signal) {
+  const task = backgroundTasks.get(agentId);
+  if (!task) return void 0;
+  if (task.status !== "running") return task;
+  const timeoutPromise = new Promise((_, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error("Request timed out"));
+    }, waitUpToMs);
+    timeoutId.unref?.();
+  });
+  const abortPromise = new Promise((_, reject) => {
+    if (signal.aborted) {
+      reject(new Error("Request aborted"));
+      return;
+    }
+    const onAbort = () => reject(new Error("Request aborted"));
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  await Promise.race([task.done, timeoutPromise, abortPromise]);
+  return backgroundTasks.get(agentId);
+}
+
+// src/utils/tooling/toolOutputDisplay.ts
+function isTruthyEnv(value) {
+  if (!value) return false;
+  return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+function isPackagedRuntime() {
+  if (isTruthyEnv(process.env.KODE_PACKAGED)) return true;
+  try {
+    const exec = (process.execPath || "").split(/[\\/]/).pop()?.toLowerCase();
+    if (!exec) return false;
+    if (exec === "bun" || exec === "bun.exe") return false;
+    if (exec === "node" || exec === "node.exe") return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function truncateTextForDisplay(text, options) {
+  const maxLines = options?.maxLines ?? 120;
+  const maxChars = options?.maxChars ?? 12e3;
+  const normalized = String(text ?? "");
+  const lines = normalized.split(/\r?\n/);
+  let workingLines = lines;
+  let omittedLines = 0;
+  if (maxLines > 0 && lines.length > maxLines) {
+    workingLines = lines.slice(0, maxLines);
+    omittedLines = lines.length - maxLines;
+  }
+  let workingText = workingLines.join("\n");
+  let omittedChars = 0;
+  if (maxChars > 0 && workingText.length > maxChars) {
+    omittedChars = workingText.length - maxChars;
+    workingText = workingText.slice(0, maxChars);
+  }
+  const truncated = omittedLines > 0 || omittedChars > 0;
+  if (!truncated) {
+    return {
+      text: workingText,
+      truncated: false,
+      omittedLines: 0,
+      omittedChars: 0
+    };
+  }
+  const suffixParts = [];
+  if (omittedLines > 0) {
+    suffixParts.push(`${omittedLines} lines`);
+  }
+  if (omittedChars > 0) {
+    suffixParts.push(`${omittedChars} chars`);
+  }
+  const suffix = `
+
+... [truncated ${suffixParts.join(" \xB7 ")}] ...`;
+  return {
+    text: workingText + suffix,
+    truncated: true,
+    omittedLines,
+    omittedChars
+  };
+}
+function maybeTruncateVerboseToolOutput(text, options) {
+  const maxLinesEnv = Number(process.env.KODE_TOOL_OUTPUT_MAX_LINES ?? "");
+  const maxCharsEnv = Number(process.env.KODE_TOOL_OUTPUT_MAX_CHARS ?? "");
+  const envOverrides = {
+    maxLines: Number.isFinite(maxLinesEnv) && maxLinesEnv > 0 ? maxLinesEnv : void 0,
+    maxChars: Number.isFinite(maxCharsEnv) && maxCharsEnv > 0 ? maxCharsEnv : void 0
+  };
+  const effective = {
+    maxLines: envOverrides.maxLines ?? options?.maxLines,
+    maxChars: envOverrides.maxChars ?? options?.maxChars
+  };
+  const fullAllowed = isTruthyEnv(process.env.KODE_TOOL_OUTPUT_FULL);
+  if (!isPackagedRuntime() || fullAllowed) {
+    return { text: String(text ?? ""), truncated: false };
+  }
+  const result = truncateTextForDisplay(String(text ?? ""), effective);
+  return { text: result.text, truncated: result.truncated };
+}
+
+// src/tools/system/TaskOutputTool/prompt.ts
+var TOOL_NAME_FOR_PROMPT = "TaskOutput";
+var DESCRIPTION = "Retrieves output from a running or completed task";
+var PROMPT = `- Retrieves output from a running or completed task (background shell, agent, or remote session)
+- Takes a task_id parameter identifying the task
+- Returns the task output along with status information
+- Use block=true (default) to wait for task completion
+- Use block=false for non-blocking check of current status
+- Task IDs can be found using the /tasks command
+- Works with all task types: background shells, async agents, and remote sessions`;
+
+// src/tools/system/TaskOutputTool/TaskOutputTool.tsx
+var inputSchema2 = z2.strictObject({
+  task_id: z2.string().describe("The task ID to get output from"),
+  block: z2.boolean().optional().default(true).describe("Whether to wait for completion"),
+  timeout: z2.number().min(0).max(6e5).optional().default(3e4).describe("Max wait time in ms")
+});
+function normalizeTaskOutputInput(input) {
+  const task_id = typeof input.task_id === "string" && input.task_id || typeof input.agentId === "string" && String(input.agentId) || typeof input.bash_id === "string" && String(input.bash_id) || "";
+  const block = typeof input.block === "boolean" ? input.block : true;
+  const timeout = typeof input.timeout === "number" ? input.timeout : typeof input.wait_up_to === "number" ? Number(input.wait_up_to) * 1e3 : 3e4;
+  return { task_id, block, timeout };
+}
+function taskStatusFromBash(bg) {
+  if (!bg) return "failed";
+  if (bg.killed) return "killed";
+  if (bg.code === null) return "running";
+  return bg.code === 0 ? "completed" : "failed";
+}
+function buildTaskSummary(taskId) {
+  const bg = BunShell.getInstance().getBackgroundOutput(taskId);
+  if (bg) {
+    return {
+      task_id: taskId,
+      task_type: "local_bash",
+      status: taskStatusFromBash(bg),
+      description: bg.command,
+      output: readTaskOutput(taskId),
+      exitCode: bg.code
+    };
+  }
+  const agent = getBackgroundAgentTaskSnapshot(taskId);
+  if (agent) {
+    const output = readTaskOutput(taskId) || agent.resultText || "";
+    return {
+      task_id: taskId,
+      task_type: "local_agent",
+      status: agent.status,
+      description: agent.description,
+      output,
+      prompt: agent.prompt,
+      result: output,
+      error: agent.error
+    };
+  }
+  return null;
+}
+async function waitForBashTaskCompletion(args) {
+  const { taskId, timeoutMs, signal } = args;
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (signal.aborted) return null;
+    const summary = buildTaskSummary(taskId);
+    if (!summary) return null;
+    if (summary.status !== "running" && summary.status !== "pending")
+      return summary;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return buildTaskSummary(taskId);
+}
+var TaskOutputTool = {
+  name: TOOL_NAME_FOR_PROMPT,
+  async description() {
+    return DESCRIPTION;
+  },
+  userFacingName() {
+    return "Task Output";
+  },
+  inputSchema: inputSchema2,
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  async isEnabled() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  async prompt() {
+    return PROMPT;
+  },
+  renderToolUseMessage(input) {
+    const normalized = normalizeTaskOutputInput(input);
+    if (!normalized.block) return "non-blocking";
+    return "";
+  },
+  renderToolUseRejectedMessage() {
+    return null;
+  },
+  renderToolResultMessage(output, { verbose }) {
+    const theme = getTheme();
+    if (output.retrieval_status === "timeout" || output.retrieval_status === "not_ready") {
+      return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: theme.secondaryText }, "Task is still running\u2026"));
+    }
+    if (!output.task) {
+      return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: theme.secondaryText }, "No task output available"));
+    }
+    if (output.task.task_type === "local_agent") {
+      const lines = output.task.result ? output.task.result.split("\n").length : 0;
+      if (!verbose) {
+        return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: theme.secondaryText }, "Read output (ctrl+o to expand)"));
+      }
+      return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, null, output.task.description, " (", lines, " lines)"), output.task.prompt ? /* @__PURE__ */ React2.createElement(Box2, { paddingLeft: 2 }, /* @__PURE__ */ React2.createElement(Text2, { color: theme.secondaryText }, output.task.prompt)) : null, output.task.result ? /* @__PURE__ */ React2.createElement(Box2, { paddingLeft: 2, marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, null, maybeTruncateVerboseToolOutput(output.task.result, {
+        maxLines: 200,
+        maxChars: 4e4
+      }).text)) : null, output.task.error ? /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1, paddingLeft: 2 }, /* @__PURE__ */ React2.createElement(Text2, { color: theme.error, bold: true }, "Error:"), /* @__PURE__ */ React2.createElement(Text2, { color: theme.error }, output.task.error)) : null);
+    }
+    const content = output.task.output?.trimEnd() ?? "";
+    if (!verbose) {
+      return /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: theme.secondaryText }, content.length > 0 ? "Read output (ctrl+o to expand)" : "(No content)"));
+    }
+    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Text2, { color: theme.secondaryText }, output.task.description), content ? /* @__PURE__ */ React2.createElement(Box2, { paddingLeft: 2, marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, null, maybeTruncateVerboseToolOutput(content, {
+      maxLines: 200,
+      maxChars: 4e4
+    }).text)) : null);
+  },
+  renderResultForAssistant(output) {
+    const parts = [];
+    parts.push(
+      `<retrieval_status>${output.retrieval_status}</retrieval_status>`
+    );
+    if (output.task) {
+      parts.push(`<task_id>${output.task.task_id}</task_id>`);
+      parts.push(`<task_type>${output.task.task_type}</task_type>`);
+      parts.push(`<status>${output.task.status}</status>`);
+      if (output.task.exitCode !== void 0 && output.task.exitCode !== null) {
+        parts.push(`<exit_code>${output.task.exitCode}</exit_code>`);
+      }
+      if (output.task.output?.trim()) {
+        parts.push(`<output>
+${output.task.output.trimEnd()}
+</output>`);
+      }
+      if (output.task.error) {
+        parts.push(`<error>${output.task.error}</error>`);
+      }
+    }
+    return parts.join("\n\n");
+  },
+  async validateInput(input) {
+    if (!input.task_id) {
+      return { result: false, message: "Task ID is required", errorCode: 1 };
+    }
+    const task = buildTaskSummary(input.task_id);
+    if (!task) {
+      return {
+        result: false,
+        message: `No task found with ID: ${input.task_id}`,
+        errorCode: 2
+      };
+    }
+    return { result: true };
+  },
+  async *call(input, context) {
+    const normalized = normalizeTaskOutputInput(input);
+    const taskId = normalized.task_id;
+    const block = normalized.block;
+    const timeoutMs = normalized.timeout;
+    const initial = buildTaskSummary(taskId);
+    if (!initial) {
+      throw new Error(`No task found with ID: ${taskId}`);
+    }
+    if (!block) {
+      const isDone = initial.status !== "running" && initial.status !== "pending";
+      const out2 = {
+        retrieval_status: isDone ? "success" : "not_ready",
+        task: initial
+      };
+      yield {
+        type: "result",
+        data: out2,
+        resultForAssistant: this.renderResultForAssistant(out2)
+      };
+      return;
+    }
+    yield {
+      type: "progress",
+      content: createAssistantMessage(
+        `<tool-progress>${initial.description ? `  ${initial.description}
+` : ""}     Waiting for task (esc to give additional instructions)</tool-progress>`
+      )
+    };
+    let finalTask = null;
+    if (initial.task_type === "local_agent") {
+      try {
+        const task = await waitForBackgroundAgentTask(
+          taskId,
+          timeoutMs,
+          context.abortController.signal
+        );
+        finalTask = task ? buildTaskSummary(taskId) : null;
+      } catch {
+        finalTask = buildTaskSummary(taskId);
+      }
+    } else {
+      finalTask = await waitForBashTaskCompletion({
+        taskId,
+        timeoutMs,
+        signal: context.abortController.signal
+      });
+    }
+    if (!finalTask) {
+      const out2 = { retrieval_status: "timeout", task: null };
+      yield {
+        type: "result",
+        data: out2,
+        resultForAssistant: this.renderResultForAssistant(out2)
+      };
+      return;
+    }
+    if (finalTask.status === "running" || finalTask.status === "pending") {
+      const out2 = { retrieval_status: "timeout", task: finalTask };
+      yield {
+        type: "result",
+        data: out2,
+        resultForAssistant: this.renderResultForAssistant(out2)
+      };
+      return;
+    }
+    const out = { retrieval_status: "success", task: finalTask };
+    yield {
+      type: "result",
+      data: out,
+      resultForAssistant: this.renderResultForAssistant(out)
+    };
+  }
+};
+
+// src/tools/mcp/ListMcpResourcesTool/ListMcpResourcesTool.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import React3 from "react";
+import { z as z3 } from "zod";
+import { ListResourcesResultSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/mcp/ListMcpResourcesTool/prompt.ts
+var TOOL_NAME = "ListMcpResourcesTool";
+var DESCRIPTION2 = `Lists available resources from configured MCP servers.
+Each resource object includes a 'server' field indicating which server it's from.
+
+Usage examples:
+- List all resources from all servers: \`listMcpResources\`
+- List resources from a specific server: \`listMcpResources({ server: "myserver" })\``;
+var PROMPT2 = `List available resources from configured MCP servers.
+Each returned resource will include all standard MCP resource fields plus a 'server' field 
+indicating which server the resource belongs to.
+
+Parameters:
+- server (optional): The name of a specific MCP server to get resources from. If not provided,
+  resources from all servers will be returned.`;
+
+// src/tools/mcp/ListMcpResourcesTool/ListMcpResourcesTool.tsx
+var inputSchema3 = z3.strictObject({
+  server: z3.string().optional().describe("Optional server name to filter resources by")
+});
+var ListMcpResourcesTool = {
+  name: TOOL_NAME,
+  async description() {
+    return DESCRIPTION2;
+  },
+  async prompt() {
+    return PROMPT2;
+  },
+  inputSchema: inputSchema3,
+  userFacingName() {
+    return "listMcpResources";
+  },
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  async validateInput({ server }, context) {
+    if (!server) return { result: true };
+    const clients = context?.options?.mcpClients ?? await getClients();
+    const found = clients.some((c) => c.name === server);
+    if (!found) {
+      return {
+        result: false,
+        message: `Server "${server}" not found. Available servers: ${clients.map((c) => c.name).join(", ")}`,
+        errorCode: 1
+      };
+    }
+    return { result: true };
+  },
+  renderToolUseMessage({ server }) {
+    return server ? `List MCP resources from server "${server}"` : "List all MCP resources";
+  },
+  renderToolUseRejectedMessage() {
+    return /* @__PURE__ */ React3.createElement(FallbackToolUseRejectedMessage, null);
+  },
+  renderToolResultMessage(output) {
+    return /* @__PURE__ */ React3.createElement(Box3, { justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "row" }, /* @__PURE__ */ React3.createElement(Text3, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React3.createElement(Text3, { bold: true }, output.length), /* @__PURE__ */ React3.createElement(Text3, null, " resources")), /* @__PURE__ */ React3.createElement(Cost, { costUSD: 0, durationMs: 0, debug: false }));
+  },
+  renderResultForAssistant(output) {
+    return JSON.stringify(output);
+  },
+  async *call({ server }, context) {
+    const clients = context.options?.mcpClients ?? await getClients();
+    const selected = server ? clients.filter((c) => c.name === server) : clients;
+    if (server && selected.length === 0) {
+      throw new Error(
+        `Server "${server}" not found. Available servers: ${clients.map((c) => c.name).join(", ")}`
+      );
+    }
+    const resources = [];
+    for (const wrapped of selected) {
+      if (wrapped.type !== "connected") continue;
+      try {
+        let capabilities = wrapped.capabilities ?? null;
+        if (!capabilities) {
+          try {
+            capabilities = wrapped.client.getServerCapabilities();
+          } catch {
+            capabilities = null;
+          }
+        }
+        if (!capabilities?.resources) continue;
+        const result = await wrapped.client.request(
+          { method: "resources/list" },
+          ListResourcesResultSchema
+        );
+        if (!result.resources) continue;
+        resources.push(
+          ...result.resources.map((r) => ({
+            ...r,
+            server: wrapped.name
+          }))
+        );
+      } catch {
+      }
+    }
+    yield {
+      type: "result",
+      data: resources,
+      resultForAssistant: this.renderResultForAssistant(resources)
+    };
+  }
+};
+
+// src/tools/search/LspTool/LspTool.tsx
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "fs";
+import { Box as Box4, Text as Text4 } from "ink";
+import { createRequire } from "node:module";
+import { extname, join as join2, relative } from "path";
+import React4 from "react";
+import { pathToFileURL } from "url";
+import { z as z4 } from "zod";
+
+// src/tools/search/LspTool/prompt.ts
+var TOOL_NAME_FOR_PROMPT2 = "LSP";
+var PROMPT3 = `Interact with Language Server Protocol (LSP) servers to get code intelligence features.
+
+Supported operations:
+- goToDefinition: Find where a symbol is defined
+- findReferences: Find all references to a symbol
+- hover: Get hover information (documentation, type info) for a symbol
+- documentSymbol: Get all symbols (functions, classes, variables) in a document
+- workspaceSymbol: Search for symbols across the entire workspace
+- goToImplementation: Find implementations of an interface or abstract method
+- prepareCallHierarchy: Get call hierarchy item at a position (functions/methods)
+- incomingCalls: Find all functions/methods that call the function at a position
+- outgoingCalls: Find all functions/methods called by the function at a position
+
+All operations require:
+- filePath: The file to operate on
+- line: The line number (1-based, as shown in editors)
+- character: The character offset (1-based, as shown in editors)
+
+Note: LSP servers must be configured for the file type. If no server is available, an error will be returned.`;
+var DESCRIPTION3 = PROMPT3;
+
+// src/tools/search/LspTool/LspTool.tsx
+var inputSchema4 = z4.strictObject({
+  operation: z4.enum([
+    "goToDefinition",
+    "findReferences",
+    "hover",
+    "documentSymbol",
+    "workspaceSymbol",
+    "goToImplementation",
+    "prepareCallHierarchy",
+    "incomingCalls",
+    "outgoingCalls"
+  ]).describe("The LSP operation to perform"),
+  filePath: z4.string().describe("The absolute or relative path to the file"),
+  line: z4.number().int().positive().describe("The line number (1-based, as shown in editors)"),
+  character: z4.number().int().positive().describe("The character offset (1-based, as shown in editors)")
+});
+var outputSchema = z4.object({
+  operation: z4.enum([
+    "goToDefinition",
+    "findReferences",
+    "hover",
+    "documentSymbol",
+    "workspaceSymbol",
+    "goToImplementation",
+    "prepareCallHierarchy",
+    "incomingCalls",
+    "outgoingCalls"
+  ]).describe("The LSP operation that was performed"),
+  result: z4.string().describe("The formatted result of the LSP operation"),
+  filePath: z4.string().describe("The file path the operation was performed on"),
+  resultCount: z4.number().int().nonnegative().optional().describe("Number of results (definitions, references, symbols)"),
+  fileCount: z4.number().int().nonnegative().optional().describe("Number of files containing results")
+});
+var OPERATION_LABELS = {
+  goToDefinition: { singular: "definition", plural: "definitions" },
+  findReferences: { singular: "reference", plural: "references" },
+  documentSymbol: { singular: "symbol", plural: "symbols" },
+  workspaceSymbol: { singular: "symbol", plural: "symbols" },
+  hover: { singular: "hover info", plural: "hover info", special: "available" },
+  goToImplementation: { singular: "implementation", plural: "implementations" },
+  prepareCallHierarchy: { singular: "call item", plural: "call items" },
+  incomingCalls: { singular: "caller", plural: "callers" },
+  outgoingCalls: { singular: "callee", plural: "callees" }
+};
+function extractSymbolAtPosition(lines, zeroBasedLine, zeroBasedCharacter) {
+  try {
+    if (zeroBasedLine < 0 || zeroBasedLine >= lines.length) return null;
+    const line = lines[zeroBasedLine];
+    if (zeroBasedCharacter < 0 || zeroBasedCharacter >= line.length) return null;
+    const tokenRe = /[\w$'!]+|[+\-*/%&|^~<>=]+/g;
+    let match;
+    while ((match = tokenRe.exec(line)) !== null) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (zeroBasedCharacter >= start && zeroBasedCharacter < end) {
+        const token = match[0];
+        return token.length > 30 ? `${token.slice(0, 27)}...` : token;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function toProjectRelativeIfPossible(filePath) {
+  const cwd = getCwd();
+  try {
+    const rel = relative(cwd, filePath);
+    if (!rel || rel === "") return filePath;
+    if (rel.startsWith("..")) return filePath;
+    return rel;
+  } catch {
+    return filePath;
+  }
+}
+function formatLocation(fileName, line0, character0) {
+  return `${toProjectRelativeIfPossible(fileName)}:${line0 + 1}:${character0 + 1}`;
+}
+function formatGoToDefinitionResult(locations) {
+  if (!locations || locations.length === 0) {
+    return {
+      formatted: "No definition found. This may occur if the cursor is not on a symbol, or if the definition is in an external library not indexed by the LSP server.",
+      resultCount: 0,
+      fileCount: 0
+    };
+  }
+  const fileCount = new Set(locations.map((l) => l.fileName)).size;
+  if (locations.length === 1) {
+    const loc = locations[0];
+    return {
+      formatted: `Defined in ${formatLocation(loc.fileName, loc.line0, loc.character0)}`,
+      resultCount: 1,
+      fileCount
+    };
+  }
+  return {
+    formatted: `Found ${locations.length} definitions:
+${locations.map(
+      (loc) => `  ${formatLocation(loc.fileName, loc.line0, loc.character0)}`
+    ).join("\n")}`,
+    resultCount: locations.length,
+    fileCount
+  };
+}
+function groupLocationsByFile(items) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = toProjectRelativeIfPossible(item.fileName);
+    const existing = grouped.get(key);
+    if (existing) existing.push(item);
+    else grouped.set(key, [item]);
+  }
+  return grouped;
+}
+function formatFindReferencesResult(references) {
+  if (!references || references.length === 0) {
+    return {
+      formatted: "No references found. This may occur if the symbol has no usages, or if the LSP server has not fully indexed the workspace.",
+      resultCount: 0,
+      fileCount: 0
+    };
+  }
+  if (references.length === 1) {
+    const ref = references[0];
+    return {
+      formatted: `Found 1 reference:
+  ${formatLocation(ref.fileName, ref.line0, ref.character0)}`,
+      resultCount: 1,
+      fileCount: 1
+    };
+  }
+  const grouped = groupLocationsByFile(references);
+  const lines = [
+    `Found ${references.length} references across ${grouped.size} files:`
+  ];
+  for (const [file, refs] of grouped) {
+    lines.push(`
+${file}:`);
+    for (const ref of refs) {
+      lines.push(`  Line ${ref.line0 + 1}:${ref.character0 + 1}`);
+    }
+  }
+  return {
+    formatted: lines.join("\n"),
+    resultCount: references.length,
+    fileCount: grouped.size
+  };
+}
+function formatHoverResult(hoverText, line0, character0) {
+  if (!hoverText || hoverText.trim() === "") {
+    return {
+      formatted: "No hover information available. This may occur if the cursor is not on a symbol, or if the LSP server has not fully indexed the file.",
+      resultCount: 0,
+      fileCount: 0
+    };
+  }
+  return {
+    formatted: `Hover info at ${line0 + 1}:${character0 + 1}:
+
+${hoverText}`,
+    resultCount: 1,
+    fileCount: 1
+  };
+}
+function formatDocumentSymbolsResult(lines, symbolCount) {
+  if (symbolCount === 0) {
+    return {
+      formatted: "No symbols found in document. This may occur if the file is empty, not supported by the LSP server, or if the server has not fully indexed the file.",
+      resultCount: 0,
+      fileCount: 0
+    };
+  }
+  return {
+    formatted: ["Document symbols:", ...lines].join("\n"),
+    resultCount: symbolCount,
+    fileCount: 1
+  };
+}
+var cachedTypeScript = null;
+function tryLoadTypeScriptModule(projectCwd) {
+  if (cachedTypeScript?.cwd === projectCwd) return cachedTypeScript.module;
+  try {
+    const requireFromCwd = createRequire(
+      pathToFileURL(join2(projectCwd, "__kode_lsp__.js"))
+    );
+    const mod = requireFromCwd("typescript");
+    cachedTypeScript = { cwd: projectCwd, module: mod };
+    return mod;
+  } catch {
+    cachedTypeScript = { cwd: projectCwd, module: null };
+    return null;
+  }
+}
+var projectCache = /* @__PURE__ */ new Map();
+function getOrCreateTsProject(projectCwd) {
+  const ts = tryLoadTypeScriptModule(projectCwd);
+  if (!ts) return null;
+  const existing = projectCache.get(projectCwd);
+  if (existing) return existing;
+  let compilerOptions = {
+    allowJs: true,
+    checkJs: false,
+    jsx: ts.JsxEmit.ReactJSX,
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.NodeNext
+  };
+  let rootFileNames = [];
+  try {
+    const configPath = ts.findConfigFile(
+      projectCwd,
+      ts.sys.fileExists,
+      "tsconfig.json"
+    );
+    if (configPath) {
+      const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+      if (!configFile.error) {
+        const parsed = ts.parseJsonConfigFileContent(
+          configFile.config,
+          ts.sys,
+          projectCwd
+        );
+        compilerOptions = { ...compilerOptions, ...parsed.options };
+        rootFileNames = parsed.fileNames;
+      }
+    }
+  } catch {
+  }
+  const rootFiles = new Set(rootFileNames);
+  const versions = /* @__PURE__ */ new Map();
+  const host = {
+    getCompilationSettings: () => compilerOptions,
+    getScriptFileNames: () => Array.from(rootFiles),
+    getScriptVersion: (fileName) => {
+      try {
+        const stat = statSync(fileName);
+        const version = String(stat.mtimeMs ?? Date.now());
+        versions.set(fileName, version);
+        return version;
+      } catch {
+        return versions.get(fileName) ?? "0";
+      }
+    },
+    getScriptSnapshot: (fileName) => {
+      try {
+        if (!ts.sys.fileExists(fileName)) return void 0;
+        const content = ts.sys.readFile(fileName);
+        if (content === void 0) return void 0;
+        const stat = statSync(fileName);
+        versions.set(fileName, String(stat.mtimeMs ?? Date.now()));
+        return ts.ScriptSnapshot.fromString(content);
+      } catch {
+        return void 0;
+      }
+    },
+    getCurrentDirectory: () => projectCwd,
+    getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
+    fileExists: ts.sys.fileExists,
+    readFile: ts.sys.readFile,
+    readDirectory: ts.sys.readDirectory,
+    directoryExists: ts.sys.directoryExists,
+    getDirectories: ts.sys.getDirectories,
+    useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames,
+    getCanonicalFileName: (fileName) => ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
+    getNewLine: () => ts.sys.newLine
+  };
+  const languageService = ts.createLanguageService(
+    host,
+    ts.createDocumentRegistry()
+  );
+  const state = {
+    ts,
+    cwd: projectCwd,
+    rootFiles,
+    compilerOptions,
+    languageService,
+    versions
+  };
+  projectCache.set(projectCwd, state);
+  return state;
+}
+function isFileTypeSupportedByTypescriptBackend(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return ext === ".ts" || ext === ".tsx" || ext === ".js" || ext === ".jsx" || ext === ".mts" || ext === ".cts" || ext === ".mjs" || ext === ".cjs";
+}
+function summarizeToolResult(operation, resultCount, fileCount) {
+  const label = OPERATION_LABELS[operation] ?? {
+    singular: "result",
+    plural: "results"
+  };
+  const noun = resultCount === 1 ? label.singular : label.plural;
+  if (operation === "hover" && resultCount > 0 && label.special) {
+    return /* @__PURE__ */ React4.createElement(Text4, null, "Hover info ", label.special);
+  }
+  return /* @__PURE__ */ React4.createElement(Text4, null, "Found ", /* @__PURE__ */ React4.createElement(Text4, { bold: true }, resultCount), " ", noun, fileCount > 1 ? /* @__PURE__ */ React4.createElement(React4.Fragment, null, " ", "across ", /* @__PURE__ */ React4.createElement(Text4, { bold: true }, fileCount), " files") : null);
+}
+var LspTool = {
+  name: TOOL_NAME_FOR_PROMPT2,
+  async description() {
+    return DESCRIPTION3;
+  },
+  async prompt() {
+    return PROMPT3;
+  },
+  inputSchema: inputSchema4,
+  userFacingName() {
+    return "LSP";
+  },
+  async isEnabled() {
+    return tryLoadTypeScriptModule(getCwd()) !== null;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  needsPermissions({ filePath }) {
+    const abs = getAbsolutePath(filePath) ?? filePath;
+    return !hasReadPermission(abs || getCwd());
+  },
+  async validateInput(input) {
+    const parsed = inputSchema4.safeParse(input);
+    if (!parsed.success) {
+      return {
+        result: false,
+        message: `Invalid input: ${parsed.error.message}`,
+        errorCode: 3
+      };
+    }
+    const absPath = getAbsolutePath(input.filePath) ?? input.filePath;
+    if (!existsSync2(absPath)) {
+      return {
+        result: false,
+        message: `File does not exist: ${input.filePath}`,
+        errorCode: 1
+      };
+    }
+    try {
+      if (!statSync(absPath).isFile()) {
+        return {
+          result: false,
+          message: `Path is not a file: ${input.filePath}`,
+          errorCode: 2
+        };
+      }
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      return {
+        result: false,
+        message: `Cannot access file: ${input.filePath}. ${e.message}`,
+        errorCode: 4
+      };
+    }
+    return { result: true };
+  },
+  renderToolUseMessage(input, { verbose }) {
+    const abs = getAbsolutePath(input.filePath) ?? input.filePath;
+    const filePathForDisplay = verbose ? abs : toProjectRelativeIfPossible(abs);
+    const parts = [];
+    if ((input.operation === "goToDefinition" || input.operation === "findReferences" || input.operation === "hover" || input.operation === "goToImplementation") && input.filePath && input.line !== void 0 && input.character !== void 0) {
+      try {
+        const content = readFileSync2(abs, "utf8");
+        const symbol = extractSymbolAtPosition(
+          content.split("\n"),
+          input.line - 1,
+          input.character - 1
+        );
+        if (symbol) {
+          parts.push(`operation: "${input.operation}"`);
+          parts.push(`symbol: "${symbol}"`);
+          parts.push(`in: "${filePathForDisplay}"`);
+          return parts.join(", ");
+        }
+      } catch {
+      }
+      parts.push(`operation: "${input.operation}"`);
+      parts.push(`file: "${filePathForDisplay}"`);
+      parts.push(`position: ${input.line}:${input.character}`);
+      return parts.join(", ");
+    }
+    parts.push(`operation: "${input.operation}"`);
+    if (input.filePath) parts.push(`file: "${filePathForDisplay}"`);
+    return parts.join(", ");
+  },
+  renderToolUseRejectedMessage() {
+    return /* @__PURE__ */ React4.createElement(FallbackToolUseRejectedMessage, null);
+  },
+  renderToolResultMessage(output, { verbose }) {
+    if (output.resultCount !== void 0 && output.fileCount !== void 0) {
+      const display = verbose ? maybeTruncateVerboseToolOutput(output.result, {
+        maxLines: 120,
+        maxChars: 2e4
+      }) : null;
+      return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "row" }, /* @__PURE__ */ React4.createElement(Text4, null, "\xA0\xA0\u23BF \xA0"), summarizeToolResult(
+        output.operation,
+        output.resultCount,
+        output.fileCount
+      )), display ? /* @__PURE__ */ React4.createElement(Box4, { marginLeft: 5 }, /* @__PURE__ */ React4.createElement(Text4, null, display.text)) : null);
+    }
+    return /* @__PURE__ */ React4.createElement(Box4, { justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "row" }, /* @__PURE__ */ React4.createElement(Text4, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React4.createElement(Text4, null, output.result)));
+  },
+  renderResultForAssistant(output) {
+    return output.result;
+  },
+  async *call(input, _context) {
+    const absPath = getAbsolutePath(input.filePath) ?? input.filePath;
+    if (!isFileTypeSupportedByTypescriptBackend(absPath)) {
+      const ext = extname(absPath);
+      const out = {
+        operation: input.operation,
+        result: `No LSP server available for file type: ${ext}`,
+        filePath: input.filePath,
+        resultCount: 0,
+        fileCount: 0
+      };
+      yield { type: "result", data: out, resultForAssistant: out.result };
+      return;
+    }
+    const project = getOrCreateTsProject(getCwd());
+    if (!project) {
+      const out = {
+        operation: input.operation,
+        result: "LSP server manager not initialized. This may indicate a startup issue.",
+        filePath: input.filePath,
+        resultCount: 0,
+        fileCount: 0
+      };
+      yield { type: "result", data: out, resultForAssistant: out.result };
+      return;
+    }
+    project.rootFiles.add(absPath);
+    const ts = project.ts;
+    const service = project.languageService;
+    const program = service.getProgram?.();
+    if (!program) {
+      const out = {
+        operation: input.operation,
+        result: `Error performing ${input.operation}: TypeScript program not available`,
+        filePath: input.filePath,
+        resultCount: 0,
+        fileCount: 0
+      };
+      yield { type: "result", data: out, resultForAssistant: out.result };
+      return;
+    }
+    const sourceFile = program.getSourceFile(absPath);
+    if (!sourceFile) {
+      const out = {
+        operation: input.operation,
+        result: `Error performing ${input.operation}: File is not part of the TypeScript program`,
+        filePath: input.filePath,
+        resultCount: 0,
+        fileCount: 0
+      };
+      yield { type: "result", data: out, resultForAssistant: out.result };
+      return;
+    }
+    const pos = ts.getPositionOfLineAndCharacter(
+      sourceFile,
+      input.line - 1,
+      input.character - 1
+    );
+    try {
+      let formatted;
+      let resultCount = 0;
+      let fileCount = 0;
+      switch (input.operation) {
+        case "goToDefinition": {
+          const defs = service.getDefinitionAtPosition?.(absPath, pos) ?? [];
+          const locations = defs.map((d) => {
+            const defSourceFile = program.getSourceFile(d.fileName);
+            if (!defSourceFile) return null;
+            const lc = ts.getLineAndCharacterOfPosition(
+              defSourceFile,
+              d.textSpan.start
+            );
+            return {
+              fileName: d.fileName,
+              line0: lc.line,
+              character0: lc.character
+            };
+          }).filter(Boolean);
+          const res = formatGoToDefinitionResult(locations);
+          formatted = res.formatted;
+          resultCount = res.resultCount;
+          fileCount = res.fileCount;
+          break;
+        }
+        case "goToImplementation": {
+          const impls = service.getImplementationAtPosition?.(absPath, pos) ?? [];
+          const locations = impls.map((d) => {
+            const defSourceFile = program.getSourceFile(d.fileName);
+            if (!defSourceFile) return null;
+            const lc = ts.getLineAndCharacterOfPosition(
+              defSourceFile,
+              d.textSpan.start
+            );
+            return {
+              fileName: d.fileName,
+              line0: lc.line,
+              character0: lc.character
+            };
+          }).filter(Boolean);
+          const res = formatGoToDefinitionResult(locations);
+          formatted = res.formatted;
+          resultCount = res.resultCount;
+          fileCount = res.fileCount;
+          break;
+        }
+        case "findReferences": {
+          const referencedSymbols = service.findReferences?.(absPath, pos) ?? [];
+          const refs = [];
+          for (const sym of referencedSymbols) {
+            for (const ref of sym.references ?? []) {
+              const refSource = program.getSourceFile(ref.fileName);
+              if (!refSource) continue;
+              const lc = ts.getLineAndCharacterOfPosition(
+                refSource,
+                ref.textSpan.start
+              );
+              refs.push({
+                fileName: ref.fileName,
+                line0: lc.line,
+                character0: lc.character
+              });
+            }
+          }
+          const res = formatFindReferencesResult(refs);
+          formatted = res.formatted;
+          resultCount = res.resultCount;
+          fileCount = res.fileCount;
+          break;
+        }
+        case "hover": {
+          const info = service.getQuickInfoAtPosition?.(absPath, pos);
+          let text = null;
+          let hoverLine0 = input.line - 1;
+          let hoverCharacter0 = input.character - 1;
+          if (info) {
+            const parts = [];
+            const signature = ts.displayPartsToString(info.displayParts ?? []);
+            if (signature) parts.push(signature);
+            const doc = ts.displayPartsToString(info.documentation ?? []);
+            if (doc) parts.push(doc);
+            if (info.tags && info.tags.length > 0) {
+              for (const tag of info.tags) {
+                const tagText = ts.displayPartsToString(tag.text ?? []);
+                parts.push(`@${tag.name}${tagText ? ` ${tagText}` : ""}`);
+              }
+            }
+            text = parts.filter(Boolean).join("\n\n");
+            const lc = ts.getLineAndCharacterOfPosition(
+              sourceFile,
+              info.textSpan.start
+            );
+            hoverLine0 = lc.line;
+            hoverCharacter0 = lc.character;
+          }
+          const res = formatHoverResult(text, hoverLine0, hoverCharacter0);
+          formatted = res.formatted;
+          resultCount = res.resultCount;
+          fileCount = res.fileCount;
+          break;
+        }
+        case "documentSymbol": {
+          const tree = service.getNavigationTree?.(absPath);
+          const lines = [];
+          let count = 0;
+          const kindLabel = (kind) => {
+            const m = {
+              class: "Class",
+              interface: "Interface",
+              enum: "Enum",
+              function: "Function",
+              method: "Method",
+              property: "Property",
+              var: "Variable",
+              let: "Variable",
+              const: "Constant",
+              module: "Module",
+              alias: "Alias",
+              type: "Type"
+            };
+            return m[kind] ?? (kind ? kind[0].toUpperCase() + kind.slice(1) : "Unknown");
+          };
+          const walk = (node, depth) => {
+            const children = node?.childItems ?? [];
+            for (const child of children) {
+              const span = child.spans?.[0];
+              if (!span) continue;
+              const lc = ts.getLineAndCharacterOfPosition(
+                sourceFile,
+                span.start
+              );
+              const indent = "  ".repeat(depth);
+              const label = kindLabel(child.kind);
+              const detail = child.kindModifiers ? ` ${child.kindModifiers}` : "";
+              lines.push(
+                `${indent}${child.text} (${label})${detail} - Line ${lc.line + 1}`
+              );
+              count += 1;
+              if (child.childItems && child.childItems.length > 0) {
+                walk(child, depth + 1);
+              }
+            }
+          };
+          walk(tree, 0);
+          const res = formatDocumentSymbolsResult(lines, count);
+          formatted = res.formatted;
+          resultCount = res.resultCount;
+          fileCount = res.fileCount;
+          break;
+        }
+        case "workspaceSymbol": {
+          const items = service.getNavigateToItems?.("", 100, void 0, true, true) ?? [];
+          if (!items || items.length === 0) {
+            formatted = "No symbols found in workspace. This may occur if the workspace is empty, or if the LSP server has not finished indexing the project.";
+            resultCount = 0;
+            fileCount = 0;
+            break;
+          }
+          const lines = [
+            `Found ${items.length} symbol${items.length === 1 ? "" : "s"} in workspace:`
+          ];
+          const grouped = groupLocationsByFile(
+            items.map((it) => ({
+              fileName: it.fileName,
+              item: it
+            }))
+          );
+          for (const [file, itemsInFile] of grouped) {
+            lines.push(`
+${file}:`);
+            for (const wrapper of itemsInFile) {
+              const it = wrapper.item;
+              const sf = program.getSourceFile(it.fileName);
+              if (!sf) continue;
+              const span = it.textSpan;
+              const lc = span ? ts.getLineAndCharacterOfPosition(sf, span.start) : { line: 0, character: 0 };
+              const label = it.kind ? String(it.kind)[0].toUpperCase() + String(it.kind).slice(1) : "Symbol";
+              let line = `  ${it.name} (${label}) - Line ${lc.line + 1}`;
+              if (it.containerName) line += ` in ${it.containerName}`;
+              lines.push(line);
+            }
+          }
+          formatted = lines.join("\n");
+          resultCount = items.length;
+          fileCount = grouped.size;
+          break;
+        }
+        case "prepareCallHierarchy":
+        case "incomingCalls":
+        case "outgoingCalls": {
+          const opLabel = input.operation;
+          formatted = `Error performing ${opLabel}: Call hierarchy is not supported by the TypeScript backend`;
+          resultCount = 0;
+          fileCount = 0;
+          break;
+        }
+        default: {
+          formatted = `Error performing ${input.operation}: Unsupported operation`;
+          resultCount = 0;
+          fileCount = 0;
+        }
+      }
+      const out = {
+        operation: input.operation,
+        result: formatted,
+        filePath: input.filePath,
+        resultCount,
+        fileCount
+      };
+      yield { type: "result", data: out, resultForAssistant: out.result };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const out = {
+        operation: input.operation,
+        result: `Error performing ${input.operation}: ${message}`,
+        filePath: input.filePath
+      };
+      yield { type: "result", data: out, resultForAssistant: out.result };
+    }
+  }
+};
+
+// src/tools/mcp/ReadMcpResourceTool/ReadMcpResourceTool.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import React5 from "react";
+import { z as z5 } from "zod";
+import { ReadResourceResultSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/mcp/ReadMcpResourceTool/prompt.ts
+var TOOL_NAME2 = "ReadMcpResourceTool";
+var DESCRIPTION4 = `Reads a specific resource from an MCP server.
+- server: The name of the MCP server to read from
+- uri: The URI of the resource to read
+
+Usage examples:
+- Read a resource from a server: \`readMcpResource({ server: "myserver", uri: "my-resource-uri" })\``;
+var PROMPT4 = `Reads a specific resource from an MCP server, identified by server name and resource URI.
+
+Parameters:
+- server (required): The name of the MCP server from which to read the resource
+- uri (required): The URI of the resource to read`;
+
+// src/tools/mcp/ReadMcpResourceTool/ReadMcpResourceTool.tsx
+var inputSchema5 = z5.strictObject({
+  server: z5.string().describe("The MCP server name"),
+  uri: z5.string().describe("The resource URI to read")
+});
+var ReadMcpResourceTool = {
+  name: TOOL_NAME2,
+  async description() {
+    return DESCRIPTION4;
+  },
+  async prompt() {
+    return PROMPT4;
+  },
+  inputSchema: inputSchema5,
+  userFacingName() {
+    return "readMcpResource";
+  },
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  async validateInput({ server }, context) {
+    const clients = context?.options?.mcpClients ?? await getClients();
+    const match = clients.find((c) => c.name === server);
+    if (!match) {
+      return {
+        result: false,
+        message: `Server "${server}" not found. Available servers: ${clients.map((c) => c.name).join(", ")}`,
+        errorCode: 1
+      };
+    }
+    if (match.type !== "connected") {
+      return {
+        result: false,
+        message: `Server "${server}" is not connected`,
+        errorCode: 2
+      };
+    }
+    let capabilities = match.capabilities ?? null;
+    if (!capabilities) {
+      try {
+        capabilities = match.client.getServerCapabilities();
+      } catch {
+        capabilities = null;
+      }
+    }
+    if (!capabilities?.resources) {
+      return {
+        result: false,
+        message: `Server "${server}" does not support resources`,
+        errorCode: 3
+      };
+    }
+    return { result: true };
+  },
+  renderToolUseMessage({ server, uri }) {
+    if (!server || !uri) return null;
+    return `Read resource "${uri}" from server "${server}"`;
+  },
+  renderToolUseRejectedMessage() {
+    return /* @__PURE__ */ React5.createElement(FallbackToolUseRejectedMessage, null);
+  },
+  renderToolResultMessage(output) {
+    const count = output.contents?.length ?? 0;
+    return /* @__PURE__ */ React5.createElement(Box5, { justifyContent: "space-between", width: "100%" }, /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "row" }, /* @__PURE__ */ React5.createElement(Text5, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React5.createElement(Text5, { bold: true }, "Read MCP resource"), /* @__PURE__ */ React5.createElement(Text5, null, count ? ` (${count} part${count === 1 ? "" : "s"})` : "")), /* @__PURE__ */ React5.createElement(Cost, { costUSD: 0, durationMs: 0, debug: false }));
+  },
+  renderResultForAssistant(output) {
+    return JSON.stringify(output);
+  },
+  async *call({ server, uri }, context) {
+    const clients = context.options?.mcpClients ?? await getClients();
+    const match = clients.find((c) => c.name === server);
+    if (!match) {
+      throw new Error(
+        `Server "${server}" not found. Available servers: ${clients.map((c) => c.name).join(", ")}`
+      );
+    }
+    if (match.type !== "connected") {
+      throw new Error(`Server "${server}" is not connected`);
+    }
+    let capabilities = match.capabilities ?? null;
+    if (!capabilities) {
+      try {
+        capabilities = match.client.getServerCapabilities();
+      } catch {
+        capabilities = null;
+      }
+    }
+    if (!capabilities?.resources) {
+      throw new Error(`Server "${server}" does not support resources`);
+    }
+    const result = await match.client.request(
+      { method: "resources/read", params: { uri } },
+      ReadResourceResultSchema
+    );
+    yield {
+      type: "result",
+      data: result,
+      resultForAssistant: this.renderResultForAssistant(result)
+    };
+  }
+};
+
+// src/tools/agent/TaskTool/TaskTool.tsx
+import { last, memoize } from "lodash-es";
+import React6 from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+import { z as z6 } from "zod";
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+
+// src/utils/agent/transcripts.ts
+var transcripts = /* @__PURE__ */ new Map();
+function saveAgentTranscript(agentId, messages) {
+  transcripts.set(agentId, messages);
+}
+function getAgentTranscript(agentId) {
+  return transcripts.get(agentId);
+}
+
+// src/tools/agent/TaskTool/prompt.ts
+var SUBAGENT_DISALLOWED_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "Task",
+  "TaskOutput",
+  "KillShell",
+  "EnterPlanMode",
+  "ExitPlanMode",
+  "AskUserQuestion"
+]);
+async function getTaskTools(safeMode) {
+  return (await (!safeMode ? getTools() : getReadOnlyTools())).filter(
+    (tool) => !SUBAGENT_DISALLOWED_TOOL_NAMES.has(tool.name)
+  );
+}
+async function getPrompt(safeMode) {
+  const agents = await getActiveAgents();
+  const agentDescriptions = agents.map((agent) => {
+    const toolsStr = Array.isArray(agent.tools) ? agent.tools.join(", ") : "*";
+    return `- ${agent.agentType}: ${agent.whenToUse} (Tools: ${toolsStr})`;
+  }).join("\n");
+  return `Launch a new agent to handle complex, multi-step tasks autonomously. 
+
+Available agent types and the tools they have access to:
+${agentDescriptions}
+
+When using the Task tool, you must specify a subagent_type parameter to select which agent type to use.
+
+When to use the Agent tool:
+- When you are instructed to execute custom slash commands. Use the Agent tool with the slash command invocation as the entire prompt. The slash command can take arguments. For example: Task(description="Check the file", prompt="/check-file path/to/file.py")
+
+When NOT to use the Agent tool:
+- If you want to read a specific file path, use the ${FileReadTool.name} or ${GlobTool.name} tool instead of the Agent tool, to find the match more quickly
+- If you are searching for a specific class definition like "class Foo", use the ${GlobTool.name} tool instead, to find the match more quickly
+- If you are searching for code within a specific file or set of 2-3 files, use the ${FileReadTool.name} tool instead of the Agent tool, to find the match more quickly
+- Other tasks that are not related to the agent descriptions above
+
+Usage notes:
+1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
+2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
+4. The agent's outputs should generally be trusted
+5. Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
+6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
+
+Example usage:
+
+<example_agent_descriptions>
+"code-reviewer": use this agent after you are done writing a signficant piece of code
+"greeting-responder": use this agent when to respond to user greetings with a friendly joke
+</example_agent_description>
+
+<example>
+user: "Please write a function that checks if a number is prime"
+assistant: Sure let me write a function that checks if a number is prime
+assistant: First let me use the ${FileWriteTool.name} tool to write a function that checks if a number is prime
+assistant: I'm going to use the ${FileWriteTool.name} tool to write the following code:
+<code>
+function isPrime(n) {
+  if (n <= 1) return false
+  for (let i = 2; i * i <= n; i++) {
+    if (n % i === 0) return false
+  }
+  return true
+}
+</code>
+<commentary>
+Since a signficant piece of code was written and the task was completed, now use the code-reviewer agent to review the code
+</commentary>
+assistant: Now let me use the code-reviewer agent to review the code
+assistant: Uses the Task tool to launch the with the code-reviewer agent 
+</example>
+
+<example>
+user: "Hello"
+<commentary>
+Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
+</commentary>
+assistant: "I'm going to use the Task tool to launch the with the greeting-responder agent"
+</example>`;
+}
+
+// src/tools/agent/TaskTool/constants.ts
+var TOOL_NAME3 = "Task";
+
+// src/tools/agent/TaskTool/TaskTool.tsx
+var inputSchema6 = z6.object({
+  description: z6.string().describe("A short (3-5 word) description of the task"),
+  prompt: z6.string().describe("The task for the agent to perform"),
+  subagent_type: z6.string().describe("The type of specialized agent to use for this task"),
+  model: z6.enum(["sonnet", "opus", "haiku"]).optional().describe(
+    "Optional model to use for this agent. If not specified, inherits from parent. Prefer haiku for quick, straightforward tasks to minimize cost and latency."
+  ),
+  resume: z6.string().optional().describe(
+    "Optional agent ID to resume from. If provided, the agent will continue from the previous execution transcript."
+  ),
+  run_in_background: z6.boolean().optional().describe(
+    "Set to true to run this agent in the background. Use TaskOutput to read the output later."
+  )
+});
+function modelEnumToPointer(model) {
+  if (!model) return void 0;
+  switch (model) {
+    case "haiku":
+      return "quick";
+    case "sonnet":
+      return "task";
+    case "opus":
+      return "main";
+  }
+}
+function normalizeAgentModelName(model) {
+  if (!model) return void 0;
+  if (model === "inherit") return "inherit";
+  if (model === "haiku" || model === "sonnet" || model === "opus") {
+    return modelEnumToPointer(model);
+  }
+  return model;
+}
+function getToolNameFromSpec(spec) {
+  const trimmed = spec.trim();
+  if (!trimmed) return trimmed;
+  const match = trimmed.match(/^([^(]+)\(([^)]+)\)$/);
+  if (!match) return trimmed;
+  const toolName = match[1]?.trim();
+  const ruleContent = match[2]?.trim();
+  if (!toolName || !ruleContent) return trimmed;
+  return toolName;
+}
+function asyncLaunchMessage(agentId) {
+  const toolName = "TaskOutput";
+  return `Async agent launched successfully.
+agentId: ${agentId} (This is an internal ID for your use, do not mention it to the user. Use this ID to retrieve results with ${toolName} when the agent finishes). 
+The agent is currently working in the background. If you have other tasks you you should continue working on them now. Wait to call ${toolName} until either:
+- If you want to check on the agent's progress - call ${toolName} with block=false to get an immediate update on the agent's status
+- If you run out of things to do and the agent is still running - call ${toolName} with block=true to idle and wait for the agent's result (do not use block=true unless you completely run out of things to do as it will waste time).`;
+}
+var FORK_CONTEXT_TOOL_RESULT_TEXT = `### FORKING CONVERSATION CONTEXT ###
+### ENTERING SUB-AGENT ROUTINE ###
+Entered sub-agent context
+
+PLEASE NOTE: 
+- The messages above this point are from the main thread prior to sub-agent execution. They are provided as context only.
+- Context messages may include tool_use blocks for tools that are not available in the sub-agent context. You should only use the tools specifically provided to you in the system prompt.
+- Only complete the specific sub-agent task you have been assigned below.`;
+function normalizeAgentPermissionMode(mode) {
+  if (typeof mode !== "string") return void 0;
+  const trimmed = mode.trim();
+  if (!trimmed) return void 0;
+  if (trimmed === "delegate") return "default";
+  if (trimmed === "default" || trimmed === "acceptEdits" || trimmed === "plan" || trimmed === "bypassPermissions" || trimmed === "dontAsk") {
+    return trimmed;
+  }
+  return void 0;
+}
+function applyAgentPermissionMode(base, options) {
+  if (!base) return base;
+  if (!options.agentPermissionMode) return base;
+  if (options.agentPermissionMode === "bypassPermissions" && (options.safeMode || base.isBypassPermissionsModeAvailable !== true)) {
+    return { ...base, mode: "default" };
+  }
+  return { ...base, mode: options.agentPermissionMode };
+}
+function readJsonArrayFile(path) {
+  if (!existsSync3(path)) return null;
+  try {
+    const raw = readFileSync3(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function buildForkContextForAgent(options) {
+  const userPromptMessage = createUserMessage(options.prompt);
+  if (!options.enabled || !options.toolUseId) {
+    return {
+      forkContextMessages: [],
+      promptMessages: [userPromptMessage]
+    };
+  }
+  const mainPath = getMessagesPath(options.messageLogName, options.forkNumber, 0);
+  const mainMessages = readJsonArrayFile(mainPath);
+  if (!mainMessages || mainMessages.length === 0) {
+    return {
+      forkContextMessages: [],
+      promptMessages: [userPromptMessage]
+    };
+  }
+  let toolUseMessageIndex = -1;
+  let toolUseMessage = null;
+  let taskToolUseBlock = null;
+  for (let i = 0; i < mainMessages.length; i++) {
+    const msg = mainMessages[i];
+    if (msg?.type !== "assistant") continue;
+    const blocks = Array.isArray(msg?.message?.content) ? msg.message.content : [];
+    const match = blocks.find(
+      (b) => b && b.type === "tool_use" && b.id === options.toolUseId
+    );
+    if (!match) continue;
+    toolUseMessageIndex = i;
+    toolUseMessage = msg;
+    taskToolUseBlock = match;
+    break;
+  }
+  if (toolUseMessageIndex === -1 || !toolUseMessage || !taskToolUseBlock) {
+    return {
+      forkContextMessages: [],
+      promptMessages: [userPromptMessage]
+    };
+  }
+  const forkContextMessages = mainMessages.slice(
+    0,
+    toolUseMessageIndex
+  ) ?? [];
+  const toolUseOnlyAssistant = {
+    ...toolUseMessage,
+    uuid: randomUUID2(),
+    message: {
+      ...toolUseMessage.message,
+      content: [taskToolUseBlock]
+    }
+  };
+  const forkContextToolResult = createUserMessage(
+    [
+      {
+        type: "tool_result",
+        tool_use_id: taskToolUseBlock.id,
+        content: FORK_CONTEXT_TOOL_RESULT_TEXT
+      }
+    ],
+    {
+      data: {
+        status: "sub_agent_entered",
+        description: "Entered sub-agent context",
+        message: FORK_CONTEXT_TOOL_RESULT_TEXT
+      },
+      resultForAssistant: FORK_CONTEXT_TOOL_RESULT_TEXT
+    }
+  );
+  return {
+    forkContextMessages,
+    promptMessages: [toolUseOnlyAssistant, forkContextToolResult, userPromptMessage]
+  };
+}
+var TaskTool = {
+  name: TOOL_NAME3,
+  inputSchema: inputSchema6,
+  async description() {
+    return "Launch a new task";
+  },
+  async prompt({ safeMode }) {
+    return await getPrompt(safeMode);
+  },
+  userFacingName(input) {
+    if (input?.subagent_type && input.subagent_type !== "general-purpose") {
+      return input.subagent_type;
+    }
+    return "Task";
+  },
+  async isEnabled() {
+    return true;
+  },
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  needsPermissions() {
+    return false;
+  },
+  async validateInput(input) {
+    if (!input.description || typeof input.description !== "string") {
+      return {
+        result: false,
+        message: "Description is required and must be a string"
+      };
+    }
+    if (!input.prompt || typeof input.prompt !== "string") {
+      return {
+        result: false,
+        message: "Prompt is required and must be a string"
+      };
+    }
+    const availableTypes = await getAvailableAgentTypes();
+    if (!availableTypes.includes(input.subagent_type)) {
+      return {
+        result: false,
+        message: `Agent type '${input.subagent_type}' not found. Available agents: ${availableTypes.join(", ")}`,
+        meta: { subagent_type: input.subagent_type, availableTypes }
+      };
+    }
+    if (input.resume) {
+      const transcript = getAgentTranscript(input.resume);
+      if (!transcript) {
+        return {
+          result: false,
+          message: `No transcript found for agent ID: ${input.resume}`,
+          meta: { resume: input.resume }
+        };
+      }
+    }
+    return { result: true };
+  },
+  renderToolUseMessage({ description, prompt }) {
+    if (!description || !prompt) return "";
+    return description;
+  },
+  renderToolUseRejectedMessage() {
+    return /* @__PURE__ */ React6.createElement(FallbackToolUseRejectedMessage, null);
+  },
+  renderToolResultMessage(output, { verbose }) {
+    const theme = getTheme();
+    if (output.status === "async_launched") {
+      const hint = output.prompt ? " (down arrow \u2193 to manage \xB7 ctrl+o to expand)" : " (down arrow \u2193 to manage)";
+      return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "row" }, /* @__PURE__ */ React6.createElement(Text6, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React6.createElement(Text6, null, "Backgrounded agent", !verbose && /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, hint))), verbose && output.prompt && /* @__PURE__ */ React6.createElement(
+        Box6,
+        {
+          paddingLeft: 2,
+          borderLeftStyle: "single",
+          borderLeftColor: theme.secondaryBorder
+        },
+        /* @__PURE__ */ React6.createElement(Text6, { color: theme.secondaryText, wrap: "wrap" }, output.prompt)
+      ));
+    }
+    const summary = [
+      output.totalToolUseCount === 1 ? "1 tool use" : `${output.totalToolUseCount} tool uses`,
+      `${formatNumber(output.totalTokens)} tokens`,
+      formatDuration(output.totalDurationMs)
+    ];
+    return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column" }, verbose && output.prompt && /* @__PURE__ */ React6.createElement(
+      Box6,
+      {
+        paddingLeft: 2,
+        borderLeftStyle: "single",
+        borderLeftColor: theme.secondaryBorder
+      },
+      /* @__PURE__ */ React6.createElement(Text6, { color: theme.secondaryText, wrap: "wrap" }, maybeTruncateVerboseToolOutput(output.prompt, {
+        maxLines: 120,
+        maxChars: 2e4
+      }).text)
+    ), verbose && output.content.length > 0 && /* @__PURE__ */ React6.createElement(
+      Box6,
+      {
+        paddingLeft: 2,
+        borderLeftStyle: "single",
+        borderLeftColor: theme.secondaryBorder
+      },
+      /* @__PURE__ */ React6.createElement(Text6, { wrap: "wrap" }, maybeTruncateVerboseToolOutput(
+        output.content.map((b) => b.text).join("\n"),
+        {
+          maxLines: 200,
+          maxChars: 4e4
+        }
+      ).text)
+    ), /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "row" }, /* @__PURE__ */ React6.createElement(Text6, null, "\xA0\xA0\u23BF \xA0"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, "Done (", summary.join(" \xB7 "), ")")));
+  },
+  renderResultForAssistant(output) {
+    if (output.status === "async_launched")
+      return asyncLaunchMessage(output.agentId);
+    return output.content.map((b) => b.text).join("\n");
+  },
+  async *call(input, toolUseContext) {
+    const startTime = Date.now();
+    const {
+      abortController,
+      toolUseId,
+      options: {
+        safeMode = false,
+        forkNumber,
+        messageLogName,
+        verbose,
+        model: parentModel,
+        mcpClients
+      },
+      readFileTimestamps
+    } = toolUseContext;
+    const queryFn = typeof toolUseContext?.__testQuery === "function" ? toolUseContext.__testQuery : query;
+    const agentConfig = await getAgentByType(input.subagent_type);
+    if (!agentConfig) {
+      const available = await getAvailableAgentTypes();
+      throw Error(
+        `Agent type '${input.subagent_type}' not found. Available agents: ${available.join(", ")}`
+      );
+    }
+    const effectivePrompt = input.prompt;
+    const normalizedAgentModel = normalizeAgentModelName(agentConfig.model);
+    const defaultSubagentModel = "task";
+    const envSubagentModel = process.env.KODE_SUBAGENT_MODEL ?? process.env.CLAUDE_CODE_SUBAGENT_MODEL;
+    const modelToUse = (typeof envSubagentModel === "string" && envSubagentModel.trim() ? envSubagentModel.trim() : void 0) || modelEnumToPointer(input.model) || (normalizedAgentModel === "inherit" ? parentModel || defaultSubagentModel : normalizedAgentModel) || defaultSubagentModel;
+    const toolFilter = agentConfig.tools;
+    let tools = await getTaskTools(safeMode);
+    if (toolFilter) {
+      const isAllArray = Array.isArray(toolFilter) && toolFilter.length === 1 && toolFilter[0] === "*";
+      if (toolFilter === "*" || isAllArray) {
+      } else if (Array.isArray(toolFilter)) {
+        const allowedToolNames = new Set(
+          toolFilter.map(getToolNameFromSpec).filter(Boolean)
+        );
+        tools = tools.filter((t) => allowedToolNames.has(t.name));
+      }
+    }
+    const disallowedTools = Array.isArray(agentConfig.disallowedTools) ? agentConfig.disallowedTools : [];
+    if (disallowedTools.length > 0) {
+      const disallowedToolNames = new Set(
+        disallowedTools.map(getToolNameFromSpec).filter(Boolean)
+      );
+      tools = tools.filter((t) => !disallowedToolNames.has(t.name));
+    }
+    const agentId = input.resume || generateAgentId();
+    const baseTranscript = input.resume ? getAgentTranscript(input.resume)?.filter((m) => m.type !== "progress") ?? null : [];
+    if (input.resume && baseTranscript === null) {
+      throw Error(`No transcript found for agent ID: ${input.resume}`);
+    }
+    const { forkContextMessages, promptMessages } = buildForkContextForAgent({
+      enabled: agentConfig.forkContext === true,
+      prompt: effectivePrompt,
+      toolUseId,
+      messageLogName,
+      forkNumber
+    });
+    const transcriptMessages = [
+      ...baseTranscript || [],
+      ...promptMessages
+    ];
+    const messagesForQuery = [
+      ...forkContextMessages,
+      ...transcriptMessages
+    ];
+    const [baseSystemPrompt, context, maxThinkingTokens] = await Promise.all([
+      getAgentPrompt(),
+      getContext(),
+      getMaxThinkingTokens(messagesForQuery)
+    ]);
+    const systemPrompt = agentConfig.systemPrompt && agentConfig.systemPrompt.length > 0 ? [...baseSystemPrompt, agentConfig.systemPrompt] : baseSystemPrompt;
+    const agentPermissionMode = normalizeAgentPermissionMode(
+      agentConfig.permissionMode
+    );
+    const toolPermissionContext = applyAgentPermissionMode(
+      toolUseContext.options?.toolPermissionContext,
+      { agentPermissionMode, safeMode }
+    );
+    const queryOptions = {
+      safeMode,
+      forkNumber,
+      messageLogName,
+      tools,
+      commands: [],
+      verbose,
+      permissionMode: "dontAsk",
+      toolPermissionContext,
+      maxThinkingTokens,
+      model: modelToUse,
+      mcpClients
+    };
+    if (input.run_in_background) {
+      const bgAbortController = new AbortController();
+      const taskRecord = {
+        type: "async_agent",
+        agentId,
+        description: input.description,
+        prompt: effectivePrompt,
+        status: "running",
+        startedAt: Date.now(),
+        messages: [...transcriptMessages],
+        abortController: bgAbortController,
+        done: Promise.resolve()
+      };
+      taskRecord.done = (async () => {
+        try {
+          const bgMessages = [...messagesForQuery];
+          const bgTranscriptMessages = [...transcriptMessages];
+          for await (const msg of queryFn(
+            bgMessages,
+            systemPrompt,
+            context,
+            hasPermissionsToUseTool,
+            {
+              abortController: bgAbortController,
+              options: queryOptions,
+              messageId: getLastAssistantMessageId(bgMessages),
+              agentId,
+              readFileTimestamps,
+              setToolJSX: () => {
+              }
+            }
+          )) {
+            bgMessages.push(msg);
+            bgTranscriptMessages.push(msg);
+            taskRecord.messages = [...bgTranscriptMessages];
+            upsertBackgroundAgentTask(taskRecord);
+          }
+          const lastAssistant2 = last(
+            bgTranscriptMessages.filter((m) => m.type === "assistant")
+          );
+          const content2 = lastAssistant2?.message?.content?.filter(
+            (b) => b.type === "text"
+          );
+          taskRecord.status = "completed";
+          taskRecord.completedAt = Date.now();
+          taskRecord.resultText = (content2 || []).map((b) => b.text).join("\n");
+          taskRecord.messages = [...bgTranscriptMessages];
+          upsertBackgroundAgentTask(taskRecord);
+          saveAgentTranscript(agentId, bgTranscriptMessages);
+        } catch (e) {
+          taskRecord.status = "failed";
+          taskRecord.completedAt = Date.now();
+          taskRecord.error = e instanceof Error ? e.message : String(e);
+          upsertBackgroundAgentTask(taskRecord);
+        }
+      })();
+      upsertBackgroundAgentTask(taskRecord);
+      const output2 = {
+        status: "async_launched",
+        agentId,
+        description: input.description,
+        prompt: effectivePrompt
+      };
+      yield {
+        type: "result",
+        data: output2,
+        resultForAssistant: asyncLaunchMessage(agentId)
+      };
+      return;
+    }
+    const getSidechainNumber = memoize(
+      () => getNextAvailableLogSidechainNumber(messageLogName, forkNumber)
+    );
+    const PROGRESS_THROTTLE_MS = 200;
+    const MAX_RECENT_ACTIONS = 6;
+    let lastProgressEmitAt = 0;
+    let lastEmittedToolUseCount = 0;
+    const recentActions = [];
+    const addRecentAction = (action) => {
+      const trimmed = action.trim();
+      if (!trimmed) return;
+      recentActions.push(trimmed);
+      if (recentActions.length > MAX_RECENT_ACTIONS) {
+        recentActions.splice(0, recentActions.length - MAX_RECENT_ACTIONS);
+      }
+    };
+    const truncate = (text, maxLen) => {
+      const normalized = text.replace(/\s+/g, " ").trim();
+      if (normalized.length <= maxLen) return normalized;
+      return `${normalized.slice(0, maxLen - 1)}\u2026`;
+    };
+    const summarizeToolUse = (name, rawInput) => {
+      const input2 = rawInput && typeof rawInput === "object" ? rawInput : {};
+      switch (name) {
+        case "Read": {
+          const filePath = typeof input2.file_path === "string" && input2.file_path || typeof input2.path === "string" && input2.path || "";
+          return filePath ? `Read ${filePath}` : "Read";
+        }
+        case "Write": {
+          const filePath = typeof input2.file_path === "string" && input2.file_path || typeof input2.path === "string" && input2.path || "";
+          return filePath ? `Write ${filePath}` : "Write";
+        }
+        case "Edit":
+        case "MultiEdit": {
+          const filePath = typeof input2.file_path === "string" && input2.file_path || typeof input2.path === "string" && input2.path || "";
+          return filePath ? `${name} ${filePath}` : name;
+        }
+        case "Grep": {
+          const pattern = typeof input2.pattern === "string" ? input2.pattern : "";
+          return pattern ? `Grep ${truncate(pattern, 80)}` : "Grep";
+        }
+        case "Glob": {
+          const pattern = typeof input2.pattern === "string" && input2.pattern || typeof input2.glob === "string" && input2.glob || "";
+          return pattern ? `Glob ${truncate(pattern, 80)}` : "Glob";
+        }
+        case "Bash": {
+          const command = typeof input2.command === "string" ? input2.command : "";
+          return command ? `Bash ${truncate(command, 80)}` : "Bash";
+        }
+        case "WebFetch":
+        case "WebSearch": {
+          const url = typeof input2.url === "string" ? input2.url : "";
+          const query2 = typeof input2.query === "string" ? input2.query : "";
+          if (url) return `${name} ${truncate(url, 100)}`;
+          if (query2) return `${name} ${truncate(query2, 100)}`;
+          return name;
+        }
+        default:
+          return name;
+      }
+    };
+    const renderProgressText = (toolUseCount2) => {
+      const header = `${input.description || "Task"}\u2026 (${toolUseCount2} tool${toolUseCount2 === 1 ? "" : "s"})`;
+      if (recentActions.length === 0) return header;
+      const lines = recentActions.map((a) => `- ${a}`);
+      return [header, ...lines].join("\n");
+    };
+    yield {
+      type: "progress",
+      content: createAssistantMessage(
+        `<tool-progress>${renderProgressText(0)}</tool-progress>`
+      )
+    };
+    lastProgressEmitAt = Date.now();
+    let toolUseCount = 0;
+    for await (const message of queryFn(
+      messagesForQuery,
+      systemPrompt,
+      context,
+      hasPermissionsToUseTool,
+      {
+        abortController,
+        options: queryOptions,
+        messageId: getLastAssistantMessageId(messagesForQuery),
+        agentId,
+        readFileTimestamps,
+        setToolJSX: () => {
+        }
+      }
+    )) {
+      messagesForQuery.push(message);
+      transcriptMessages.push(message);
+      overwriteLog(
+        getMessagesPath(messageLogName, forkNumber, getSidechainNumber()),
+        transcriptMessages.filter((_) => _.type !== "progress"),
+        { conversationKey: `${messageLogName}:${forkNumber}` }
+      );
+      if (message.type === "assistant") {
+        for (const block of message.message.content) {
+          if (block.type === "tool_use" || block.type === "server_tool_use" || block.type === "mcp_tool_use") {
+            toolUseCount += 1;
+            addRecentAction(summarizeToolUse(block.name, block.input));
+          }
+        }
+      }
+      const now = Date.now();
+      const hasNewToolUses = toolUseCount > lastEmittedToolUseCount;
+      const shouldEmit = hasNewToolUses && (lastEmittedToolUseCount === 0 || now - lastProgressEmitAt >= PROGRESS_THROTTLE_MS);
+      if (shouldEmit) {
+        yield {
+          type: "progress",
+          content: createAssistantMessage(
+            `<tool-progress>${renderProgressText(toolUseCount)}</tool-progress>`
+          )
+        };
+        lastEmittedToolUseCount = toolUseCount;
+        lastProgressEmitAt = now;
+      }
+    }
+    const lastAssistant = last(
+      transcriptMessages.filter((m) => m.type === "assistant")
+    );
+    if (!lastAssistant || lastAssistant.type !== "assistant") {
+      throw Error("No assistant messages found");
+    }
+    const content = lastAssistant.message.content.filter(
+      (b) => b.type === "text"
+    );
+    saveAgentTranscript(agentId, transcriptMessages);
+    const totalDurationMs = Date.now() - startTime;
+    const totalTokens = countTokens(transcriptMessages);
+    const usage = lastAssistant.message.usage;
+    const output = {
+      status: "completed",
+      agentId,
+      prompt: effectivePrompt,
+      content,
+      totalToolUseCount: toolUseCount,
+      totalDurationMs,
+      totalTokens,
+      usage
+    };
+    const agentIdBlock = {
+      type: "text",
+      text: `agentId: ${agentId} (for resuming to continue this agent's work if needed)`,
+      citations: []
+    };
+    yield {
+      type: "result",
+      data: output,
+      resultForAssistant: [...content, agentIdBlock]
+    };
+  }
+};
+
+// src/tools/index.ts
+var getAllTools = () => [
+  TaskTool,
+  AskExpertModelTool,
+  BashTool,
+  TaskOutputTool,
+  KillShellTool,
+  GlobTool,
+  GrepTool,
+  LspTool,
+  FileReadTool,
+  FileEditTool,
+  FileWriteTool,
+  NotebookEditTool,
+  TodoWriteTool,
+  WebSearchTool,
+  WebFetchTool,
+  AskUserQuestionTool,
+  EnterPlanModeTool,
+  ExitPlanModeTool,
+  SlashCommandTool,
+  SkillTool,
+  ListMcpResourcesTool,
+  ReadMcpResourceTool,
+  MCPTool
+];
+var getTools = memoize2(
+  async (_includeOptional) => {
+    const tools = [...getAllTools(), ...await getMCPTools()];
+    const isEnabled = await Promise.all(tools.map((tool) => tool.isEnabled()));
+    return tools.filter((_, i) => isEnabled[i]);
+  }
+);
+var getReadOnlyTools = memoize2(async () => {
+  const tools = getAllTools().filter((tool) => tool.isReadOnly());
+  const isEnabled = await Promise.all(tools.map((tool) => tool.isEnabled()));
+  return tools.filter((_, index) => isEnabled[index]);
+});
+
+export {
+  getAllTools,
+  getTools,
+  getReadOnlyTools
+};