@shareai-lab/kode 1.1.12 → 1.1.14

package/dist/services/claude.js

@@ -0,0 +1,1605 @@
+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 { createHash, randomUUID } from "crypto";
+import "dotenv/config";
+import { addToTotalCost } from "../cost-tracker.js";
+import models from "../constants/models.js";
+import {
+  getAnthropicApiKey,
+  getOrCreateUserID,
+  getGlobalConfig
+} from "../utils/config.js";
+import { getProjectDocs } from "../context.js";
+import { logError, SESSION_ID } from "../utils/log.js";
+import { USER_AGENT } from "../utils/http.js";
+import {
+  createAssistantAPIErrorMessage,
+  normalizeContentFromAPI
+} from "../utils/messages.js";
+import { logEvent } from "./statsig.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";
+function isGPT5Model(modelName) {
+  return modelName.startsWith("gpt-5");
+}
+function getModelConfigForDebug(model) {
+  const config = getGlobalConfig();
+  const modelManager = getModelManager();
+  const modelProfile = modelManager.getModel("main");
+  let apiKeyStatus = "missing";
+  let baseURL;
+  let maxTokens;
+  let reasoningEffort;
+  if (modelProfile) {
+    apiKeyStatus = modelProfile.apiKey ? "configured" : "missing";
+    baseURL = modelProfile.baseURL;
+    maxTokens = modelProfile.maxTokens;
+    reasoningEffort = modelProfile.reasoningEffort;
+  } else {
+    apiKeyStatus = "missing";
+    maxTokens = void 0;
+    reasoningEffort = void 0;
+  }
+  return {
+    modelName: model,
+    provider: modelProfile?.provider || config.primaryProvider || "anthropic",
+    apiKeyStatus,
+    baseURL,
+    maxTokens,
+    reasoningEffort,
+    isStream: config.stream || false,
+    temperature: MAIN_QUERY_TEMPERATURE
+  };
+}
+class KodeContextManager {
+  static instance;
+  projectDocsCache = "";
+  cacheInitialized = false;
+  initPromise = null;
+  constructor() {
+  }
+  static getInstance() {
+    if (!KodeContextManager.instance) {
+      KodeContextManager.instance = new KodeContextManager();
+    }
+    return KodeContextManager.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") {
+        console.log(
+          `[KodeContext] Loaded ${this.projectDocsCache.length} characters from project docs`
+        );
+      }
+    } catch (error) {
+      console.warn("[KodeContext] Failed to load project docs:", error);
+      this.projectDocsCache = "";
+      this.cacheInitialized = true;
+    }
+  }
+  getKodeContext() {
+    if (!this.cacheInitialized) {
+      this.initialize().catch(console.warn);
+      return "";
+    }
+    return this.projectDocsCache;
+  }
+  async refreshCache() {
+    this.cacheInitialized = false;
+    this.initPromise = null;
+    await this.initialize();
+  }
+}
+const kodeContextManager = KodeContextManager.getInstance();
+kodeContextManager.initialize().catch(console.warn);
+const generateKodeContext = () => {
+  return kodeContextManager.getKodeContext();
+};
+const refreshKodeContext = async () => {
+  await kodeContextManager.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 HAIKU_COST_PER_MILLION_INPUT_TOKENS = 0.8;
+const HAIKU_COST_PER_MILLION_OUTPUT_TOKENS = 4;
+const HAIKU_COST_PER_MILLION_PROMPT_CACHE_WRITE_TOKENS = 1;
+const HAIKU_COST_PER_MILLION_PROMPT_CACHE_READ_TOKENS = 0.08;
+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 abortableDelay(delayMs, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Request was aborted"));
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      resolve();
+    }, delayMs);
+    if (signal) {
+      const abortHandler = () => {
+        clearTimeout(timeoutId);
+        reject(new Error("Request was aborted"));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+  });
+}
+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);
+      console.log(
+        `  \u23BF  ${chalk.red(`API ${error.name} (${error.message}) \xB7 Retrying in ${Math.round(delayMs / 1e3)} seconds\u2026 (attempt ${attempt}/${maxRetries})`)}`
+      );
+      logEvent("tengu_api_retry", {
+        attempt: String(attempt),
+        delayMs: String(delayMs),
+        error: error.message,
+        status: String(error.status),
+        provider: USE_BEDROCK ? "bedrock" : USE_VERTEX ? "vertex" : "1p"
+      });
+      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;
+    }
+    console.error("Failed to fetch Anthropic models:", 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) {
+        console.warn(
+          "No baseURL provided for non-Anthropic provider verification"
+        );
+        return false;
+      }
+      const modelsURL = `${baseURL.replace(/\/+$/, "")}/models`;
+      const response = await fetch(modelsURL, {
+        method: "GET",
+        headers
+      });
+      return response.ok;
+    } catch (error) {
+      console.warn("API verification failed for non-Anthropic provider:", 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) {
+          usage = chunk.usage;
+        }
+        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) {
+    logEvent("weird_response", {
+      response: JSON.stringify(response)
+    });
+    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 = {};
+      try {
+        toolArgs = tool?.arguments ? JSON.parse(tool.arguments) : {};
+      } catch (e) {
+      }
+      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 kodeContext = generateKodeContext();
+      if (kodeContext) {
+        enhancedPrompt.push("\n---\n# \u9879\u76EE\u4E0A\u4E0B\u6587\n");
+        enhancedPrompt.push(kodeContext);
+        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);
+    logEvent("tengu_sysprompt_block", {
+      snippet: firstSyspromptBlock?.slice(0, 20),
+      length: String(firstSyspromptBlock?.length ?? 0),
+      hash: firstSyspromptBlock ? createHash("sha256").update(firstSyspromptBlock).digest("hex") : ""
+    });
+    systemPrompt = [getCLISyspromptPrefix(), ...systemPrompt];
+  }
+  const system = splitSysPromptPrefix(systemPrompt).map(
+    (_) => ({
+      text: _,
+      type: "text"
+    })
+  );
+  const toolSchemas = await Promise.all(
+    tools.map(
+      async (tool) => ({
+        name: tool.name,
+        description: typeof tool.description === "function" ? await tool.description() : tool.description,
+        input_schema: zodToJsonSchema(tool.inputSchema)
+      })
+    )
+  );
+  const anthropicMessages = addCacheBreakpoints(messages);
+  const { systemBlocks: processedSystem, messageParams: processedMessages } = applyCacheControlWithLimits(system, anthropicMessages);
+  const startIncludingRetries = Date.now();
+  logSystemPromptConstruction({
+    basePrompt: systemPrompt.join("\n"),
+    kodeContext: generateKodeContext() || "",
+    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
+              };
+              break;
+            case "content_block_start":
+              contentBlocks[event.index] = { ...event.content_block };
+              if (event.content_block.type === "tool_use") {
+                inputJSONBuffers.set(event.index, "");
+              }
+              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;
+              } else if (event.delta.type === "input_json_delta") {
+                const currentBuffer = inputJSONBuffers.get(blockIndex) || "";
+                inputJSONBuffers.set(blockIndex, currentBuffer + event.delta.partial_json);
+              }
+              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 };
+              break;
+            case "content_block_stop":
+              const stopIndex = event.index;
+              const block = contentBlocks[stopIndex];
+              if (block?.type === "tool_use" && inputJSONBuffers.has(stopIndex)) {
+                const jsonStr = inputJSONBuffers.get(stopIndex);
+                if (jsonStr) {
+                  try {
+                    block.input = JSON.parse(jsonStr);
+                  } catch (error) {
+                    debugLogger.error("JSON_PARSE_ERROR", {
+                      blockIndex: stopIndex,
+                      jsonStr,
+                      error: error instanceof Error ? error.message : String(error)
+                    });
+                    block.input = {};
+                  }
+                  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 });
+    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 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
+    };
+    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);
+    logEvent("api_response_anthropic_native", {
+      model,
+      input_tokens: String(inputTokens),
+      output_tokens: String(outputTokens),
+      cache_creation_input_tokens: String(cacheCreationInputTokens),
+      cache_read_input_tokens: String(cacheReadInputTokens),
+      cost_usd: String(costUSD),
+      duration_ms: String(durationMs),
+      ttft_ms: String(ttftMs),
+      attempt_number: String(attemptNumber)
+    });
+    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") {
+      console.log(error);
+    }
+    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);
+    logEvent("tengu_sysprompt_block", {
+      snippet: firstSyspromptBlock?.slice(0, 20),
+      length: String(firstSyspromptBlock?.length ?? 0),
+      hash: firstSyspromptBlock ? createHash("sha256").update(firstSyspromptBlock).digest("hex") : ""
+    });
+    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"),
+    kodeContext: generateKodeContext() || "",
+    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) {
+        logEvent("debug_reasoning_effort", {
+          effort: 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 });
+  } 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);
+  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);
+}
+export {
+  API_ERROR_MESSAGE_PREFIX,
+  CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE,
+  INVALID_API_KEY_ERROR_MESSAGE,
+  MAIN_QUERY_TEMPERATURE,
+  NO_CONTENT_MESSAGE,
+  PROMPT_TOO_LONG_ERROR_MESSAGE,
+  assistantMessageToMessageParam,
+  fetchAnthropicModels,
+  formatSystemPromptWithContext,
+  generateKodeContext,
+  getAnthropicClient,
+  queryLLM,
+  queryModel,
+  queryQuick,
+  refreshKodeContext,
+  resetAnthropicClient,
+  userMessageToMessageParam,
+  verifyApiKey
+};
+//# sourceMappingURL=claude.js.map