@within-7/minto 0.1.7 → 0.3.0

package/dist/services/claude.js

@@ -6,7 +6,9 @@ import chalk from "chalk";
 import { randomUUID } from "crypto";
 import "dotenv/config";
 import { addToTotalCost } from "../cost-tracker.js";
+import { recordTokenUsage } from "@core/tokenStatsManager";
 import models from "../constants/models.js";
+import { getToolDescriptionAsync } from "../Tool.js";
 import {
   getAnthropicApiKey,
   getOrCreateUserID,
@@ -43,6 +45,8 @@ import {
 } from "./openai.js";
 import { getReasoningEffort } from "../utils/thinking.js";
 import { generateSystemReminders } from "./systemReminder.js";
+import { addRetryEventToTranscript } from "../utils/agentTranscripts.js";
+import { setStreamingState, getStreamingState } from "../components/Spinner.js";
 function isGPT5Model(modelName) {
   return modelName.startsWith("gpt-5");
 }
@@ -85,7 +89,8 @@ class MintoContextManager {
   }
   getMintoContext() {
     if (!this.cacheInitialized) {
-      this.initialize().catch(() => {
+      this.initialize().catch((error) => {
+        debugLogger.warn("MINTO_CONTEXT_INIT_FAILED", { error: String(error) });
       });
       return "";
     }
@@ -98,7 +103,8 @@ class MintoContextManager {
   }
 }
 const mintoContextManager = MintoContextManager.getInstance();
-mintoContextManager.initialize().catch(() => {
+mintoContextManager.initialize().catch((error) => {
+  debugLogger.warn("MINTO_CONTEXT_MODULE_INIT_FAILED", { error: String(error) });
 });
 const generateMintoContext = () => {
   return mintoContextManager.getMintoContext();
@@ -166,9 +172,31 @@ async function withRetry(operation, options = {}) {
       }
       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})`)}`
-      );
+      setStreamingState({
+        phase: "retrying",
+        retryCount: attempt,
+        maxRetries,
+        errorName: error.name
+      });
+      debugLogger.flow("API_RETRY_ATTEMPT", {
+        attempt,
+        maxRetries,
+        errorName: error.name,
+        errorMessage: error.message,
+        delayMs
+      });
+      if (options.onRetry) {
+        options.onRetry({
+          attempt,
+          maxRetries,
+          error,
+          delayMs
+        });
+      } else {
+        console.log(
+          `  \u23BF  ${chalk.red(`API ${error.name} (${error.message}) \xB7 Retrying in ${Math.round(delayMs / 1e3)} seconds\u2026 (attempt ${attempt}/${maxRetries})`)}`
+        );
+      }
       try {
         await abortableDelay(delayMs, options.signal);
       } catch (delayError) {
@@ -441,8 +469,12 @@ async function handleMessageStream(stream, signal) {
         if (!object) {
           object = chunk.object;
         }
-        if (!usage) {
+        if (!usage && chunk.usage) {
           usage = chunk.usage;
+          setStreamingState({
+            inputTokens: chunk.usage.prompt_tokens,
+            outputTokens: chunk.usage.completion_tokens
+          });
         }
         message = messageReducer(message, chunk);
         if (chunk?.choices?.[0]?.delta?.content) {
@@ -512,9 +544,24 @@ function convertOpenAIResponseToAnthropic(response, _tools) {
       const tool = toolCall.function;
       const toolName = tool?.name;
       let toolArgs = {};
+      let parseError = null;
       try {
         toolArgs = tool?.arguments ? JSON.parse(tool.arguments) : {};
       } catch (e) {
+        parseError = e instanceof Error ? e.message : String(e);
+        debugLogger.warn("TOOL_ARGUMENTS_PARSE_ERROR", {
+          toolName,
+          rawArguments: tool?.arguments?.substring(0, 200),
+          // Limit log size
+          errorMessage: parseError
+        });
+      }
+      if (parseError && Object.keys(toolArgs).length === 0) {
+        debugLogger.error("TOOL_CALL_EMPTY_ARGUMENTS", {
+          toolName,
+          parseError,
+          suggestion: "Model may have sent malformed JSON. The tool call will likely fail validation."
+        });
       }
       contentBlocks.push({
         type: "tool_use",
@@ -953,7 +1000,8 @@ async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, t
     tools.map(
       async (tool) => ({
         name: tool.name,
-        description: typeof tool.description === "function" ? await tool.description() : tool.description,
+        // Use getToolDescriptionAsync for consistent async access
+        description: await getToolDescriptionAsync(tool),
         input_schema: "inputJSONSchema" in tool && tool.inputJSONSchema ? tool.inputJSONSchema : zodToJsonSchema(tool.inputSchema)
       })
     )
@@ -1042,12 +1090,32 @@ async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, t
                   content: []
                   // Will be populated from content blocks
                 };
+                setStreamingState({
+                  inputTokens: event.message.usage?.input_tokens,
+                  receivedChars: 0
+                  // Reset for new request
+                });
                 break;
               case "content_block_start":
                 contentBlocks[event.index] = { ...event.content_block };
                 if (event.content_block.type === "tool_use") {
                   inputJSONBuffers.set(event.index, "");
                 }
+                if (event.content_block.type === "thinking") {
+                  const thinkingStartTime = Date.now();
+                  setStreamingState({
+                    phase: "deep_thinking",
+                    tokenCount: 0,
+                    thinkingMaxTokens: maxThinkingTokens,
+                    thinkingStartTime
+                    // NEW: Record start time for duration tracking
+                  });
+                  debugLogger.flow("THINKING_BLOCK_START", {
+                    index: event.index,
+                    maxTokens: maxThinkingTokens,
+                    startTime: thinkingStartTime
+                  });
+                }
                 break;
               case "content_block_delta":
                 const blockIndex = event.index;
@@ -1062,12 +1130,32 @@ async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, t
                 }
                 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":
@@ -1075,23 +1163,47 @@ async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, t
                   stopReason = event.delta.stop_reason;
                 if (event.delta.stop_sequence)
                   stopSequence = event.delta.stop_sequence;
-                if (event.usage) usage = { ...usage, ...event.usage };
+                if (event.usage) {
+                  usage = { ...usage, ...event.usage };
+                  setStreamingState({
+                    outputTokens: event.usage.output_tokens
+                  });
+                }
                 break;
               case "content_block_stop":
                 const stopIndex = event.index;
                 const block = contentBlocks[stopIndex];
+                if (block?.type === "thinking") {
+                  const streamState2 = getStreamingState();
+                  const thinkingDurationMs = streamState2.thinkingStartTime ? Date.now() - streamState2.thinkingStartTime : 0;
+                  setStreamingState({
+                    phase: "generating",
+                    thinkingDurationMs
+                    // NEW: Store duration for display
+                  });
+                  debugLogger.flow("THINKING_BLOCK_COMPLETE", {
+                    index: stopIndex,
+                    finalTokenCount: block.thinking?.length || 0,
+                    durationMs: thinkingDurationMs
+                  });
+                }
                 if (block?.type === "tool_use" && inputJSONBuffers.has(stopIndex)) {
                   const jsonStr = inputJSONBuffers.get(stopIndex);
                   if (jsonStr) {
                     try {
                       block.input = JSON.parse(jsonStr);
                     } catch (error) {
+                      const errorMsg = error instanceof Error ? error.message : String(error);
                       debugLogger.error("JSON_PARSE_ERROR", {
                         blockIndex: stopIndex,
-                        jsonStr,
-                        error: error instanceof Error ? error.message : String(error)
+                        jsonStr: jsonStr.length > 500 ? jsonStr.slice(0, 500) + "..." : jsonStr,
+                        error: errorMsg
                       });
-                      block.input = {};
+                      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);
                   }
@@ -1142,7 +1254,18 @@ async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, t
           });
         }
       },
-      { signal }
+      {
+        signal,
+        // Pass retry events to agent transcript for UI display
+        onRetry: toolUseContext?.agentId ? ({ attempt, maxRetries, error, delayMs }) => {
+          addRetryEventToTranscript(toolUseContext.agentId, {
+            attempt,
+            maxRetries,
+            errorMessage: error.message,
+            delayMs
+          });
+        } : void 0
+      }
     );
     debugLogger.api("ANTHROPIC_API_CALL_SUCCESS", {
       content: response.content
@@ -1165,6 +1288,19 @@ async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, t
       }
       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,
@@ -1179,8 +1315,9 @@ async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, t
       type: "assistant",
       uuid: nanoid(),
       durationMs,
-      costUSD: 0
+      costUSD: 0,
       // Will be calculated below
+      thinkingMetadata
     };
     const systemMessages = system.map((block) => ({
       role: "system",
@@ -1207,6 +1344,21 @@ async function queryAnthropicNative(messages, systemPrompt, maxThinkingTokens, t
     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);
@@ -1451,7 +1603,18 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
           );
         }
       },
-      { signal }
+      {
+        signal,
+        // Pass retry events to agent transcript for UI display
+        onRetry: toolUseContext?.agentId ? ({ attempt, maxRetries, error, delayMs }) => {
+          addRetryEventToTranscript(toolUseContext.agentId, {
+            attempt,
+            maxRetries,
+            errorMessage: error.message,
+            delayMs
+          });
+        } : void 0
+      }
     );
   } catch (error) {
     logError(error);
@@ -1465,6 +1628,21 @@ async function queryOpenAI(messages, systemPrompt, maxThinkingTokens, tools, sig
   const cacheCreationInputTokens = response.usage?.prompt_token_details?.cached_tokens ?? 0;
   const costUSD = inputTokens / 1e6 * SONNET_COST_PER_MILLION_INPUT_TOKENS + outputTokens / 1e6 * SONNET_COST_PER_MILLION_OUTPUT_TOKENS + cacheReadInputTokens / 1e6 * SONNET_COST_PER_MILLION_PROMPT_CACHE_READ_TOKENS + cacheCreationInputTokens / 1e6 * SONNET_COST_PER_MILLION_PROMPT_CACHE_WRITE_TOKENS;
   addToTotalCost(costUSD, durationMsIncludingRetries);
+  recordTokenUsage(
+    {
+      inputTokens,
+      outputTokens,
+      cacheCreationTokens: cacheCreationInputTokens,
+      cacheReadTokens: cacheReadInputTokens
+    },
+    costUSD,
+    model,
+    toolUseContext ? {
+      agentId: toolUseContext.agentId,
+      toolUseId: toolUseContext.toolUseId,
+      model
+    } : void 0
+  );
   logLLMInteraction({
     systemPrompt: systemPrompt.join("\n"),
     messages: [...openaiSystem, ...openaiMessages],