@within-7/minto 0.1.6 → 0.2.0

package/dist/services/claude.js

@@ -7,6 +7,7 @@ import { randomUUID } from "crypto";
 import "dotenv/config";
 import { addToTotalCost } from "../cost-tracker.js";
 import models from "../constants/models.js";
+import { getToolDescriptionAsync } from "../Tool.js";
 import {
   getAnthropicApiKey,
   getOrCreateUserID,
@@ -43,6 +44,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 +88,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 +102,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 +171,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 +468,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) {
@@ -953,7 +984,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 +1074,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 +1114,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,11 +1147,30 @@ 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) {
@@ -1142,7 +1233,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 +1267,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 +1294,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",
@@ -1451,7 +1567,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);