@within-7/minto 0.3.10 → 0.4.0

package/dist/services/claude.js

@@ -1,1732 +1,23 @@
-import "@anthropic-ai/sdk/shims/node";
-import Anthropic, { APIConnectionError, APIError } from "@anthropic-ai/sdk";
-import { AnthropicBedrock } from "@anthropic-ai/bedrock-sdk";
-import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";
-import chalk from "chalk";
-import { randomUUID } from "crypto";
-import "dotenv/config";
-import { addToTotalCost } from "../cost-tracker.js";
-import { recordTokenUsage } from "../core/tokenStatsManager.js";
-import models from "../constants/models.js";
-import { getToolDescriptionAsync } from "../Tool.js";
 import {
-  getAnthropicApiKey,
-  getOrCreateUserID,
-  getGlobalConfig
-} from "../utils/config.js";
-import { getProjectDocs } from "../context.js";
-import { logError, SESSION_ID } from "../utils/log.js";
-import { abortableDelay } from "../utils/async.js";
-import { USER_AGENT } from "../utils/http.js";
-import {
-  createAssistantAPIErrorMessage,
-  normalizeContentFromAPI
-} from "../utils/messages.js";
-import { withVCR } from "./vcr.js";
-import {
-  debug as debugLogger,
-  markPhase,
-  getCurrentRequest,
-  logLLMInteraction,
-  logSystemPromptConstruction,
-  logErrorWithDiagnosis
-} from "../utils/debugLogger.js";
-import { getModelManager } from "../utils/model.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { ModelAdapterFactory } from "./modelAdapterFactory.js";
-import { responseStateManager, getConversationId } from "./responseStateManager.js";
-import { USE_BEDROCK, USE_VERTEX } from "../utils/model.js";
-import { getCLISyspromptPrefix } from "../constants/prompts.js";
-import { getVertexRegionForModel } from "../utils/model.js";
-import { nanoid } from "nanoid";
-import {
-  getCompletionWithProfile,
-  getGPT5CompletionWithProfile
-} from "./openai.js";
-import { getReasoningEffort } from "../utils/thinking.js";
-import { generateSystemReminders } from "./systemReminder.js";
-import { addRetryEventToTranscript } from "../utils/agentTranscripts.js";
-import { setStreamingState, getStreamingState } from "../components/Spinner.js";
-function isGPT5Model(modelName) {
-  return modelName.startsWith("gpt-5");
-}
-class MintoContextManager {
-  static instance;
-  projectDocsCache = "";
-  cacheInitialized = false;
-  initPromise = null;
-  constructor() {
-  }
-  static getInstance() {
-    if (!MintoContextManager.instance) {
-      MintoContextManager.instance = new MintoContextManager();
-    }
-    return MintoContextManager.instance;
-  }
-  async initialize() {
-    if (this.cacheInitialized) return;
-    if (this.initPromise) {
-      return this.initPromise;
-    }
-    this.initPromise = this.loadProjectDocs();
-    await this.initPromise;
-  }
-  async loadProjectDocs() {
-    try {
-      const projectDocs = await getProjectDocs();
-      this.projectDocsCache = projectDocs || "";
-      this.cacheInitialized = true;
-      if (process.env.NODE_ENV === "development") {
-        debugLogger.info("MINTO_CONTEXT_LOADED", {
-          characters: this.projectDocsCache.length
-        });
-      }
-    } catch (error) {
-      debugLogger.warn("MINTO_CONTEXT_LOAD_FAILED", { error: String(error) });
-      this.projectDocsCache = "";
-      this.cacheInitialized = true;
-    }
-  }
-  getMintoContext() {
-    if (!this.cacheInitialized) {
-      this.initialize().catch((error) => {
-        debugLogger.warn("MINTO_CONTEXT_INIT_FAILED", { error: String(error) });
-      });
-      return "";
-    }
-    return this.projectDocsCache;
-  }
-  async refreshCache() {
-    this.cacheInitialized = false;
-    this.initPromise = null;
-    await this.initialize();
-  }
-}
-const mintoContextManager = MintoContextManager.getInstance();
-mintoContextManager.initialize().catch((error) => {
-  debugLogger.warn("MINTO_CONTEXT_MODULE_INIT_FAILED", { error: String(error) });
-});
-const generateMintoContext = () => {
-  return mintoContextManager.getMintoContext();
-};
-const refreshMintoContext = async () => {
-  await mintoContextManager.refreshCache();
-};
-const API_ERROR_MESSAGE_PREFIX = "API Error";
-const PROMPT_TOO_LONG_ERROR_MESSAGE = "Prompt is too long";
-const CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE = "Credit balance is too low";
-const INVALID_API_KEY_ERROR_MESSAGE = "Invalid API key \xB7 Please run /login";
-const NO_CONTENT_MESSAGE = "(no content)";
-const PROMPT_CACHING_ENABLED = !process.env.DISABLE_PROMPT_CACHING;
-const SONNET_COST_PER_MILLION_INPUT_TOKENS = 3;
-const SONNET_COST_PER_MILLION_OUTPUT_TOKENS = 15;
-const SONNET_COST_PER_MILLION_PROMPT_CACHE_WRITE_TOKENS = 3.75;
-const SONNET_COST_PER_MILLION_PROMPT_CACHE_READ_TOKENS = 0.3;
-const MAIN_QUERY_TEMPERATURE = 1;
-function getMetadata() {
-  return {
-    user_id: `${getOrCreateUserID()}_${SESSION_ID}`
-  };
-}
-const MAX_RETRIES = process.env.USER_TYPE === "SWE_BENCH" ? 100 : 10;
-const BASE_DELAY_MS = 500;
-function getRetryDelay(attempt, retryAfterHeader) {
-  if (retryAfterHeader) {
-    const seconds = parseInt(retryAfterHeader, 10);
-    if (!isNaN(seconds)) {
-      return seconds * 1e3;
-    }
-  }
-  return Math.min(BASE_DELAY_MS * Math.pow(2, attempt - 1), 32e3);
-}
-function shouldRetry(error) {
-  if (error.message?.includes('"type":"overloaded_error"')) {
-    return process.env.USER_TYPE === "SWE_BENCH";
-  }
-  const shouldRetryHeader = error.headers?.["x-should-retry"];
-  if (shouldRetryHeader === "true") return true;
-  if (shouldRetryHeader === "false") return false;
-  if (error instanceof APIConnectionError) {
-    return true;
-  }
-  if (!error.status) return false;
-  if (error.status === 408) return true;
-  if (error.status === 409) return true;
-  if (error.status === 429) return true;
-  if (error.status && error.status >= 500) return true;
-  return false;
-}
-async function withRetry(operation, options = {}) {
-  const maxRetries = options.maxRetries ?? MAX_RETRIES;
-  let lastError;
-  for (let attempt = 1; attempt <= maxRetries + 1; attempt++) {
-    try {
-      return await operation(attempt);
-    } catch (error) {
-      lastError = error;
-      if (attempt > maxRetries || !(error instanceof APIError) || !shouldRetry(error)) {
-        throw error;
-      }
-      if (options.signal?.aborted) {
-        throw new Error("Request cancelled by user");
-      }
-      const retryAfter = error.headers?.["retry-after"] ?? null;
-      const delayMs = getRetryDelay(attempt, retryAfter);
-      setStreamingState({
-        phase: "retrying",
-        retryCount: attempt,
-        maxRetries,
-        errorName: error.name
-      });
-      debugLogger.flow("API_RETRY_ATTEMPT", {
-        attempt,
-        maxRetries,
-        errorName: error.name,
-        errorMessage: error.message,
-        delayMs
-      });
-      if (options.onRetry) {
-        options.onRetry({
-          attempt,
-          maxRetries,
-          error,
-          delayMs
-        });
-      } else {
-        console.log(
-          `  \u23BF  ${chalk.red(`API ${error.name} (${error.message}) \xB7 Retrying in ${Math.round(delayMs / 1e3)} seconds\u2026 (attempt ${attempt}/${maxRetries})`)}`
-        );
-      }
-      try {
-        await abortableDelay(delayMs, options.signal);
-      } catch (delayError) {
-        if (delayError.message === "Request was aborted") {
-          throw new Error("Request cancelled by user");
-        }
-        throw delayError;
-      }
-    }
-  }
-  throw lastError;
-}
-async function fetchAnthropicModels(baseURL, apiKey) {
-  try {
-    const modelsURL = baseURL ? `${baseURL.replace(/\/+$/, "")}/v1/models` : "https://api.anthropic.com/v1/models";
-    const response = await fetch(modelsURL, {
-      method: "GET",
-      headers: {
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01",
-        "User-Agent": USER_AGENT
-      }
-    });
-    if (!response.ok) {
-      if (response.status === 401) {
-        throw new Error(
-          "Invalid API key. Please check your Anthropic API key and try again."
-        );
-      } else if (response.status === 403) {
-        throw new Error(
-          "API key does not have permission to access models. Please check your API key permissions."
-        );
-      } else if (response.status === 429) {
-        throw new Error(
-          "Too many requests. Please wait a moment and try again."
-        );
-      } else if (response.status >= 500) {
-        throw new Error(
-          "Anthropic service is temporarily unavailable. Please try again later."
-        );
-      } else {
-        throw new Error(
-          `Unable to connect to Anthropic API (${response.status}). Please check your internet connection and API key.`
-        );
-      }
-    }
-    const data = await response.json();
-    return data.data || [];
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("API key") || error instanceof Error && error.message.includes("Anthropic")) {
-      throw error;
-    }
-    logError(error);
-    throw new Error(
-      "Unable to connect to Anthropic API. Please check your internet connection and try again."
-    );
-  }
-}
-async function verifyApiKey(apiKey, baseURL, provider) {
-  if (!apiKey) {
-    return false;
-  }
-  if (provider && provider !== "anthropic") {
-    try {
-      const headers = {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      };
-      if (!baseURL) {
-        debugLogger.warn("API_VERIFY", {
-          error: "No baseURL provided for non-Anthropic provider"
-        });
-        return false;
-      }
-      const modelsURL = `${baseURL.replace(/\/+$/, "")}/models`;
-      const response = await fetch(modelsURL, {
-        method: "GET",
-        headers
-      });
-      return response.ok;
-    } catch (error) {
-      debugLogger.warn("API_VERIFY", {
-        error: "non-Anthropic provider verification failed",
-        details: String(error)
-      });
-      return false;
-    }
-  }
-  const clientConfig = {
-    apiKey,
-    dangerouslyAllowBrowser: true,
-    maxRetries: 3,
-    defaultHeaders: {
-      "User-Agent": USER_AGENT
-    }
-  };
-  if (baseURL && (provider === "anthropic" || provider === "bigdream" || provider === "opendev")) {
-    clientConfig.baseURL = baseURL;
-  }
-  const anthropic = new Anthropic(clientConfig);
-  try {
-    await withRetry(
-      async () => {
-        const model = "claude-sonnet-4-20250514";
-        const messages = [{ role: "user", content: "test" }];
-        await anthropic.messages.create({
-          model,
-          max_tokens: 1e3,
-          // Simple test token limit for API verification
-          messages,
-          temperature: 0,
-          metadata: getMetadata()
-        });
-        return true;
-      },
-      { maxRetries: 2 }
-      // Use fewer retries for API key verification
-    );
-    return true;
-  } catch (error) {
-    logError(error);
-    if (error instanceof Error && error.message.includes(
-      '{"type":"error","error":{"type":"authentication_error","message":"invalid x-api-key"}}'
-    )) {
-      return false;
-    }
-    throw error;
-  }
-}
-function convertAnthropicMessagesToOpenAIMessages(messages) {
-  const openaiMessages = [];
-  const toolResults = {};
-  for (const message of messages) {
-    let contentBlocks = [];
-    if (typeof message.message.content === "string") {
-      contentBlocks = [
-        {
-          type: "text",
-          text: message.message.content
-        }
-      ];
-    } else if (!Array.isArray(message.message.content)) {
-      contentBlocks = [message.message.content];
-    } else {
-      contentBlocks = message.message.content;
-    }
-    for (const block of contentBlocks) {
-      if (block.type === "text") {
-        openaiMessages.push({
-          role: message.message.role,
-          content: block.text
-        });
-      } else if (block.type === "tool_use") {
-        openaiMessages.push({
-          role: "assistant",
-          content: void 0,
-          tool_calls: [
-            {
-              type: "function",
-              function: {
-                name: block.name,
-                arguments: JSON.stringify(block.input)
-              },
-              id: block.id
-            }
-          ]
-        });
-      } else if (block.type === "tool_result") {
-        let toolContent = block.content;
-        if (typeof toolContent !== "string") {
-          toolContent = JSON.stringify(toolContent);
-        }
-        toolResults[block.tool_use_id] = {
-          role: "tool",
-          content: toolContent,
-          tool_call_id: block.tool_use_id
-        };
-      }
-    }
-  }
-  const finalMessages = [];
-  for (const message of openaiMessages) {
-    finalMessages.push(message);
-    if ("tool_calls" in message && message.tool_calls) {
-      for (const toolCall of message.tool_calls) {
-        if (toolResults[toolCall.id]) {
-          finalMessages.push(toolResults[toolCall.id]);
-        }
-      }
-    }
-  }
-  return finalMessages;
-}
-function messageReducer(previous, item) {
-  const reduce = (acc, delta) => {
-    acc = { ...acc };
-    for (const [key, value] of Object.entries(delta)) {
-      if (acc[key] === void 0 || acc[key] === null) {
-        acc[key] = value;
-        if (Array.isArray(acc[key])) {
-          for (const arr of acc[key]) {
-            delete arr.index;
-          }
-        }
-      } else if (typeof acc[key] === "string" && typeof value === "string") {
-        acc[key] += value;
-      } else if (typeof acc[key] === "number" && typeof value === "number") {
-        acc[key] = value;
-      } else if (Array.isArray(acc[key]) && Array.isArray(value)) {
-        const accArray = acc[key];
-        for (let i = 0; i < value.length; i++) {
-          const { index, ...chunkTool } = value[i];
-          if (index - accArray.length > 1) {
-            throw new Error(
-              `Error: An array has an empty value when tool_calls are constructed. tool_calls: ${accArray}; tool: ${value}`
-            );
-          }
-          accArray[index] = reduce(accArray[index], chunkTool);
-        }
-      } else if (typeof acc[key] === "object" && typeof value === "object") {
-        acc[key] = reduce(acc[key], value);
-      }
-    }
-    return acc;
-  };
-  const choice = item.choices?.[0];
-  if (!choice) {
-    return previous;
-  }
-  return reduce(previous, choice.delta);
-}
-async function handleMessageStream(stream, signal) {
-  const streamStartTime = Date.now();
-  let ttftMs;
-  let chunkCount = 0;
-  let errorCount = 0;
-  debugLogger.api("OPENAI_STREAM_START", {
-    streamStartTime: String(streamStartTime)
-  });
-  let message = {};
-  let id, model, created, object, usage;
-  try {
-    for await (const chunk of stream) {
-      if (signal?.aborted) {
-        debugLogger.flow("OPENAI_STREAM_ABORTED", {
-          chunkCount,
-          timestamp: Date.now()
-        });
-        throw new Error("Request was cancelled");
-      }
-      chunkCount++;
-      try {
-        if (!id) {
-          id = chunk.id;
-          debugLogger.api("OPENAI_STREAM_ID_RECEIVED", {
-            id,
-            chunkNumber: String(chunkCount)
-          });
-        }
-        if (!model) {
-          model = chunk.model;
-          debugLogger.api("OPENAI_STREAM_MODEL_RECEIVED", {
-            model,
-            chunkNumber: String(chunkCount)
-          });
-        }
-        if (!created) {
-          created = chunk.created;
-        }
-        if (!object) {
-          object = chunk.object;
-        }
-        if (!usage && chunk.usage) {
-          usage = chunk.usage;
-          setStreamingState({
-            inputTokens: chunk.usage.prompt_tokens,
-            outputTokens: chunk.usage.completion_tokens
-          });
-        }
-        message = messageReducer(message, chunk);
-        if (chunk?.choices?.[0]?.delta?.content) {
-          if (!ttftMs) {
-            ttftMs = Date.now() - streamStartTime;
-            debugLogger.api("OPENAI_STREAM_FIRST_TOKEN", {
-              ttftMs: String(ttftMs),
-              chunkNumber: String(chunkCount)
-            });
-          }
-        }
-      } catch (chunkError) {
-        errorCount++;
-        debugLogger.error("OPENAI_STREAM_CHUNK_ERROR", {
-          chunkNumber: String(chunkCount),
-          errorMessage: chunkError instanceof Error ? chunkError.message : String(chunkError),
-          errorType: chunkError instanceof Error ? chunkError.constructor.name : typeof chunkError
-        });
-      }
-    }
-    debugLogger.api("OPENAI_STREAM_COMPLETE", {
-      totalChunks: String(chunkCount),
-      errorCount: String(errorCount),
-      totalDuration: String(Date.now() - streamStartTime),
-      ttftMs: String(ttftMs || 0),
-      finalMessageId: id || "undefined"
-    });
-  } catch (streamError) {
-    debugLogger.error("OPENAI_STREAM_FATAL_ERROR", {
-      totalChunks: String(chunkCount),
-      errorCount: String(errorCount),
-      errorMessage: streamError instanceof Error ? streamError.message : String(streamError),
-      errorType: streamError instanceof Error ? streamError.constructor.name : typeof streamError
-    });
-    throw streamError;
-  }
-  return {
-    id,
-    created,
-    model,
-    object,
-    choices: [
-      {
-        index: 0,
-        message,
-        finish_reason: "stop",
-        logprobs: void 0
-      }
-    ],
-    usage
-  };
-}
-function convertOpenAIResponseToAnthropic(response, _tools) {
-  let contentBlocks = [];
-  const message = response.choices?.[0]?.message;
-  if (!message) {
-    return {
-      role: "assistant",
-      content: [],
-      stop_reason: response.choices?.[0]?.finish_reason,
-      type: "message",
-      usage: response.usage
-    };
-  }
-  if (message?.tool_calls) {
-    for (const toolCall of message.tool_calls) {
-      const tool = toolCall.function;
-      const toolName = tool?.name;
-      let toolArgs = {};
-      let parseError = null;
-      try {
-        toolArgs = tool?.arguments ? JSON.parse(tool.arguments) : {};
-      } catch (e) {
-        parseError = e instanceof Error ? e.message : String(e);
-        debugLogger.warn("TOOL_ARGUMENTS_PARSE_ERROR", {
-          toolName,
-          rawArguments: tool?.arguments?.substring(0, 200),
-          // Limit log size
-          errorMessage: parseError
-        });
-      }
-      if (parseError && Object.keys(toolArgs).length === 0) {
-        debugLogger.error("TOOL_CALL_EMPTY_ARGUMENTS", {
-          toolName,
-          parseError,
-          suggestion: "Model may have sent malformed JSON. The tool call will likely fail validation."
-        });
-      }
-      contentBlocks.push({
-        type: "tool_use",
-        input: toolArgs,
-        name: toolName,
-        id: toolCall.id?.length > 0 ? toolCall.id : nanoid()
-      });
-    }
-  }
-  if (message.reasoning) {
-    contentBlocks.push({
-      type: "thinking",
-      thinking: message.reasoning,
-      signature: ""
-    });
-  }
-  if (message.reasoning_content) {
-    contentBlocks.push({
-      type: "thinking",
-      thinking: message.reasoning_content,
-      signature: ""
-    });
-  }
-  if (message.content) {
-    contentBlocks.push({
-      type: "text",
-      text: message?.content,
-      citations: []
-    });
-  }
-  const finalMessage = {
-    role: "assistant",
-    content: contentBlocks,
-    stop_reason: response.choices?.[0]?.finish_reason,
-    type: "message",
-    usage: response.usage
-  };
-  return finalMessage;
-}
-let anthropicClient = null;
-function getAnthropicClient(model) {
-  const config = getGlobalConfig();
-  const provider = config.primaryProvider;
-  if (anthropicClient && provider) {
-    anthropicClient = null;
-  }
-  if (anthropicClient) {
-    return anthropicClient;
-  }
-  const region = getVertexRegionForModel(model);
-  const defaultHeaders = {
-    "x-app": "cli",
-    "User-Agent": USER_AGENT
-  };
-  if (process.env.ANTHROPIC_AUTH_TOKEN) {
-    defaultHeaders["Authorization"] = `Bearer ${process.env.ANTHROPIC_AUTH_TOKEN}`;
-  }
-  const ARGS = {
-    defaultHeaders,
-    maxRetries: 0,
-    // Disabled auto-retry in favor of manual implementation
-    timeout: parseInt(process.env.API_TIMEOUT_MS || String(60 * 1e3), 10)
-  };
-  if (USE_BEDROCK) {
-    const client = new AnthropicBedrock(ARGS);
-    anthropicClient = client;
-    return client;
-  }
-  if (USE_VERTEX) {
-    const vertexArgs = {
-      ...ARGS,
-      region: region || process.env.CLOUD_ML_REGION || "us-east5"
-    };
-    const client = new AnthropicVertex(vertexArgs);
-    anthropicClient = client;
-    return client;
-  }
-  const modelManager = getModelManager();
-  const modelProfile = modelManager.getModel("main");
-  let apiKey;
-  let baseURL;
-  if (modelProfile) {
-    apiKey = modelProfile.apiKey || "";
-    baseURL = modelProfile.baseURL;
-  } else {
-    apiKey = getAnthropicApiKey();
-    baseURL = void 0;
-  }
-  if (process.env.USER_TYPE === "ant" && !apiKey && provider === "anthropic") {
-    console.error(
-      chalk.red(
-        "[ANT-ONLY] Please set the ANTHROPIC_API_KEY environment variable to use the CLI. To create a new key, go to https://console.anthropic.com/settings/keys."
-      )
-    );
-  }
-  const clientConfig = {
-    apiKey,
-    dangerouslyAllowBrowser: true,
-    ...ARGS,
-    ...baseURL && { baseURL }
-    // Use baseURL directly, SDK will handle API versioning
-  };
-  anthropicClient = new Anthropic(clientConfig);
-  return anthropicClient;
-}
-function resetAnthropicClient() {
-  anthropicClient = null;
-}
-function applyCacheControlWithLimits(systemBlocks, messageParams) {
-  if (!PROMPT_CACHING_ENABLED) {
-    return { systemBlocks, messageParams };
-  }
-  const maxCacheBlocks = 4;
-  let usedCacheBlocks = 0;
-  const processedSystemBlocks = systemBlocks.map((block, _index) => {
-    if (usedCacheBlocks < maxCacheBlocks && block.text.length > 1e3) {
-      usedCacheBlocks++;
-      return {
-        ...block,
-        cache_control: { type: "ephemeral" }
-      };
-    }
-    const { cache_control, ...blockWithoutCache } = block;
-    return blockWithoutCache;
-  });
-  const processedMessageParams = messageParams.map((message, messageIndex) => {
-    if (Array.isArray(message.content)) {
-      const processedContent = message.content.map(
-        (contentBlock, blockIndex) => {
-          const shouldCache = usedCacheBlocks < maxCacheBlocks && contentBlock.type === "text" && typeof contentBlock.text === "string" && // Long documents (over 2000 characters)
-          (contentBlock.text.length > 2e3 || // Last content block of the last message (may be important context)
-          messageIndex === messageParams.length - 1 && blockIndex === message.content.length - 1 && contentBlock.text.length > 500);
-          if (shouldCache) {
-            usedCacheBlocks++;
-            return {
-              ...contentBlock,
-              cache_control: { type: "ephemeral" }
-            };
-          }
-          const { cache_control, ...blockWithoutCache } = contentBlock;
-          return blockWithoutCache;
-        }
-      );
-      return {
-        ...message,
-        content: processedContent
-      };
-    }
-    return message;
-  });
-  return {
-    systemBlocks: processedSystemBlocks,
-    messageParams: processedMessageParams
-  };
-}
-function userMessageToMessageParam(message, addCache = false) {
-  if (addCache) {
-    if (typeof message.message.content === "string") {
-      return {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: message.message.content
-          }
-        ]
-      };
-    } else {
-      return {
-        role: "user",
-        content: message.message.content.map((_) => ({ ..._ }))
-      };
-    }
-  }
-  return {
-    role: "user",
-    content: message.message.content
-  };
-}
-function assistantMessageToMessageParam(message, addCache = false) {
-  if (addCache) {
-    if (typeof message.message.content === "string") {
-      return {
-        role: "assistant",
-        content: [
-          {
-            type: "text",
-            text: message.message.content
-          }
-        ]
-      };
-    } else {
-      return {
-        role: "assistant",
-        content: message.message.content.map((_) => ({ ..._ }))
-      };
-    }
-  }
-  return {
-    role: "assistant",
-    content: message.message.content
-  };
-}
-function splitSysPromptPrefix(systemPrompt) {
-  const systemPromptFirstBlock = systemPrompt[0] || "";
-  const systemPromptRest = systemPrompt.slice(1);
-  return [systemPromptFirstBlock, systemPromptRest.join("\n")].filter(Boolean);
-}
-async function queryLLM(messages, systemPrompt, maxThinkingTokens, tools, signal, options) {
-  const modelManager = getModelManager();
-  const modelResolution = modelManager.resolveModelWithInfo(options.model);
-  if (!modelResolution.success || !modelResolution.profile) {
-    throw new Error(
-      modelResolution.error || `Failed to resolve model: ${options.model}`
-    );
-  }
-  const modelProfile = modelResolution.profile;
-  const resolvedModel = modelProfile.modelName;
-  const toolUseContext = options.toolUseContext;
-  if (toolUseContext && !toolUseContext.responseState) {
-    const conversationId = getConversationId(
-      toolUseContext.agentId,
-      toolUseContext.messageId
-    );
-    const previousResponseId = responseStateManager.getPreviousResponseId(conversationId);
-    toolUseContext.responseState = {
-      previousResponseId,
-      conversationId
-    };
-  }
-  debugLogger.api("MODEL_RESOLVED", {
-    inputParam: options.model,
-    resolvedModelName: resolvedModel,
-    provider: modelProfile.provider,
-    isPointer: ["main", "task", "reasoning", "quick"].includes(options.model),
-    hasResponseState: !!toolUseContext?.responseState,
-    conversationId: toolUseContext?.responseState?.conversationId,
-    requestId: getCurrentRequest()?.id
-  });
-  const currentRequest = getCurrentRequest();
-  debugLogger.api("LLM_REQUEST_START", {
-    messageCount: messages.length,
-    systemPromptLength: systemPrompt.join(" ").length,
-    toolCount: tools.length,
-    model: resolvedModel,
-    originalModelParam: options.model,
-    requestId: getCurrentRequest()?.id
-  });
-  markPhase("LLM_CALL");
-  try {
-    const result = await withVCR(
-      messages,
-      () => queryLLMWithPromptCaching(
-        messages,
-        systemPrompt,
-        maxThinkingTokens,
-        tools,
-        signal,
-        { ...options, model: resolvedModel, modelProfile, toolUseContext }
-        // Pass resolved ModelProfile and toolUseContext
-      )
-    );
-    debugLogger.api("LLM_REQUEST_SUCCESS", {
-      costUSD: result.costUSD,
-      durationMs: result.durationMs,
-      responseLength: result.message.content?.length || 0,
-      requestId: getCurrentRequest()?.id
-    });
-    if (toolUseContext?.responseState?.conversationId && result.responseId) {
-      responseStateManager.setPreviousResponseId(
-        toolUseContext.responseState.conversationId,
-        result.responseId
-      );
-      debugLogger.api("RESPONSE_STATE_UPDATED", {
-        conversationId: toolUseContext.responseState.conversationId,
-        responseId: result.responseId,
-        requestId: getCurrentRequest()?.id
-      });
-    }
-    return result;
-  } catch (error) {
-    logErrorWithDiagnosis(
-      error,
-      {
-        messageCount: messages.length,
-        systemPromptLength: systemPrompt.join(" ").length,
-        model: options.model,
-        toolCount: tools.length,
-        phase: "LLM_CALL"
-      },
-      currentRequest?.id
-    );
-    throw error;
-  }
-}
-function formatSystemPromptWithContext(systemPrompt, context, agentId, skipContextReminders = false) {
-  const enhancedPrompt = [...systemPrompt];
-  let reminders = "";
-  const modelManager = getModelManager();
-  const modelProfile = modelManager.getModel("main");
-  if (modelProfile && isGPT5Model(modelProfile.modelName)) {
-    const persistencePrompts = [
-      "\n# Agent Persistence for Long-Running Coding Tasks",
-      "You are working on a coding project that may involve multiple steps and iterations. Please maintain context and continuity throughout the session:",
-      "- Remember architectural decisions and design patterns established earlier",
-      "- Keep track of file modifications and their relationships",
-      "- Maintain awareness of the overall project structure and goals",
-      "- Reference previous implementations when making related changes",
-      "- Ensure consistency with existing code style and conventions",
-      "- Build incrementally on previous work rather than starting from scratch"
-    ];
-    enhancedPrompt.push(...persistencePrompts);
-  }
-  const hasContext = Object.entries(context).length > 0;
-  if (hasContext) {
-    if (!skipContextReminders) {
-      const mintoContext = generateMintoContext();
-      if (mintoContext) {
-        enhancedPrompt.push("\n---\n# \u9879\u76EE\u4E0A\u4E0B\u6587\n");
-        enhancedPrompt.push(mintoContext);
-        enhancedPrompt.push("\n---\n");
-      }
-    }
-    const reminderMessages = generateSystemReminders(hasContext, agentId);
-    if (reminderMessages.length > 0) {
-      reminders = reminderMessages.map((r) => r.content).join("\n") + "\n";
-    }
-    enhancedPrompt.push(
-      `
-As you answer the user's questions, you can use the following context:
-`
-    );
-    const filteredContext = Object.fromEntries(
-      Object.entries(context).filter(
-        ([key]) => key !== "projectDocs" && key !== "userDocs"
-      )
-    );
-    enhancedPrompt.push(
-      ...Object.entries(filteredContext).map(
-        ([key, value]) => `<context name="${key}">${value}</context>`
-      )
-    );
-  }
-  return { systemPrompt: enhancedPrompt, reminders };
-}
-async function queryLLMWithPromptCaching(messages, systemPrompt, maxThinkingTokens, tools, signal, options) {
-  const config = getGlobalConfig();
-  const modelManager = getModelManager();
-  const toolUseContext = options.toolUseContext;
-  const modelProfile = options.modelProfile || modelManager.getModel("main");
-  let provider;
-  if (modelProfile) {
-    provider = modelProfile.provider || config.primaryProvider || "anthropic";
-  } else {
-    provider = config.primaryProvider || "anthropic";
-  }
-  if (provider === "anthropic" || provider === "bigdream" || provider === "opendev") {
-    return queryAnthropicNative(
-      messages,
-      systemPrompt,
-      maxThinkingTokens,
-      tools,
-      signal,
-      { ...options, modelProfile, toolUseContext }
-    );
-  }
-  return queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, signal, {
-    ...options,
-    modelProfile,
-    toolUseContext
-  });
-}
-async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, tools, signal, options) {
-  const config = getGlobalConfig();
-  const modelManager = getModelManager();
-  const toolUseContext = options?.toolUseContext;
-  const modelProfile = options?.modelProfile || modelManager.getModel("main");
-  let anthropic;
-  let model;
-  let provider;
-  debugLogger.api("MODEL_CONFIG_ANTHROPIC", {
-    modelProfileFound: !!modelProfile,
-    modelProfileId: modelProfile?.modelName,
-    modelProfileName: modelProfile?.name,
-    modelProfileModelName: modelProfile?.modelName,
-    modelProfileProvider: modelProfile?.provider,
-    modelProfileBaseURL: modelProfile?.baseURL,
-    modelProfileApiKeyExists: !!modelProfile?.apiKey,
-    optionsModel: options?.model,
-    requestId: getCurrentRequest()?.id
-  });
-  if (modelProfile) {
-    model = modelProfile.modelName;
-    provider = modelProfile.provider || config.primaryProvider || "anthropic";
-    if (modelProfile.provider === "anthropic" || modelProfile.provider === "bigdream" || modelProfile.provider === "opendev") {
-      const clientConfig = {
-        apiKey: modelProfile.apiKey,
-        dangerouslyAllowBrowser: true,
-        maxRetries: 0,
-        timeout: parseInt(process.env.API_TIMEOUT_MS || String(60 * 1e3), 10),
-        defaultHeaders: {
-          "x-app": "cli",
-          "User-Agent": USER_AGENT
-        }
-      };
-      if (modelProfile.baseURL) {
-        clientConfig.baseURL = modelProfile.baseURL;
-      }
-      anthropic = new Anthropic(clientConfig);
-    } else {
-      anthropic = getAnthropicClient(model);
-    }
-  } else {
-    const errorDetails = {
-      modelProfileExists: !!modelProfile,
-      modelProfileModelName: modelProfile?.modelName,
-      requestedModel: options?.model,
-      requestId: getCurrentRequest()?.id
-    };
-    debugLogger.error("ANTHROPIC_FALLBACK_ERROR", errorDetails);
-    throw new Error(
-      `No valid ModelProfile available for Anthropic provider. Please configure model through /model command. Debug: ${JSON.stringify(errorDetails)}`
-    );
-  }
-  if (options?.prependCLISysprompt) {
-    const [firstSyspromptBlock] = splitSysPromptPrefix(systemPrompt);
-    systemPrompt = [getCLISyspromptPrefix(), ...systemPrompt];
-  }
-  const system = splitSysPromptPrefix(systemPrompt).map(
-    (_) => ({
-      text: _,
-      type: "text"
-    })
-  );
-  const toolSchemas = await Promise.all(
-    tools.map(
-      async (tool) => ({
-        name: tool.name,
-        // Use getToolDescriptionAsync for consistent async access
-        description: await getToolDescriptionAsync(tool),
-        input_schema: "inputJSONSchema" in tool && tool.inputJSONSchema ? tool.inputJSONSchema : zodToJsonSchema(tool.inputSchema)
-      })
-    )
-  );
-  const anthropicMessages = addCacheBreakpoints(messages);
-  const { systemBlocks: processedSystem, messageParams: processedMessages } = applyCacheControlWithLimits(system, anthropicMessages);
-  const startIncludingRetries = Date.now();
-  logSystemPromptConstruction({
-    basePrompt: systemPrompt.join("\n"),
-    mintoContext: generateMintoContext() || "",
-    reminders: [],
-    // 这里可以从 generateSystemReminders 获取
-    finalPrompt: systemPrompt.join("\n")
-  });
-  let start = Date.now();
-  let attemptNumber = 0;
-  let response;
-  try {
-    response = await withRetry(
-      async (attempt) => {
-        attemptNumber = attempt;
-        start = Date.now();
-        const params = {
-          model,
-          max_tokens: getMaxTokensFromProfile(modelProfile),
-          messages: processedMessages,
-          system: processedSystem,
-          tools: toolSchemas.length > 0 ? toolSchemas : void 0,
-          tool_choice: toolSchemas.length > 0 ? { type: "auto" } : void 0
-        };
-        if (maxThinkingTokens > 0) {
-          ;
-          params.extra_headers = {
-            "anthropic-beta": "max-tokens-3-5-sonnet-2024-07-15"
-          };
-          params.thinking = { max_tokens: maxThinkingTokens };
-        }
-        debugLogger.api("ANTHROPIC_API_CALL_START_STREAMING", {
-          endpoint: modelProfile?.baseURL || "DEFAULT_ANTHROPIC",
-          model,
-          provider,
-          apiKeyConfigured: !!modelProfile?.apiKey,
-          apiKeyPrefix: modelProfile?.apiKey ? modelProfile.apiKey.substring(0, 8) : null,
-          maxTokens: params.max_tokens,
-          temperature: MAIN_QUERY_TEMPERATURE,
-          params,
-          messageCount: params.messages?.length || 0,
-          streamMode: true,
-          toolsCount: toolSchemas.length,
-          thinkingTokens: maxThinkingTokens,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          modelProfileId: modelProfile?.modelName,
-          modelProfileName: modelProfile?.name
-        });
-        if (config.stream) {
-          const stream = await anthropic.beta.messages.create(
-            {
-              ...params,
-              stream: true
-            },
-            {
-              signal
-              // ← CRITICAL: Connect the AbortSignal to API call
-            }
-          );
-          let finalResponse = null;
-          let messageStartEvent = null;
-          const contentBlocks = [];
-          const inputJSONBuffers = /* @__PURE__ */ new Map();
-          let usage = null;
-          let stopReason = null;
-          let stopSequence = null;
-          for await (const event of stream) {
-            if (signal.aborted) {
-              debugLogger.flow("STREAM_ABORTED", {
-                eventType: event.type,
-                timestamp: Date.now()
-              });
-              throw new Error("Request was cancelled");
-            }
-            switch (event.type) {
-              case "message_start":
-                messageStartEvent = event;
-                finalResponse = {
-                  ...event.message,
-                  content: []
-                  // Will be populated from content blocks
-                };
-                setStreamingState({
-                  inputTokens: event.message.usage?.input_tokens,
-                  receivedChars: 0
-                  // Reset for new request
-                });
-                break;
-              case "content_block_start":
-                contentBlocks[event.index] = { ...event.content_block };
-                if (event.content_block.type === "tool_use") {
-                  inputJSONBuffers.set(event.index, "");
-                }
-                if (event.content_block.type === "thinking") {
-                  const thinkingStartTime = Date.now();
-                  setStreamingState({
-                    phase: "deep_thinking",
-                    tokenCount: 0,
-                    thinkingMaxTokens: maxThinkingTokens,
-                    thinkingStartTime
-                    // NEW: Record start time for duration tracking
-                  });
-                  debugLogger.flow("THINKING_BLOCK_START", {
-                    index: event.index,
-                    maxTokens: maxThinkingTokens,
-                    startTime: thinkingStartTime
-                  });
-                }
-                break;
-              case "content_block_delta":
-                const blockIndex = event.index;
-                if (!contentBlocks[blockIndex]) {
-                  contentBlocks[blockIndex] = {
-                    type: event.delta.type === "text_delta" ? "text" : "tool_use",
-                    text: event.delta.type === "text_delta" ? "" : void 0
-                  };
-                  if (event.delta.type === "input_json_delta") {
-                    inputJSONBuffers.set(blockIndex, "");
-                  }
-                }
-                if (event.delta.type === "text_delta") {
-                  contentBlocks[blockIndex].text += event.delta.text;
-                  const currentState = getStreamingState();
-                  setStreamingState({
-                    receivedChars: (currentState.receivedChars || 0) + event.delta.text.length
-                  });
-                } else if (event.delta.type === "input_json_delta") {
-                  const currentBuffer = inputJSONBuffers.get(blockIndex) || "";
-                  inputJSONBuffers.set(
-                    blockIndex,
-                    currentBuffer + event.delta.partial_json
-                  );
-                } else if (event.delta.type === "thinking_delta") {
-                  const currentThinking = contentBlocks[blockIndex].thinking || "";
-                  const updatedThinking = currentThinking + (event.delta.thinking || "");
-                  contentBlocks[blockIndex] = {
-                    ...contentBlocks[blockIndex],
-                    thinking: updatedThinking
-                  };
-                  setStreamingState({
-                    phase: "deep_thinking",
-                    tokenCount: updatedThinking.length,
-                    thinkingMaxTokens: maxThinkingTokens
-                  });
-                  debugLogger.trace("THINKING_DELTA", {
-                    index: blockIndex,
-                    tokenCount: updatedThinking.length
-                  });
-                }
-                break;
-              case "message_delta":
-                if (event.delta.stop_reason)
-                  stopReason = event.delta.stop_reason;
-                if (event.delta.stop_sequence)
-                  stopSequence = event.delta.stop_sequence;
-                if (event.usage) {
-                  usage = { ...usage, ...event.usage };
-                  setStreamingState({
-                    outputTokens: event.usage.output_tokens
-                  });
-                }
-                break;
-              case "content_block_stop":
-                const stopIndex = event.index;
-                const block = contentBlocks[stopIndex];
-                if (block?.type === "thinking") {
-                  const streamState2 = getStreamingState();
-                  const thinkingDurationMs = streamState2.thinkingStartTime ? Date.now() - streamState2.thinkingStartTime : 0;
-                  setStreamingState({
-                    phase: "generating",
-                    thinkingDurationMs
-                    // NEW: Store duration for display
-                  });
-                  debugLogger.flow("THINKING_BLOCK_COMPLETE", {
-                    index: stopIndex,
-                    finalTokenCount: block.thinking?.length || 0,
-                    durationMs: thinkingDurationMs
-                  });
-                }
-                if (block?.type === "tool_use" && inputJSONBuffers.has(stopIndex)) {
-                  const jsonStr = inputJSONBuffers.get(stopIndex);
-                  if (jsonStr) {
-                    try {
-                      block.input = JSON.parse(jsonStr);
-                    } catch (error) {
-                      const errorMsg = error instanceof Error ? error.message : String(error);
-                      debugLogger.error("JSON_PARSE_ERROR", {
-                        blockIndex: stopIndex,
-                        jsonStr: jsonStr.length > 500 ? jsonStr.slice(0, 500) + "..." : jsonStr,
-                        error: errorMsg
-                      });
-                      block.input = {
-                        __parse_error__: true,
-                        __error_message__: `JSON parse failed: ${errorMsg}`,
-                        __raw_json_preview__: jsonStr.length > 200 ? jsonStr.slice(0, 200) + "..." : jsonStr
-                      };
-                    }
-                    inputJSONBuffers.delete(stopIndex);
-                  }
-                }
-                break;
-              case "message_stop":
-                inputJSONBuffers.clear();
-                break;
-            }
-            if (event.type === "message_stop") {
-              break;
-            }
-          }
-          if (!finalResponse || !messageStartEvent) {
-            throw new Error("Stream ended without proper message structure");
-          }
-          finalResponse = {
-            ...messageStartEvent.message,
-            content: contentBlocks.filter(Boolean),
-            stop_reason: stopReason,
-            stop_sequence: stopSequence,
-            usage: {
-              ...messageStartEvent.message.usage,
-              ...usage
-            }
-          };
-          return finalResponse;
-        } else {
-          debugLogger.api("ANTHROPIC_API_CALL_START_NON_STREAMING", {
-            endpoint: modelProfile?.baseURL || "DEFAULT_ANTHROPIC",
-            model,
-            provider,
-            apiKeyConfigured: !!modelProfile?.apiKey,
-            apiKeyPrefix: modelProfile?.apiKey ? modelProfile.apiKey.substring(0, 8) : null,
-            maxTokens: params.max_tokens,
-            temperature: MAIN_QUERY_TEMPERATURE,
-            messageCount: params.messages?.length || 0,
-            streamMode: false,
-            toolsCount: toolSchemas.length,
-            thinkingTokens: maxThinkingTokens,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            modelProfileId: modelProfile?.modelName,
-            modelProfileName: modelProfile?.name
-          });
-          return await anthropic.beta.messages.create(params, {
-            signal
-            // ← CRITICAL: Connect the AbortSignal to API call
-          });
-        }
-      },
-      {
-        signal,
-        // Pass retry events to agent transcript for UI display
-        onRetry: toolUseContext?.agentId ? ({ attempt, maxRetries, error, delayMs }) => {
-          addRetryEventToTranscript(toolUseContext.agentId, {
-            attempt,
-            maxRetries,
-            errorMessage: error.message,
-            delayMs
-          });
-        } : void 0
-      }
-    );
-    debugLogger.api("ANTHROPIC_API_CALL_SUCCESS", {
-      content: response.content
-    });
-    const ttftMs = start - Date.now();
-    const durationMs = Date.now() - startIncludingRetries;
-    const content = response.content.map((block) => {
-      if (block.type === "text") {
-        return {
-          type: "text",
-          text: block.text
-        };
-      } else if (block.type === "tool_use") {
-        return {
-          type: "tool_use",
-          id: block.id,
-          name: block.name,
-          input: block.input
-        };
-      }
-      return block;
-    });
-    const thinkingBlocks = content.filter(
-      (block) => block.type === "thinking"
-    );
-    const streamState = getStreamingState();
-    const thinkingMetadata = thinkingBlocks.length > 0 ? {
-      charCount: thinkingBlocks.reduce(
-        (sum, b) => sum + (b.thinking?.length || 0),
-        0
-      ),
-      durationMs: streamState.thinkingDurationMs || 0,
-      startTime: streamState.thinkingStartTime || Date.now(),
-      isComplete: true
-    } : void 0;
-    const assistantMessage = {
-      message: {
-        id: response.id,
-        content,
-        model: response.model,
-        role: "assistant",
-        stop_reason: response.stop_reason,
-        stop_sequence: response.stop_sequence,
-        type: "message",
-        usage: response.usage
-      },
-      type: "assistant",
-      uuid: nanoid(),
-      durationMs,
-      costUSD: 0,
-      // Will be calculated below
-      thinkingMetadata
-    };
-    const systemMessages = system.map((block) => ({
-      role: "system",
-      content: block.text
-    }));
-    logLLMInteraction({
-      systemPrompt: systemPrompt.join("\n"),
-      messages: [...systemMessages, ...anthropicMessages],
-      response,
-      usage: response.usage ? {
-        inputTokens: response.usage.input_tokens,
-        outputTokens: response.usage.output_tokens
-      } : void 0,
-      timing: {
-        start,
-        end: Date.now()
-      },
-      apiFormat: "anthropic"
-    });
-    const inputTokens = response.usage.input_tokens;
-    const outputTokens = response.usage.output_tokens;
-    const cacheCreationInputTokens = response.usage.cache_creation_input_tokens ?? 0;
-    const cacheReadInputTokens = response.usage.cache_read_input_tokens ?? 0;
-    const costUSD = inputTokens / 1e6 * getModelInputTokenCostUSD(model) + outputTokens / 1e6 * getModelOutputTokenCostUSD(model) + cacheCreationInputTokens / 1e6 * getModelInputTokenCostUSD(model) + cacheReadInputTokens / 1e6 * (getModelInputTokenCostUSD(model) * 0.1);
-    assistantMessage.costUSD = costUSD;
-    addToTotalCost(costUSD, durationMs);
-    recordTokenUsage(
-      {
-        inputTokens,
-        outputTokens,
-        cacheCreationTokens: cacheCreationInputTokens,
-        cacheReadTokens: cacheReadInputTokens
-      },
-      costUSD,
-      model,
-      toolUseContext ? {
-        agentId: toolUseContext.agentId,
-        toolUseId: toolUseContext.toolUseId,
-        model
-      } : void 0
-    );
-    return assistantMessage;
-  } catch (error) {
-    return getAssistantMessageFromError(error);
-  }
-}
-function getAssistantMessageFromError(error) {
-  if (error instanceof Error && error.message.includes("prompt is too long")) {
-    return createAssistantAPIErrorMessage(PROMPT_TOO_LONG_ERROR_MESSAGE);
-  }
-  if (error instanceof Error && error.message.includes("Your credit balance is too low")) {
-    return createAssistantAPIErrorMessage(CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE);
-  }
-  if (error instanceof Error && error.message.toLowerCase().includes("x-api-key")) {
-    return createAssistantAPIErrorMessage(INVALID_API_KEY_ERROR_MESSAGE);
-  }
-  if (error instanceof Error) {
-    if (process.env.NODE_ENV === "development") {
-      debugLogger.error("ANTHROPIC_API_ERROR", {
-        message: error.message,
-        stack: error.stack
-      });
-    }
-    return createAssistantAPIErrorMessage(
-      `${API_ERROR_MESSAGE_PREFIX}: ${error.message}`
-    );
-  }
-  return createAssistantAPIErrorMessage(API_ERROR_MESSAGE_PREFIX);
-}
-function addCacheBreakpoints(messages) {
-  return messages.map((msg, index) => {
-    return msg.type === "user" ? userMessageToMessageParam(msg, index > messages.length - 3) : assistantMessageToMessageParam(msg, index > messages.length - 3);
-  });
-}
-async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, signal, options) {
-  const config = getGlobalConfig();
-  const modelManager = getModelManager();
-  const toolUseContext = options?.toolUseContext;
-  const modelProfile = options?.modelProfile || modelManager.getModel("main");
-  let model;
-  const currentRequest = getCurrentRequest();
-  debugLogger.api("MODEL_CONFIG_OPENAI", {
-    modelProfileFound: !!modelProfile,
-    modelProfileId: modelProfile?.modelName,
-    modelProfileName: modelProfile?.name,
-    modelProfileModelName: modelProfile?.modelName,
-    modelProfileProvider: modelProfile?.provider,
-    modelProfileBaseURL: modelProfile?.baseURL,
-    modelProfileApiKeyExists: !!modelProfile?.apiKey,
-    optionsModel: options?.model,
-    requestId: getCurrentRequest()?.id
-  });
-  if (modelProfile) {
-    model = modelProfile.modelName;
-  } else {
-    model = options?.model || modelProfile?.modelName || "";
-  }
-  if (options?.prependCLISysprompt) {
-    const [firstSyspromptBlock] = splitSysPromptPrefix(systemPrompt);
-    systemPrompt = [getCLISyspromptPrefix() + systemPrompt];
-  }
-  const system = splitSysPromptPrefix(systemPrompt).map(
-    (_) => ({
-      ...PROMPT_CACHING_ENABLED ? { cache_control: { type: "ephemeral" } } : {},
-      text: _,
-      type: "text"
-    })
-  );
-  const toolSchemas = await Promise.all(
-    tools.map(
-      async (_) => ({
-        type: "function",
-        function: {
-          name: _.name,
-          description: await _.prompt({
-            safeMode: options?.safeMode
-          }),
-          // Use tool's JSON schema directly if provided, otherwise convert Zod schema
-          parameters: "inputJSONSchema" in _ && _.inputJSONSchema ? _.inputJSONSchema : zodToJsonSchema(_.inputSchema)
-        }
-      })
-    )
-  );
-  const openaiSystem = system.map(
-    (s) => ({
-      role: "system",
-      content: s.text
-    })
-  );
-  const openaiMessages = convertAnthropicMessagesToOpenAIMessages(messages);
-  const startIncludingRetries = Date.now();
-  logSystemPromptConstruction({
-    basePrompt: systemPrompt.join("\n"),
-    mintoContext: generateMintoContext() || "",
-    reminders: [],
-    // 这里可以从 generateSystemReminders 获取
-    finalPrompt: systemPrompt.join("\n")
-  });
-  let start = Date.now();
-  let attemptNumber = 0;
-  let response;
-  try {
-    response = await withRetry(
-      async (attempt) => {
-        attemptNumber = attempt;
-        start = Date.now();
-        const maxTokens = getMaxTokensFromProfile(modelProfile);
-        const isGPT5 = isGPT5Model(model);
-        const opts = {
-          model,
-          ...isGPT5 ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens },
-          messages: [...openaiSystem, ...openaiMessages],
-          temperature: isGPT5 ? 1 : MAIN_QUERY_TEMPERATURE
-        };
-        if (config.stream) {
-          ;
-          opts.stream = true;
-          opts.stream_options = {
-            include_usage: true
-          };
-        }
-        if (toolSchemas.length > 0) {
-          opts.tools = toolSchemas;
-          opts.tool_choice = "auto";
-        }
-        const reasoningEffort = await getReasoningEffort(modelProfile, messages);
-        if (reasoningEffort) {
-          opts.reasoning_effort = reasoningEffort;
-        }
-        if (modelProfile && modelProfile.modelName) {
-          debugLogger.api("USING_MODEL_PROFILE_PATH", {
-            modelProfileName: modelProfile.modelName,
-            modelName: modelProfile.modelName,
-            provider: modelProfile.provider,
-            baseURL: modelProfile.baseURL,
-            apiKeyExists: !!modelProfile.apiKey,
-            requestId: getCurrentRequest()?.id
-          });
-          const USE_NEW_ADAPTER_SYSTEM = process.env.USE_NEW_ADAPTERS !== "false";
-          if (USE_NEW_ADAPTER_SYSTEM) {
-            const adapter = ModelAdapterFactory.createAdapter(modelProfile);
-            const unifiedParams = {
-              messages: openaiMessages,
-              systemPrompt: openaiSystem.map((s) => s.content),
-              tools,
-              maxTokens: getMaxTokensFromProfile(modelProfile),
-              stream: config.stream,
-              reasoningEffort,
-              temperature: isGPT5Model(model) ? 1 : MAIN_QUERY_TEMPERATURE,
-              previousResponseId: toolUseContext?.responseState?.previousResponseId,
-              verbosity: "high"
-              // High verbosity for coding tasks
-            };
-            const request = adapter.createRequest(unifiedParams);
-            if (ModelAdapterFactory.shouldUseResponsesAPI(modelProfile)) {
-              const { callGPT5ResponsesAPI } = await import("./openai.js");
-              const response2 = await callGPT5ResponsesAPI(
-                modelProfile,
-                request,
-                signal
-              );
-              const unifiedResponse = adapter.parseResponse(response2);
-              const apiMessage = {
-                role: "assistant",
-                content: unifiedResponse.content,
-                tool_calls: unifiedResponse.toolCalls,
-                usage: {
-                  prompt_tokens: unifiedResponse.usage.promptTokens,
-                  completion_tokens: unifiedResponse.usage.completionTokens
-                }
-              };
-              const assistantMsg = {
-                type: "assistant",
-                message: apiMessage,
-                costUSD: 0,
-                // Will be calculated later
-                durationMs: Date.now() - start,
-                uuid: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-                responseId: unifiedResponse.responseId
-                // For state management
-              };
-              return assistantMsg;
-            } else {
-              const s = await getCompletionWithProfile(
-                modelProfile,
-                request,
-                0,
-                10,
-                signal
-              );
-              let finalResponse;
-              if (config.stream) {
-                finalResponse = await handleMessageStream(
-                  s,
-                  signal
-                );
-              } else {
-                finalResponse = s;
-              }
-              const r = convertOpenAIResponseToAnthropic(finalResponse, tools);
-              return r;
-            }
-          } else {
-            const completionFunction = isGPT5Model(modelProfile.modelName) ? getGPT5CompletionWithProfile : getCompletionWithProfile;
-            const s = await completionFunction(
-              modelProfile,
-              opts,
-              0,
-              10,
-              signal
-            );
-            let finalResponse;
-            if (opts.stream) {
-              finalResponse = await handleMessageStream(
-                s,
-                signal
-              );
-            } else {
-              finalResponse = s;
-            }
-            const r = convertOpenAIResponseToAnthropic(finalResponse, tools);
-            return r;
-          }
-        } else {
-          debugLogger.api("USING_LEGACY_PATH", {
-            modelProfileExists: !!modelProfile,
-            modelProfileId: modelProfile?.modelName,
-            modelNameExists: !!modelProfile?.modelName,
-            fallbackModel: "main",
-            actualModel: model,
-            requestId: getCurrentRequest()?.id
-          });
-          const errorDetails = {
-            modelProfileExists: !!modelProfile,
-            modelProfileId: modelProfile?.modelName,
-            modelNameExists: !!modelProfile?.modelName,
-            requestedModel: model,
-            requestId: getCurrentRequest()?.id
-          };
-          debugLogger.error("NO_VALID_MODEL_PROFILE", errorDetails);
-          throw new Error(
-            `No valid ModelProfile available for model: ${model}. Please configure model through /model command. Debug: ${JSON.stringify(errorDetails)}`
-          );
-        }
-      },
-      {
-        signal,
-        // Pass retry events to agent transcript for UI display
-        onRetry: toolUseContext?.agentId ? ({ attempt, maxRetries, error, delayMs }) => {
-          addRetryEventToTranscript(toolUseContext.agentId, {
-            attempt,
-            maxRetries,
-            errorMessage: error.message,
-            delayMs
-          });
-        } : void 0
-      }
-    );
-  } catch (error) {
-    logError(error);
-    return getAssistantMessageFromError(error);
-  }
-  const durationMs = Date.now() - start;
-  const durationMsIncludingRetries = Date.now() - startIncludingRetries;
-  const inputTokens = response.usage?.prompt_tokens ?? 0;
-  const outputTokens = response.usage?.completion_tokens ?? 0;
-  const cacheReadInputTokens = response.usage?.prompt_token_details?.cached_tokens ?? 0;
-  const cacheCreationInputTokens = response.usage?.prompt_token_details?.cached_tokens ?? 0;
-  const costUSD = inputTokens / 1e6 * SONNET_COST_PER_MILLION_INPUT_TOKENS + outputTokens / 1e6 * SONNET_COST_PER_MILLION_OUTPUT_TOKENS + cacheReadInputTokens / 1e6 * SONNET_COST_PER_MILLION_PROMPT_CACHE_READ_TOKENS + cacheCreationInputTokens / 1e6 * SONNET_COST_PER_MILLION_PROMPT_CACHE_WRITE_TOKENS;
-  addToTotalCost(costUSD, durationMsIncludingRetries);
-  recordTokenUsage(
-    {
-      inputTokens,
-      outputTokens,
-      cacheCreationTokens: cacheCreationInputTokens,
-      cacheReadTokens: cacheReadInputTokens
-    },
-    costUSD,
-    model,
-    toolUseContext ? {
-      agentId: toolUseContext.agentId,
-      toolUseId: toolUseContext.toolUseId,
-      model
-    } : void 0
-  );
-  logLLMInteraction({
-    systemPrompt: systemPrompt.join("\n"),
-    messages: [...openaiSystem, ...openaiMessages],
-    response,
-    usage: {
-      inputTokens,
-      outputTokens
-    },
-    timing: {
-      start,
-      end: Date.now()
-    },
-    apiFormat: "openai"
-  });
-  return {
-    message: {
-      ...response,
-      content: normalizeContentFromAPI(response.content),
-      usage: {
-        input_tokens: inputTokens,
-        output_tokens: outputTokens,
-        cache_read_input_tokens: cacheReadInputTokens,
-        cache_creation_input_tokens: 0
-      }
-    },
-    costUSD,
-    durationMs,
-    type: "assistant",
-    uuid: randomUUID()
-  };
-}
-function getMaxTokensFromProfile(modelProfile) {
-  return modelProfile?.maxTokens || 8e3;
-}
-function getModelInputTokenCostUSD(model) {
-  for (const providerModels of Object.values(models)) {
-    const modelInfo = providerModels.find((m) => m.model === model);
-    if (modelInfo) {
-      return modelInfo.input_cost_per_token || 0;
-    }
-  }
-  return 3e-6;
-}
-function getModelOutputTokenCostUSD(model) {
-  for (const providerModels of Object.values(models)) {
-    const modelInfo = providerModels.find((m) => m.model === model);
-    if (modelInfo) {
-      return modelInfo.output_cost_per_token || 0;
-    }
-  }
-  return 15e-6;
-}
-async function queryModel(modelPointer, messages, systemPrompt = [], signal) {
-  return queryLLM(
-    messages,
-    systemPrompt,
-    0,
-    // maxThinkingTokens
-    [],
-    // tools
-    signal || new AbortController().signal,
-    {
-      safeMode: false,
-      model: modelPointer,
-      prependCLISysprompt: true
-    }
-  );
-}
-async function queryQuick({
-  systemPrompt = [],
-  userPrompt,
-  assistantPrompt,
-  enablePromptCaching = false,
-  signal
-}) {
-  const messages = [
-    {
-      message: { role: "user", content: userPrompt },
-      type: "user",
-      uuid: randomUUID()
-    }
-  ];
-  return queryModel("quick", messages, systemPrompt, signal);
-}
+  API_ERROR_MESSAGE_PREFIX,
+  PROMPT_TOO_LONG_ERROR_MESSAGE,
+  CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE,
+  INVALID_API_KEY_ERROR_MESSAGE,
+  NO_CONTENT_MESSAGE,
+  MAIN_QUERY_TEMPERATURE,
+  generateMintoContext,
+  refreshMintoContext,
+  fetchAnthropicModels,
+  verifyApiKey,
+  getAnthropicClient,
+  resetAnthropicClient,
+  userMessageToMessageParam,
+  assistantMessageToMessageParam,
+  queryLLM,
+  formatSystemPromptWithContext,
+  queryModel,
+  queryQuick
+} from "./llm/index.js";
 export {
   API_ERROR_MESSAGE_PREFIX,
   CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE,