@within-7/minto 0.3.10 → 0.4.1

package/dist/services/llm/anthropicProvider.js

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