@shareai-lab/kode 1.2.0 → 2.0.1

package/dist/services/claude.js

@@ -1,1605 +0,0 @@
-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