@within-7/minto 0.4.1 → 0.4.3

package/dist/services/llm/anthropicProvider.js

@@ -1,807 +0,0 @@
-import "@anthropic-ai/sdk/shims/node";
-import Anthropic from "@anthropic-ai/sdk";
-import { AnthropicBedrock } from "@anthropic-ai/bedrock-sdk";
-import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";
-import chalk from "chalk";
-import { nanoid } from "nanoid";
-import "dotenv/config";
-import { getToolDescriptionAsync } from "../../Tool.js";
-import {
-  getAnthropicApiKey,
-  getGlobalConfig
-} from "../../utils/config.js";
-import { USER_AGENT } from "../../utils/http.js";
-import {
-  createAssistantAPIErrorMessage
-} from "../../utils/messages.js";
-import {
-  debug as debugLogger,
-  getCurrentRequest,
-  logLLMInteraction,
-  logSystemPromptConstruction
-} from "../../utils/debugLogger.js";
-import { getModelManager } from "../../utils/model.js";
-import { USE_BEDROCK, USE_VERTEX, getVertexRegionForModel } from "../../utils/model.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
-import { getCLISyspromptPrefix } from "../../constants/prompts/index.js";
-import { setStreamingState, getStreamingState } from "../../utils/streamingState.js";
-import { addRetryEventToTranscript } from "../../utils/agentTranscripts.js";
-import { generateMintoContext } from "./mintoContext.js";
-import {
-  API_ERROR_MESSAGE_PREFIX,
-  PROMPT_TOO_LONG_ERROR_MESSAGE,
-  CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE,
-  INVALID_API_KEY_ERROR_MESSAGE,
-  PROMPT_CACHING_ENABLED,
-  MAIN_QUERY_TEMPERATURE,
-  getMetadata,
-  withRetry,
-  getMaxTokensFromProfile,
-  getModelInputTokenCostUSD,
-  getModelOutputTokenCostUSD,
-  addToTotalCost,
-  recordTokenUsage,
-  logError
-} from "./types.js";
-let anthropicClient = null;
-function getAnthropicClient(model, overrideProfile) {
-  const config = getGlobalConfig();
-  const provider = config.primaryProvider;
-  if (overrideProfile) {
-    const overrideHeaders = {
-      "x-app": "cli",
-      "User-Agent": USER_AGENT
-    };
-    return new Anthropic({
-      apiKey: overrideProfile.apiKey || "",
-      dangerouslyAllowBrowser: true,
-      maxRetries: 0,
-      timeout: parseInt(process.env.API_TIMEOUT_MS || String(60 * 1e3), 10),
-      defaultHeaders: overrideHeaders,
-      ...overrideProfile.baseURL && { baseURL: overrideProfile.baseURL }
-    });
-  }
-  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;
-}
-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
-      },
-      signal: AbortSignal.timeout(3e4)
-    });
-    if (!response.ok) {
-      if (response.status === 401) {
-        throw new Error(
-          "Invalid API key. Please check your Anthropic API key and try again."
-        );
-      } else if (response.status === 403) {
-        throw new Error(
-          "API key does not have permission to access models. Please check your API key permissions."
-        );
-      } else if (response.status === 429) {
-        throw new Error(
-          "Too many requests. Please wait a moment and try again."
-        );
-      } else if (response.status >= 500) {
-        throw new Error(
-          "Anthropic service is temporarily unavailable. Please try again later."
-        );
-      } else {
-        throw new Error(
-          `Unable to connect to Anthropic API (${response.status}). Please check your internet connection and API key.`
-        );
-      }
-    }
-    const data = await response.json();
-    return data.data || [];
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("API key") || error instanceof Error && error.message.includes("Anthropic")) {
-      throw error;
-    }
-    logError(error);
-    throw new Error(
-      "Unable to connect to Anthropic API. Please check your internet connection and try again."
-    );
-  }
-}
-async function verifyApiKey(apiKey, baseURL, provider) {
-  if (!apiKey) {
-    return false;
-  }
-  if (provider && provider !== "anthropic") {
-    try {
-      const headers = {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      };
-      if (!baseURL) {
-        debugLogger.warn("API_VERIFY", {
-          error: "No baseURL provided for non-Anthropic provider"
-        });
-        return false;
-      }
-      const modelsURL = `${baseURL.replace(/\/+$/, "")}/models`;
-      const response = await fetch(modelsURL, {
-        method: "GET",
-        headers,
-        signal: AbortSignal.timeout(3e4)
-      });
-      return response.ok;
-    } catch (error) {
-      debugLogger.warn("API_VERIFY", {
-        error: "non-Anthropic provider verification failed",
-        details: String(error)
-      });
-      return false;
-    }
-  }
-  const clientConfig = {
-    apiKey,
-    dangerouslyAllowBrowser: true,
-    maxRetries: 3,
-    defaultHeaders: {
-      "User-Agent": USER_AGENT
-    }
-  };
-  if (baseURL && (provider === "anthropic" || provider === "bigdream" || provider === "opendev")) {
-    clientConfig.baseURL = baseURL;
-  }
-  const anthropic = new Anthropic(clientConfig);
-  try {
-    await withRetry(
-      async () => {
-        const model = "claude-sonnet-4-20250514";
-        const messages = [{ role: "user", content: "test" }];
-        await anthropic.messages.create({
-          model,
-          max_tokens: 1e3,
-          // Simple test token limit for API verification
-          messages,
-          temperature: 0,
-          metadata: getMetadata()
-        });
-        return true;
-      },
-      { maxRetries: 2 }
-      // Use fewer retries for API key verification
-    );
-    return true;
-  } catch (error) {
-    logError(error);
-    if (error instanceof Error && error.message.includes(
-      '{"type":"error","error":{"type":"authentication_error","message":"invalid x-api-key"}}'
-    )) {
-      return false;
-    }
-    throw error;
-  }
-}
-function 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);
-}
-function addCacheBreakpoints(messages) {
-  return messages.map((msg, index) => {
-    return msg.type === "user" ? userMessageToMessageParam(msg, index > messages.length - 3) : assistantMessageToMessageParam(msg, index > messages.length - 3);
-  });
-}
-function getAssistantMessageFromError(error) {
-  if (error instanceof Error && error.message.includes("prompt is too long")) {
-    return createAssistantAPIErrorMessage(PROMPT_TOO_LONG_ERROR_MESSAGE);
-  }
-  if (error instanceof Error && error.message.includes("Your credit balance is too low")) {
-    return createAssistantAPIErrorMessage(CREDIT_BALANCE_TOO_LOW_ERROR_MESSAGE);
-  }
-  if (error instanceof Error && error.message.toLowerCase().includes("x-api-key")) {
-    return createAssistantAPIErrorMessage(INVALID_API_KEY_ERROR_MESSAGE);
-  }
-  if (error instanceof Error) {
-    if (process.env.NODE_ENV === "development") {
-      debugLogger.error("ANTHROPIC_API_ERROR", {
-        message: error.message,
-        stack: error.stack
-      });
-    }
-    return createAssistantAPIErrorMessage(
-      `${API_ERROR_MESSAGE_PREFIX}: ${error.message}`
-    );
-  }
-  return createAssistantAPIErrorMessage(API_ERROR_MESSAGE_PREFIX);
-}
-async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, tools, signal, options) {
-  const config = getGlobalConfig();
-  const modelManager = getModelManager();
-  const toolUseContext = options?.toolUseContext;
-  const modelProfile = options?.modelProfile || modelManager.getModel("main");
-  let anthropic;
-  let model;
-  let provider;
-  debugLogger.api("MODEL_CONFIG_ANTHROPIC", {
-    modelProfileFound: !!modelProfile,
-    modelProfileId: modelProfile?.modelName,
-    modelProfileName: modelProfile?.name,
-    modelProfileModelName: modelProfile?.modelName,
-    modelProfileProvider: modelProfile?.provider,
-    modelProfileBaseURL: modelProfile?.baseURL,
-    modelProfileApiKeyExists: !!modelProfile?.apiKey,
-    optionsModel: options?.model,
-    requestId: getCurrentRequest()?.id
-  });
-  if (modelProfile) {
-    model = modelProfile.modelName;
-    provider = modelProfile.provider || config.primaryProvider || "anthropic";
-    if (modelProfile.provider === "anthropic" || modelProfile.provider === "bigdream" || modelProfile.provider === "opendev") {
-      const clientConfig = {
-        apiKey: modelProfile.apiKey,
-        dangerouslyAllowBrowser: true,
-        maxRetries: 0,
-        timeout: parseInt(process.env.API_TIMEOUT_MS || String(60 * 1e3), 10),
-        defaultHeaders: {
-          "x-app": "cli",
-          "User-Agent": USER_AGENT
-        }
-      };
-      if (modelProfile.baseURL) {
-        clientConfig.baseURL = modelProfile.baseURL;
-      }
-      anthropic = new Anthropic(clientConfig);
-    } else {
-      anthropic = getAnthropicClient(model);
-    }
-  } else {
-    const errorDetails = {
-      modelProfileExists: !!modelProfile,
-      modelProfileModelName: modelProfile?.modelName,
-      requestedModel: options?.model,
-      requestId: getCurrentRequest()?.id
-    };
-    debugLogger.error("ANTHROPIC_FALLBACK_ERROR", errorDetails);
-    throw new Error(
-      `No valid ModelProfile available for Anthropic provider. Please configure model through /model command. Debug: ${JSON.stringify(errorDetails)}`
-    );
-  }
-  if (options?.prependCLISysprompt) {
-    const [firstSyspromptBlock] = splitSysPromptPrefix(systemPrompt);
-    systemPrompt = [getCLISyspromptPrefix(), ...systemPrompt];
-  }
-  const system = splitSysPromptPrefix(systemPrompt).map(
-    (_) => ({
-      text: _,
-      type: "text"
-    })
-  );
-  const toolSchemas = await Promise.all(
-    tools.map(
-      async (tool) => ({
-        name: tool.name,
-        description: await getToolDescriptionAsync(tool),
-        input_schema: "inputJSONSchema" in tool && tool.inputJSONSchema ? tool.inputJSONSchema : zodToJsonSchema(tool.inputSchema)
-      })
-    )
-  );
-  const anthropicMessages = addCacheBreakpoints(messages);
-  const { systemBlocks: processedSystem, messageParams: processedMessages } = applyCacheControlWithLimits(system, anthropicMessages);
-  const startIncludingRetries = Date.now();
-  logSystemPromptConstruction({
-    basePrompt: systemPrompt.join("\n"),
-    mintoContext: generateMintoContext() || "",
-    reminders: [],
-    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
-            }
-          );
-          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: []
-                };
-                setStreamingState({
-                  inputTokens: event.message.usage?.input_tokens,
-                  receivedChars: 0
-                });
-                break;
-              case "content_block_start":
-                contentBlocks[event.index] = { ...event.content_block };
-                if (event.content_block.type === "tool_use") {
-                  inputJSONBuffers.set(event.index, "");
-                }
-                if (event.content_block.type === "thinking") {
-                  const thinkingStartTime = Date.now();
-                  setStreamingState({
-                    phase: "deep_thinking",
-                    tokenCount: 0,
-                    thinkingMaxTokens: maxThinkingTokens,
-                    thinkingStartTime
-                  });
-                  debugLogger.flow("THINKING_BLOCK_START", {
-                    index: event.index,
-                    maxTokens: maxThinkingTokens,
-                    startTime: thinkingStartTime
-                  });
-                }
-                break;
-              case "content_block_delta":
-                const blockIndex = event.index;
-                if (!contentBlocks[blockIndex]) {
-                  contentBlocks[blockIndex] = {
-                    type: event.delta.type === "text_delta" ? "text" : "tool_use",
-                    text: event.delta.type === "text_delta" ? "" : void 0
-                  };
-                  if (event.delta.type === "input_json_delta") {
-                    inputJSONBuffers.set(blockIndex, "");
-                  }
-                }
-                if (event.delta.type === "text_delta") {
-                  contentBlocks[blockIndex].text += event.delta.text;
-                  const currentState = getStreamingState();
-                  setStreamingState({
-                    receivedChars: (currentState.receivedChars || 0) + event.delta.text.length
-                  });
-                } else if (event.delta.type === "input_json_delta") {
-                  const currentBuffer = inputJSONBuffers.get(blockIndex) || "";
-                  inputJSONBuffers.set(
-                    blockIndex,
-                    currentBuffer + event.delta.partial_json
-                  );
-                } else if (event.delta.type === "thinking_delta") {
-                  const currentThinking = contentBlocks[blockIndex].thinking || "";
-                  const updatedThinking = currentThinking + (event.delta.thinking || "");
-                  contentBlocks[blockIndex] = {
-                    ...contentBlocks[blockIndex],
-                    thinking: updatedThinking
-                  };
-                  setStreamingState({
-                    phase: "deep_thinking",
-                    tokenCount: updatedThinking.length,
-                    thinkingMaxTokens: maxThinkingTokens
-                  });
-                  debugLogger.trace("THINKING_DELTA", {
-                    index: blockIndex,
-                    tokenCount: updatedThinking.length
-                  });
-                }
-                break;
-              case "message_delta":
-                if (event.delta.stop_reason)
-                  stopReason = event.delta.stop_reason;
-                if (event.delta.stop_sequence)
-                  stopSequence = event.delta.stop_sequence;
-                if (event.usage) {
-                  usage = { ...usage, ...event.usage };
-                  setStreamingState({
-                    outputTokens: event.usage.output_tokens
-                  });
-                }
-                break;
-              case "content_block_stop":
-                const stopIndex = event.index;
-                const block = contentBlocks[stopIndex];
-                if (block?.type === "thinking") {
-                  const streamState2 = getStreamingState();
-                  const thinkingDurationMs = streamState2.thinkingStartTime ? Date.now() - streamState2.thinkingStartTime : 0;
-                  setStreamingState({
-                    phase: "generating",
-                    thinkingDurationMs
-                  });
-                  debugLogger.flow("THINKING_BLOCK_COMPLETE", {
-                    index: stopIndex,
-                    finalTokenCount: block.thinking?.length || 0,
-                    durationMs: thinkingDurationMs
-                  });
-                }
-                if (block?.type === "tool_use" && inputJSONBuffers.has(stopIndex)) {
-                  const jsonStr = inputJSONBuffers.get(stopIndex);
-                  if (jsonStr) {
-                    try {
-                      block.input = JSON.parse(jsonStr);
-                    } catch (error) {
-                      const errorMsg = error instanceof Error ? error.message : String(error);
-                      debugLogger.error("JSON_PARSE_ERROR", {
-                        blockIndex: stopIndex,
-                        jsonStr: jsonStr.length > 500 ? jsonStr.slice(0, 500) + "..." : jsonStr,
-                        error: errorMsg
-                      });
-                      block.input = {
-                        __parse_error__: true,
-                        __error_message__: `JSON parse failed: ${errorMsg}`,
-                        __raw_json_preview__: jsonStr.length > 200 ? jsonStr.slice(0, 200) + "..." : jsonStr
-                      };
-                    }
-                    inputJSONBuffers.delete(stopIndex);
-                  }
-                }
-                break;
-              case "message_stop":
-                inputJSONBuffers.clear();
-                break;
-            }
-            if (event.type === "message_stop") {
-              break;
-            }
-          }
-          if (!finalResponse || !messageStartEvent) {
-            throw new Error("Stream ended without proper message structure");
-          }
-          finalResponse = {
-            ...messageStartEvent.message,
-            content: contentBlocks.filter(Boolean),
-            stop_reason: stopReason,
-            stop_sequence: stopSequence,
-            usage: {
-              ...messageStartEvent.message.usage,
-              ...usage
-            }
-          };
-          return finalResponse;
-        } else {
-          debugLogger.api("ANTHROPIC_API_CALL_START_NON_STREAMING", {
-            endpoint: modelProfile?.baseURL || "DEFAULT_ANTHROPIC",
-            model,
-            provider,
-            apiKeyConfigured: !!modelProfile?.apiKey,
-            apiKeyPrefix: modelProfile?.apiKey ? modelProfile.apiKey.substring(0, 8) : null,
-            maxTokens: params.max_tokens,
-            temperature: MAIN_QUERY_TEMPERATURE,
-            messageCount: params.messages?.length || 0,
-            streamMode: false,
-            toolsCount: toolSchemas.length,
-            thinkingTokens: maxThinkingTokens,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            modelProfileId: modelProfile?.modelName,
-            modelProfileName: modelProfile?.name
-          });
-          return await anthropic.beta.messages.create(params, {
-            signal
-          });
-        }
-      },
-      {
-        signal,
-        onRetry: toolUseContext?.agentId ? ({ attempt, maxRetries, error, delayMs }) => {
-          addRetryEventToTranscript(toolUseContext.agentId, {
-            attempt,
-            maxRetries,
-            errorMessage: error.message,
-            delayMs
-          });
-        } : void 0
-      }
-    );
-    debugLogger.api("ANTHROPIC_API_CALL_SUCCESS", {
-      content: response.content
-    });
-    const ttftMs = start - Date.now();
-    const durationMs = Date.now() - startIncludingRetries;
-    const content = response.content.map((block) => {
-      if (block.type === "text") {
-        return {
-          type: "text",
-          text: block.text
-        };
-      } else if (block.type === "tool_use") {
-        return {
-          type: "tool_use",
-          id: block.id,
-          name: block.name,
-          input: block.input
-        };
-      }
-      return block;
-    });
-    const thinkingBlocks = content.filter(
-      (block) => block.type === "thinking"
-    );
-    const streamState = getStreamingState();
-    const thinkingMetadata = thinkingBlocks.length > 0 ? {
-      charCount: thinkingBlocks.reduce(
-        (sum, b) => sum + (b.thinking?.length || 0),
-        0
-      ),
-      durationMs: streamState.thinkingDurationMs || 0,
-      startTime: streamState.thinkingStartTime || Date.now(),
-      isComplete: true
-    } : void 0;
-    const assistantMessage = {
-      message: {
-        id: response.id,
-        content,
-        model: response.model,
-        role: "assistant",
-        stop_reason: response.stop_reason,
-        stop_sequence: response.stop_sequence,
-        type: "message",
-        usage: response.usage
-      },
-      type: "assistant",
-      uuid: nanoid(),
-      durationMs,
-      costUSD: 0,
-      // Will be calculated below
-      thinkingMetadata
-    };
-    const systemMessages = system.map((block) => ({
-      role: "system",
-      content: block.text
-    }));
-    logLLMInteraction({
-      systemPrompt: systemPrompt.join("\n"),
-      messages: [...systemMessages, ...anthropicMessages],
-      response,
-      usage: response.usage ? {
-        inputTokens: response.usage.input_tokens,
-        outputTokens: response.usage.output_tokens
-      } : void 0,
-      timing: {
-        start,
-        end: Date.now()
-      },
-      apiFormat: "anthropic"
-    });
-    const inputTokens = response.usage.input_tokens;
-    const outputTokens = response.usage.output_tokens;
-    const cacheCreationInputTokens = response.usage.cache_creation_input_tokens ?? 0;
-    const cacheReadInputTokens = response.usage.cache_read_input_tokens ?? 0;
-    const costUSD = inputTokens / 1e6 * getModelInputTokenCostUSD(model) + outputTokens / 1e6 * getModelOutputTokenCostUSD(model) + cacheCreationInputTokens / 1e6 * getModelInputTokenCostUSD(model) + cacheReadInputTokens / 1e6 * (getModelInputTokenCostUSD(model) * 0.1);
-    assistantMessage.costUSD = costUSD;
-    addToTotalCost(costUSD, durationMs);
-    recordTokenUsage(
-      {
-        inputTokens,
-        outputTokens,
-        cacheCreationTokens: cacheCreationInputTokens,
-        cacheReadTokens: cacheReadInputTokens
-      },
-      costUSD,
-      model,
-      toolUseContext ? {
-        agentId: toolUseContext.agentId,
-        toolUseId: toolUseContext.toolUseId,
-        model
-      } : void 0
-    );
-    return assistantMessage;
-  } catch (error) {
-    return getAssistantMessageFromError(error);
-  }
-}
-export {
-  assistantMessageToMessageParam,
-  fetchAnthropicModels,
-  getAnthropicClient,
-  queryAnthropicNative,
-  resetAnthropicClient,
-  splitSysPromptPrefix,
-  userMessageToMessageParam,
-  verifyApiKey
-};
-//# sourceMappingURL=anthropicProvider.js.map