@shareai-lab/kode 1.1.12 → 1.1.13

package/dist/tools/ArchitectTool/ArchitectTool.js

@@ -0,0 +1,119 @@
+import { Box } from "ink";
+import * as React from "react";
+import { z } from "zod";
+import { FallbackToolUseRejectedMessage } from "../../components/FallbackToolUseRejectedMessage.js";
+import { HighlightedCode } from "../../components/HighlightedCode.js";
+import { getContext } from "../../context.js";
+import { query } from "../../query.js";
+import { lastX } from "../../utils/generators.js";
+import { createUserMessage } from "../../utils/messages.js";
+import { BashTool } from "../BashTool/BashTool.js";
+import { FileReadTool } from "../FileReadTool/FileReadTool.js";
+import { FileWriteTool } from "../FileWriteTool/FileWriteTool.js";
+import { GlobTool } from "../GlobTool/GlobTool.js";
+import { GrepTool } from "../GrepTool/GrepTool.js";
+import { LSTool } from "../lsTool/lsTool.js";
+import { ARCHITECT_SYSTEM_PROMPT, DESCRIPTION } from "./prompt.js";
+const FS_EXPLORATION_TOOLS = [
+  BashTool,
+  LSTool,
+  FileReadTool,
+  FileWriteTool,
+  GlobTool,
+  GrepTool
+];
+const inputSchema = z.strictObject({
+  prompt: z.string().describe("The technical request or coding task to analyze"),
+  context: z.string().describe("Optional context from previous conversation or system state").optional()
+});
+const ArchitectTool = {
+  name: "Architect",
+  async description() {
+    return DESCRIPTION;
+  },
+  inputSchema,
+  isReadOnly() {
+    return true;
+  },
+  isConcurrencySafe() {
+    return true;
+  },
+  userFacingName() {
+    return "Architect";
+  },
+  async isEnabled() {
+    return false;
+  },
+  needsPermissions() {
+    return false;
+  },
+  async *call({ prompt, context }, toolUseContext) {
+    const content = context ? `<context>${context}</context>
+
+${prompt}` : prompt;
+    const userMessage = createUserMessage(content);
+    const messages = [userMessage];
+    const allowedTools = (toolUseContext.options?.tools ?? []).filter(
+      (_) => FS_EXPLORATION_TOOLS.map((_2) => _2.name).includes(_.name)
+    );
+    const canUseTool = async () => ({ result: true });
+    const lastResponse = await lastX(
+      query(
+        messages,
+        [ARCHITECT_SYSTEM_PROMPT],
+        await getContext(),
+        canUseTool,
+        {
+          ...toolUseContext,
+          setToolJSX: () => {
+          },
+          // Dummy function since ArchitectTool doesn't use UI
+          options: {
+            commands: toolUseContext.options?.commands || [],
+            forkNumber: toolUseContext.options?.forkNumber || 0,
+            messageLogName: toolUseContext.options?.messageLogName || "default",
+            verbose: toolUseContext.options?.verbose || false,
+            safeMode: toolUseContext.options?.safeMode || false,
+            maxThinkingTokens: toolUseContext.options?.maxThinkingTokens || 0,
+            ...toolUseContext.options,
+            tools: allowedTools
+          }
+        }
+      )
+    );
+    if (lastResponse.type !== "assistant") {
+      throw new Error(`Invalid response from API`);
+    }
+    const data = lastResponse.message.content.filter((_) => _.type === "text");
+    yield {
+      type: "result",
+      data,
+      resultForAssistant: this.renderResultForAssistant(data)
+    };
+  },
+  async prompt() {
+    return DESCRIPTION;
+  },
+  renderResultForAssistant(data) {
+    return data.map((block) => block.text).join("\n");
+  },
+  renderToolUseMessage(input) {
+    return Object.entries(input).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(", ");
+  },
+  renderToolResultMessage(content) {
+    return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ React.createElement(
+      HighlightedCode,
+      {
+        code: content.map((_) => _.text).join("\n"),
+        language: "markdown"
+      }
+    ));
+  },
+  renderToolUseRejectedMessage() {
+    return /* @__PURE__ */ React.createElement(FallbackToolUseRejectedMessage, null);
+  }
+};
+export {
+  ArchitectTool
+};
+//# sourceMappingURL=ArchitectTool.js.map

package/dist/tools/ArchitectTool/ArchitectTool.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/tools/ArchitectTool/ArchitectTool.tsx"],
+  "sourcesContent": ["import type { TextBlock } from '@anthropic-ai/sdk/resources/index.mjs'\nimport { Box } from 'ink'\nimport * as React from 'react'\nimport { z } from 'zod'\nimport type { Tool } from '../../Tool'\nimport { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'\nimport { HighlightedCode } from '../../components/HighlightedCode'\nimport { getContext } from '../../context'\nimport { Message, query } from '../../query'\nimport { lastX } from '../../utils/generators'\nimport { createUserMessage } from '../../utils/messages'\nimport { BashTool } from '../BashTool/BashTool'\nimport { FileReadTool } from '../FileReadTool/FileReadTool'\nimport { FileWriteTool } from '../FileWriteTool/FileWriteTool'\nimport { GlobTool } from '../GlobTool/GlobTool'\nimport { GrepTool } from '../GrepTool/GrepTool'\nimport { LSTool } from '../lsTool/lsTool'\nimport { ARCHITECT_SYSTEM_PROMPT, DESCRIPTION } from './prompt'\n\nconst FS_EXPLORATION_TOOLS: Tool[] = [\n  BashTool,\n  LSTool,\n  FileReadTool,\n  FileWriteTool,\n  GlobTool,\n  GrepTool,\n]\n\nconst inputSchema = z.strictObject({\n  prompt: z\n    .string()\n    .describe('The technical request or coding task to analyze'),\n  context: z\n    .string()\n    .describe('Optional context from previous conversation or system state')\n    .optional(),\n})\n\nexport const ArchitectTool = {\n  name: 'Architect',\n  async description() {\n    return DESCRIPTION\n  },\n  inputSchema,\n  isReadOnly() {\n    return true\n  },\n  isConcurrencySafe() {\n    return true // ArchitectTool is read-only, safe for concurrent execution\n  },\n  userFacingName() {\n    return 'Architect'\n  },\n  async isEnabled() {\n    return false\n  },\n  needsPermissions() {\n    return false\n  },\n  async *call({ prompt, context }, toolUseContext) {\n    const content = context\n      ? `<context>${context}</context>\\n\\n${prompt}`\n      : prompt\n\n    const userMessage = createUserMessage(content)\n\n    const messages: Message[] = [userMessage]\n\n    // We only allow the file exploration tools to be used in the architect tool\n    const allowedTools = (toolUseContext.options?.tools ?? []).filter(_ =>\n      FS_EXPLORATION_TOOLS.map(_ => _.name).includes(_.name),\n    )\n\n    // Create a dummy canUseTool function since this tool controls its own tool usage\n    const canUseTool = async () => ({ result: true as const })\n\n    const lastResponse = await lastX(\n      query(\n        messages,\n        [ARCHITECT_SYSTEM_PROMPT],\n        await getContext(),\n        canUseTool,\n        {\n          ...toolUseContext,\n          setToolJSX: () => {}, // Dummy function since ArchitectTool doesn't use UI\n          options: { \n            commands: toolUseContext.options?.commands || [],\n            forkNumber: toolUseContext.options?.forkNumber || 0,\n            messageLogName: toolUseContext.options?.messageLogName || 'default',\n            verbose: toolUseContext.options?.verbose || false,\n            safeMode: toolUseContext.options?.safeMode || false,\n            maxThinkingTokens: toolUseContext.options?.maxThinkingTokens || 0,\n            ...toolUseContext.options, \n            tools: allowedTools \n          },\n        },\n      ),\n    )\n\n    if (lastResponse.type !== 'assistant') {\n      throw new Error(`Invalid response from API`)\n    }\n\n    const data = lastResponse.message.content.filter(_ => _.type === 'text')\n    yield {\n      type: 'result',\n      data,\n      resultForAssistant: this.renderResultForAssistant(data),\n    }\n  },\n  async prompt() {\n    return DESCRIPTION\n  },\n  renderResultForAssistant(data: TextBlock[]): string {\n    return data.map(block => block.text).join('\\n')\n  },\n  renderToolUseMessage(input) {\n    return Object.entries(input)\n      .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)\n      .join(', ')\n  },\n  renderToolResultMessage(content) {\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <HighlightedCode\n          code={content.map(_ => _.text).join('\\n')}\n          language=\"markdown\"\n        />\n      </Box>\n    )\n  },\n  renderToolUseRejectedMessage() {\n    return <FallbackToolUseRejectedMessage />\n  },\n} satisfies Tool<typeof inputSchema, TextBlock[]>\n"],
+  "mappings": "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",
+  "names": ["_"]
+}

package/dist/tools/ArchitectTool/prompt.js

@@ -0,0 +1,18 @@
+const ARCHITECT_SYSTEM_PROMPT = `You are an expert software architect. Your role is to analyze technical requirements and produce clear, actionable implementation plans.
+These plans will then be carried out by a junior software engineer so you need to be specific and detailed. However do not actually write the code, just explain the plan.
+
+Follow these steps for each request:
+1. Carefully analyze requirements to identify core functionality and constraints
+2. Define clear technical approach with specific technologies and patterns
+3. Break down implementation into concrete, actionable steps at the appropriate level of abstraction
+
+Keep responses focused, specific and actionable. 
+
+IMPORTANT: Do not ask the user if you should implement the changes at the end. Just provide the plan as described above.
+IMPORTANT: Do not attempt to write the code or use any string modification tools. Just provide the plan.`;
+const DESCRIPTION = "Your go-to tool for any technical or coding task. Analyzes requirements and breaks them down into clear, actionable implementation steps. Use this whenever you need help planning how to implement a feature, solve a technical problem, or structure your code.";
+export {
+  ARCHITECT_SYSTEM_PROMPT,
+  DESCRIPTION
+};
+//# sourceMappingURL=prompt.js.map

package/dist/tools/ArchitectTool/prompt.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/tools/ArchitectTool/prompt.ts"],
+  "sourcesContent": ["export const ARCHITECT_SYSTEM_PROMPT = `You are an expert software architect. Your role is to analyze technical requirements and produce clear, actionable implementation plans.\nThese plans will then be carried out by a junior software engineer so you need to be specific and detailed. However do not actually write the code, just explain the plan.\n\nFollow these steps for each request:\n1. Carefully analyze requirements to identify core functionality and constraints\n2. Define clear technical approach with specific technologies and patterns\n3. Break down implementation into concrete, actionable steps at the appropriate level of abstraction\n\nKeep responses focused, specific and actionable. \n\nIMPORTANT: Do not ask the user if you should implement the changes at the end. Just provide the plan as described above.\nIMPORTANT: Do not attempt to write the code or use any string modification tools. Just provide the plan.`\n\nexport const DESCRIPTION =\n  'Your go-to tool for any technical or coding task. Analyzes requirements and breaks them down into clear, actionable implementation steps. Use this whenever you need help planning how to implement a feature, solve a technical problem, or structure your code.'\n"],
+  "mappings": "AAAO,MAAM,0BAA0B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAahC,MAAM,cACX;",
+  "names": []
+}

package/dist/tools/AskExpertModelTool/AskExpertModelTool.js

@@ -0,0 +1,423 @@
+import * as React from "react";
+import { Box, Text } from "ink";
+import { z } from "zod";
+import { FallbackToolUseRejectedMessage } from "../../components/FallbackToolUseRejectedMessage.js";
+import { getModelManager } from "../../utils/model.js";
+import { getTheme } from "../../utils/theme.js";
+import {
+  createUserMessage,
+  createAssistantMessage,
+  INTERRUPT_MESSAGE
+} from "../../utils/messages.js";
+import { logError } from "../../utils/log.js";
+import {
+  createExpertChatSession,
+  loadExpertChatSession,
+  getSessionMessages,
+  addMessageToSession
+} from "../../utils/expertChatStorage.js";
+import { queryLLM } from "../../services/claude.js";
+import { debug as debugLogger } from "../../utils/debugLogger.js";
+import { applyMarkdown } from "../../utils/markdown.js";
+const 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'
+  )
+});
+const 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
+- Anthropic: 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) {
+      debugLogger.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) {
+      console.error("Model validation error in AskExpertModelTool:", 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) {
+          console.error("Failed to create new expert chat session:", 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) {
+          console.error("Failed to load expert chat session:", error);
+          logError(error);
+          try {
+            const newSession = createExpertChatSession(expertModel);
+            sessionId = newSession.sessionId;
+          } catch (createError) {
+            console.error("Failed to create fallback expert chat session:", 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) {
+        console.error("Failed to load session messages:", 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) {
+        console.error("Failed to create system messages:", 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);
+        debugLogger.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,
+            [],
+            // no system prompt - let expert model use its default behavior
+            0,
+            // no thinking tokens needed
+            [],
+            // no tools needed
+            abortController.signal,
+            {
+              safeMode: false,
+              model: expertModel,
+              prependCLISysprompt: false
+              // KEY: avoid injecting CLI context
+            }
+          ),
+          timeoutPromise
+        ]);
+      } catch (error) {
+        console.error("Expert model query failed:", 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) {
+        console.error("Failed to extract expert answer:", error);
+        logError(error);
+        throw new Error("Failed to process expert response");
+      }
+      try {
+        addMessageToSession(sessionId, "user", question);
+        addMessageToSession(sessionId, "assistant", expertAnswer);
+      } catch (error) {
+        console.error("Failed to save conversation to session:", 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();
+      }
+      console.error("AskExpertModelTool execution failed:", error);
+      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);
+    }
+  },
+  // Unified interrupt handling method (following TaskTool pattern)
+  async *handleInterrupt() {
+    yield {
+      type: "result",
+      data: {
+        chatSessionId: "interrupted",
+        expertModelName: "cancelled",
+        expertAnswer: INTERRUPT_MESSAGE
+      },
+      resultForAssistant: INTERRUPT_MESSAGE
+    };
+  }
+};
+export {
+  AskExpertModelTool,
+  inputSchema
+};
+//# sourceMappingURL=AskExpertModelTool.js.map