@respan/cli 0.6.7 → 0.6.9

package/dist/hooks/gemini-cli.cjs

@@ -438,7 +438,7 @@ function detectModel(hookData) {
   const llmReq = hookData.llm_request ?? {};
   return String(llmReq.model ?? "") || "gemini-cli";
 }
-function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurns, toolDetails, thoughtsTokens) {
+function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurns, toolDetails, thoughtsTokens, textRounds, roundStartTimes) {
   const spans = [];
   const sessionId = String(hookData.session_id ?? "");
   const model = detectModel(hookData);
@@ -447,7 +447,6 @@ function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurn
   const beginTime = startTimeIso || endTime;
   const lat = latencySeconds(beginTime, endTime);
   const promptMessages = extractMessages(hookData);
-  const completionMessage = { role: "assistant", content: truncate(outputText, MAX_CHARS) };
   const { workflowName, spanName, customerId } = resolveSpanFields(config, {
     workflowName: "gemini-cli",
     spanName: "gemini-cli"
@@ -480,50 +479,85 @@ function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurn
     metadata,
     ...lat !== void 0 ? { latency: lat } : {}
   });
-  const genSpan = {
-    trace_unique_id: traceUniqueId,
-    span_unique_id: `gcli_${safeId}_${turnTs}_gen`,
-    span_parent_id: rootSpanId,
-    span_name: "gemini.chat",
-    span_workflow_name: workflowName,
-    span_path: "gemini_chat",
-    model,
-    provider_id: "google",
-    metadata: {},
-    input: promptMessages.length ? JSON.stringify(promptMessages) : "",
-    output: truncate(outputText, MAX_CHARS),
-    timestamp: endTime,
-    start_time: beginTime,
-    prompt_tokens: tokens.prompt_tokens,
-    completion_tokens: tokens.completion_tokens,
-    total_tokens: tokens.total_tokens,
-    ...lat !== void 0 ? { latency: lat } : {}
-  };
-  if (reqConfig.temperature != null) genSpan.temperature = reqConfig.temperature;
-  if (reqConfig.maxOutputTokens != null) genSpan.max_tokens = reqConfig.maxOutputTokens;
-  spans.push(genSpan);
-  if (thoughtsTokens > 0) {
-    spans.push({
-      trace_unique_id: traceUniqueId,
-      span_unique_id: `gcli_${safeId}_${turnTs}_reasoning`,
-      span_parent_id: rootSpanId,
-      span_name: "Reasoning",
-      span_workflow_name: workflowName,
-      span_path: "reasoning",
-      provider_id: "",
-      metadata: { reasoning_tokens: thoughtsTokens },
-      input: "",
-      output: `[Reasoning: ${thoughtsTokens} tokens]`,
-      timestamp: endTime,
-      start_time: beginTime
-    });
+  const rounds = textRounds.length > 0 ? textRounds : [outputText];
+  const roundStarts = roundStartTimes.length > 0 ? roundStartTimes : [beginTime];
+  let toolIdx = 0;
+  for (let r = 0; r < rounds.length; r++) {
+    const roundText = rounds[r];
+    const roundStart = roundStarts[r] || beginTime;
+    const nextTool = toolIdx < toolDetails.length ? toolDetails[toolIdx] : null;
+    const roundEnd = r < rounds.length - 1 && nextTool?.start_time ? nextTool.start_time : endTime;
+    const roundLat = latencySeconds(roundStart, roundEnd);
+    if (roundText) {
+      const genSpan = {
+        trace_unique_id: traceUniqueId,
+        span_unique_id: `gcli_${safeId}_${turnTs}_gen_${r}`,
+        span_parent_id: rootSpanId,
+        span_name: "gemini.chat",
+        span_workflow_name: workflowName,
+        span_path: "gemini_chat",
+        model,
+        provider_id: "google",
+        metadata: {},
+        input: r === 0 && promptMessages.length ? JSON.stringify(promptMessages) : "",
+        output: truncate(roundText, MAX_CHARS),
+        timestamp: roundEnd,
+        start_time: roundStart,
+        ...roundLat !== void 0 ? { latency: roundLat } : {},
+        // Only attach tokens to the first round (aggregate usage from Gemini)
+        ...r === 0 ? {
+          prompt_tokens: tokens.prompt_tokens,
+          completion_tokens: tokens.completion_tokens,
+          total_tokens: tokens.total_tokens
+        } : {}
+      };
+      if (r === 0) {
+        if (reqConfig.temperature != null) genSpan.temperature = reqConfig.temperature;
+        if (reqConfig.maxOutputTokens != null) genSpan.max_tokens = reqConfig.maxOutputTokens;
+      }
+      spans.push(genSpan);
+    }
+    if (r < rounds.length - 1) {
+      while (toolIdx < toolDetails.length) {
+        const detail = toolDetails[toolIdx];
+        const toolName = detail?.name ?? "";
+        const toolArgs = detail?.args ?? detail?.input ?? {};
+        const toolOutput = detail?.output ?? "";
+        const displayName = toolName ? toolDisplayName(toolName) : `Call ${toolIdx + 1}`;
+        const toolInputStr = toolName ? formatToolInput(toolName, toolArgs) : "";
+        const toolMeta = {};
+        if (toolName) toolMeta.tool_name = toolName;
+        if (detail?.error) toolMeta.error = detail.error;
+        const toolStart = detail?.start_time ?? beginTime;
+        const toolEnd = detail?.end_time ?? endTime;
+        const toolLat = latencySeconds(toolStart, toolEnd);
+        spans.push({
+          trace_unique_id: traceUniqueId,
+          span_unique_id: `gcli_${safeId}_${turnTs}_tool_${toolIdx + 1}`,
+          span_parent_id: rootSpanId,
+          span_name: `Tool: ${displayName}`,
+          span_workflow_name: workflowName,
+          span_path: toolName ? `tool_${toolName}` : "tool_call",
+          provider_id: "",
+          metadata: toolMeta,
+          input: toolInputStr,
+          output: truncate(toolOutput, MAX_CHARS),
+          timestamp: toolEnd,
+          start_time: toolStart,
+          ...toolLat !== void 0 ? { latency: toolLat } : {}
+        });
+        toolIdx++;
+        const nextDetail = toolDetails[toolIdx];
+        if (nextDetail && roundStarts[r + 1] && nextDetail.start_time && nextDetail.start_time > roundStarts[r + 1]) break;
+      }
+    }
   }
-  for (let i = 0; i < toolTurns; i++) {
-    const detail = toolDetails[i] ?? null;
+  while (toolIdx < toolDetails.length) {
+    const detail = toolDetails[toolIdx];
     const toolName = detail?.name ?? "";
     const toolArgs = detail?.args ?? detail?.input ?? {};
     const toolOutput = detail?.output ?? "";
-    const displayName = toolName ? toolDisplayName(toolName) : `Call ${i + 1}`;
+    const displayName = toolName ? toolDisplayName(toolName) : `Call ${toolIdx + 1}`;
     const toolInputStr = toolName ? formatToolInput(toolName, toolArgs) : "";
     const toolMeta = {};
     if (toolName) toolMeta.tool_name = toolName;
@@ -533,7 +567,7 @@ function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurn
     const toolLat = latencySeconds(toolStart, toolEnd);
     spans.push({
       trace_unique_id: traceUniqueId,
-      span_unique_id: `gcli_${safeId}_${turnTs}_tool_${i + 1}`,
+      span_unique_id: `gcli_${safeId}_${turnTs}_tool_${toolIdx + 1}`,
       span_parent_id: rootSpanId,
       span_name: `Tool: ${displayName}`,
       span_workflow_name: workflowName,
@@ -546,6 +580,23 @@ function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurn
       start_time: toolStart,
       ...toolLat !== void 0 ? { latency: toolLat } : {}
     });
+    toolIdx++;
+  }
+  if (thoughtsTokens > 0) {
+    spans.push({
+      trace_unique_id: traceUniqueId,
+      span_unique_id: `gcli_${safeId}_${turnTs}_reasoning`,
+      span_parent_id: rootSpanId,
+      span_name: "Reasoning",
+      span_workflow_name: workflowName,
+      span_path: "reasoning",
+      provider_id: "",
+      metadata: { reasoning_tokens: thoughtsTokens },
+      input: "",
+      output: `[Reasoning: ${thoughtsTokens} tokens]`,
+      timestamp: endTime,
+      start_time: beginTime
+    });
   }
   return addDefaultsToAll(spans);
 }
@@ -664,6 +715,8 @@ function processBeforeTool(hookData) {
   const pending = state.pending_tools ?? [];
   pending.push({ name: toolName, input: toolInput, start_time: nowISO() });
   state.pending_tools = pending;
+  state.send_version = (state.send_version ?? 0) + 1;
+  state.tool_turns = (state.tool_turns ?? 0) + 1;
   saveStreamState(sessionId, state);
 }
 function processAfterTool(hookData) {
@@ -746,7 +799,8 @@ function processChunk(hookData) {
       state.tool_turns = (state.tool_turns ?? 0) + 1;
       state.send_version = (state.send_version ?? 0) + 1;
       toolCallDetected = true;
-      debug(`Tool call detected via msg_count (${savedMsgCount} \u2192 ${currentMsgCount}), tool_turns=${state.tool_turns}`);
+      state.current_round = (state.current_round ?? 0) + 1;
+      debug(`Tool call detected via msg_count (${savedMsgCount} \u2192 ${currentMsgCount}), tool_turns=${state.tool_turns}, round=${state.current_round}`);
     }
   }
   state.msg_count = currentMsgCount;
@@ -755,10 +809,15 @@ function processChunk(hookData) {
     state.accumulated_text += chunkText;
     state.last_tokens = completionTokens || state.last_tokens;
     if (thoughtsTokens > 0) state.thoughts_tokens = thoughtsTokens;
-  }
-  if (chunkText) {
+    const round = state.current_round ?? 0;
+    if (!state.text_rounds) state.text_rounds = [];
+    if (!state.round_start_times) state.round_start_times = [];
+    while (state.text_rounds.length <= round) state.text_rounds.push("");
+    while (state.round_start_times.length <= round) state.round_start_times.push("");
+    state.text_rounds[round] += chunkText;
+    if (!state.round_start_times[round]) state.round_start_times[round] = nowISO();
     saveStreamState(sessionId, state);
-    debug(`Accumulated chunk: +${chunkText.length} chars, total=${state.accumulated_text.length}`);
+    debug(`Accumulated chunk: +${chunkText.length} chars, total=${state.accumulated_text.length}, round=${round}`);
   }
   const isToolTurn = hasToolCall || ["TOOL_CALLS", "FUNCTION_CALL", "TOOL_USE"].includes(finishReason);
   if (isToolTurn) {
@@ -798,7 +857,9 @@ function processChunk(hookData) {
     state.first_chunk_time || void 0,
     state.tool_turns ?? 0,
     state.tool_details ?? [],
-    state.thoughts_tokens ?? 0
+    state.thoughts_tokens ?? 0,
+    state.text_rounds ?? [],
+    state.round_start_times ?? []
   );
   if (isFinished && chunkText) {
     debug(`Immediate send (text+STOP, tool_turns=${state.tool_turns ?? 0}), ${state.accumulated_text.length} chars`);

package/dist/hooks/gemini-cli.js

@@ -142,7 +142,7 @@ function detectModel(hookData) {
     return String(llmReq.model ?? '') || 'gemini-cli';
 }
 // ── Span construction ─────────────────────────────────────────────
-function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurns, toolDetails, thoughtsTokens) {
+function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurns, toolDetails, thoughtsTokens, textRounds, roundStartTimes) {
     const spans = [];
     const sessionId = String(hookData.session_id ?? '');
     const model = detectModel(hookData);
@@ -151,21 +151,17 @@ function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurn
     const beginTime = startTimeIso || endTime;
     const lat = latencySeconds(beginTime, endTime);
     const promptMessages = extractMessages(hookData);
-    const completionMessage = { role: 'assistant', content: truncate(outputText, MAX_CHARS) };
     const { workflowName, spanName, customerId } = resolveSpanFields(config, {
         workflowName: 'gemini-cli',
         spanName: 'gemini-cli',
     });
     const safeId = sessionId.replace(/[/\\]/g, '_').slice(0, 50);
-    // Use first chunk timestamp to differentiate turns within the same session
     const turnTs = beginTime.replace(/[^0-9]/g, '').slice(0, 14);
     const traceUniqueId = `gcli_${safeId}_${turnTs}`;
     const rootSpanId = `gcli_${safeId}_${turnTs}_root`;
     const threadId = `gcli_${sessionId}`;
-    // LLM config
     const llmReq = (hookData.llm_request ?? {});
     const reqConfig = (llmReq.config ?? {});
-    // Metadata
     const baseMeta = { source: 'gemini-cli' };
     if (toolTurns > 0)
         baseMeta.tool_turns = toolTurns;
@@ -190,55 +186,99 @@ function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurn
         metadata,
         ...(lat !== undefined ? { latency: lat } : {}),
     });
-    // Generation child span
-    const genSpan = {
-        trace_unique_id: traceUniqueId,
-        span_unique_id: `gcli_${safeId}_${turnTs}_gen`,
-        span_parent_id: rootSpanId,
-        span_name: 'gemini.chat',
-        span_workflow_name: workflowName,
-        span_path: 'gemini_chat',
-        model,
-        provider_id: 'google',
-        metadata: {},
-        input: promptMessages.length ? JSON.stringify(promptMessages) : '',
-        output: truncate(outputText, MAX_CHARS),
-        timestamp: endTime,
-        start_time: beginTime,
-        prompt_tokens: tokens.prompt_tokens,
-        completion_tokens: tokens.completion_tokens,
-        total_tokens: tokens.total_tokens,
-        ...(lat !== undefined ? { latency: lat } : {}),
-    };
-    if (reqConfig.temperature != null)
-        genSpan.temperature = reqConfig.temperature;
-    if (reqConfig.maxOutputTokens != null)
-        genSpan.max_tokens = reqConfig.maxOutputTokens;
-    spans.push(genSpan);
-    // Reasoning span
-    if (thoughtsTokens > 0) {
-        spans.push({
-            trace_unique_id: traceUniqueId,
-            span_unique_id: `gcli_${safeId}_${turnTs}_reasoning`,
-            span_parent_id: rootSpanId,
-            span_name: 'Reasoning',
-            span_workflow_name: workflowName,
-            span_path: 'reasoning',
-            provider_id: '',
-            metadata: { reasoning_tokens: thoughtsTokens },
-            input: '',
-            output: `[Reasoning: ${thoughtsTokens} tokens]`,
-            timestamp: endTime,
-            start_time: beginTime,
-        });
+    // Build interleaved LLM + Tool spans in chronological order.
+    // If we have text rounds, create one gemini.chat per round with tools between them.
+    // Otherwise fall back to a single gemini.chat span.
+    const rounds = textRounds.length > 0 ? textRounds : [outputText];
+    const roundStarts = roundStartTimes.length > 0 ? roundStartTimes : [beginTime];
+    let toolIdx = 0;
+    for (let r = 0; r < rounds.length; r++) {
+        const roundText = rounds[r];
+        const roundStart = roundStarts[r] || beginTime;
+        // Round end: next tool start, or endTime for last round
+        const nextTool = toolIdx < toolDetails.length ? toolDetails[toolIdx] : null;
+        const roundEnd = (r < rounds.length - 1 && nextTool?.start_time) ? nextTool.start_time : endTime;
+        const roundLat = latencySeconds(roundStart, roundEnd);
+        // LLM generation span for this round
+        if (roundText) {
+            const genSpan = {
+                trace_unique_id: traceUniqueId,
+                span_unique_id: `gcli_${safeId}_${turnTs}_gen_${r}`,
+                span_parent_id: rootSpanId,
+                span_name: 'gemini.chat',
+                span_workflow_name: workflowName,
+                span_path: 'gemini_chat',
+                model,
+                provider_id: 'google',
+                metadata: {},
+                input: r === 0 && promptMessages.length ? JSON.stringify(promptMessages) : '',
+                output: truncate(roundText, MAX_CHARS),
+                timestamp: roundEnd,
+                start_time: roundStart,
+                ...(roundLat !== undefined ? { latency: roundLat } : {}),
+                // Only attach tokens to the first round (aggregate usage from Gemini)
+                ...(r === 0 ? {
+                    prompt_tokens: tokens.prompt_tokens,
+                    completion_tokens: tokens.completion_tokens,
+                    total_tokens: tokens.total_tokens,
+                } : {}),
+            };
+            if (r === 0) {
+                if (reqConfig.temperature != null)
+                    genSpan.temperature = reqConfig.temperature;
+                if (reqConfig.maxOutputTokens != null)
+                    genSpan.max_tokens = reqConfig.maxOutputTokens;
+            }
+            spans.push(genSpan);
+        }
+        // Tool spans that come after this round (before next round)
+        if (r < rounds.length - 1) {
+            // Emit all tools between this round and the next
+            while (toolIdx < toolDetails.length) {
+                const detail = toolDetails[toolIdx];
+                const toolName = detail?.name ?? '';
+                const toolArgs = detail?.args ?? detail?.input ?? {};
+                const toolOutput = detail?.output ?? '';
+                const displayName = toolName ? toolDisplayName(toolName) : `Call ${toolIdx + 1}`;
+                const toolInputStr = toolName ? formatToolInput(toolName, toolArgs) : '';
+                const toolMeta = {};
+                if (toolName)
+                    toolMeta.tool_name = toolName;
+                if (detail?.error)
+                    toolMeta.error = detail.error;
+                const toolStart = detail?.start_time ?? beginTime;
+                const toolEnd = detail?.end_time ?? endTime;
+                const toolLat = latencySeconds(toolStart, toolEnd);
+                spans.push({
+                    trace_unique_id: traceUniqueId,
+                    span_unique_id: `gcli_${safeId}_${turnTs}_tool_${toolIdx + 1}`,
+                    span_parent_id: rootSpanId,
+                    span_name: `Tool: ${displayName}`,
+                    span_workflow_name: workflowName,
+                    span_path: toolName ? `tool_${toolName}` : 'tool_call',
+                    provider_id: '',
+                    metadata: toolMeta,
+                    input: toolInputStr,
+                    output: truncate(toolOutput, MAX_CHARS),
+                    timestamp: toolEnd,
+                    start_time: toolStart,
+                    ...(toolLat !== undefined ? { latency: toolLat } : {}),
+                });
+                toolIdx++;
+                // If next tool starts after next round's start time, break — it belongs to a later gap
+                const nextDetail = toolDetails[toolIdx];
+                if (nextDetail && roundStarts[r + 1] && nextDetail.start_time && nextDetail.start_time > roundStarts[r + 1])
+                    break;
+            }
+        }
     }
-    // Tool child spans
-    for (let i = 0; i < toolTurns; i++) {
-        const detail = toolDetails[i] ?? null;
+    // Any remaining tools not yet emitted (e.g. only one round but tools exist)
+    while (toolIdx < toolDetails.length) {
+        const detail = toolDetails[toolIdx];
         const toolName = detail?.name ?? '';
         const toolArgs = detail?.args ?? detail?.input ?? {};
         const toolOutput = detail?.output ?? '';
-        const displayName = toolName ? toolDisplayName(toolName) : `Call ${i + 1}`;
+        const displayName = toolName ? toolDisplayName(toolName) : `Call ${toolIdx + 1}`;
         const toolInputStr = toolName ? formatToolInput(toolName, toolArgs) : '';
         const toolMeta = {};
         if (toolName)
@@ -250,7 +290,7 @@ function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurn
         const toolLat = latencySeconds(toolStart, toolEnd);
         spans.push({
             trace_unique_id: traceUniqueId,
-            span_unique_id: `gcli_${safeId}_${turnTs}_tool_${i + 1}`,
+            span_unique_id: `gcli_${safeId}_${turnTs}_tool_${toolIdx + 1}`,
             span_parent_id: rootSpanId,
             span_name: `Tool: ${displayName}`,
             span_workflow_name: workflowName,
@@ -263,6 +303,24 @@ function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurn
             start_time: toolStart,
             ...(toolLat !== undefined ? { latency: toolLat } : {}),
         });
+        toolIdx++;
+    }
+    // Reasoning span
+    if (thoughtsTokens > 0) {
+        spans.push({
+            trace_unique_id: traceUniqueId,
+            span_unique_id: `gcli_${safeId}_${turnTs}_reasoning`,
+            span_parent_id: rootSpanId,
+            span_name: 'Reasoning',
+            span_workflow_name: workflowName,
+            span_path: 'reasoning',
+            provider_id: '',
+            metadata: { reasoning_tokens: thoughtsTokens },
+            input: '',
+            output: `[Reasoning: ${thoughtsTokens} tokens]`,
+            timestamp: endTime,
+            start_time: beginTime,
+        });
     }
     return addDefaultsToAll(spans);
 }
@@ -387,6 +445,10 @@ function processBeforeTool(hookData) {
     const pending = state.pending_tools ?? [];
     pending.push({ name: toolName, input: toolInput, start_time: nowISO() });
     state.pending_tools = pending;
+    // Increment send_version to cancel any pending delayed sends —
+    // the turn isn't done yet, a tool is about to execute.
+    state.send_version = (state.send_version ?? 0) + 1;
+    state.tool_turns = (state.tool_turns ?? 0) + 1;
     saveStreamState(sessionId, state);
 }
 function processAfterTool(hookData) {
@@ -478,11 +540,13 @@ function processChunk(hookData) {
             state.tool_turns = (state.tool_turns ?? 0) + 1;
             state.send_version = (state.send_version ?? 0) + 1;
             toolCallDetected = true;
-            debug(`Tool call detected via msg_count (${savedMsgCount} → ${currentMsgCount}), tool_turns=${state.tool_turns}`);
+            // Start a new text round after tool completes
+            state.current_round = (state.current_round ?? 0) + 1;
+            debug(`Tool call detected via msg_count (${savedMsgCount} → ${currentMsgCount}), tool_turns=${state.tool_turns}, round=${state.current_round}`);
         }
     }
     state.msg_count = currentMsgCount;
-    // Accumulate text and grounding tool details
+    // Accumulate text into both total and per-round tracking
     if (chunkText) {
         if (!state.first_chunk_time)
             state.first_chunk_time = nowISO();
@@ -490,10 +554,21 @@ function processChunk(hookData) {
         state.last_tokens = completionTokens || state.last_tokens;
         if (thoughtsTokens > 0)
             state.thoughts_tokens = thoughtsTokens;
-    }
-    if (chunkText) {
+        // Track text per round
+        const round = state.current_round ?? 0;
+        if (!state.text_rounds)
+            state.text_rounds = [];
+        if (!state.round_start_times)
+            state.round_start_times = [];
+        while (state.text_rounds.length <= round)
+            state.text_rounds.push('');
+        while (state.round_start_times.length <= round)
+            state.round_start_times.push('');
+        state.text_rounds[round] += chunkText;
+        if (!state.round_start_times[round])
+            state.round_start_times[round] = nowISO();
         saveStreamState(sessionId, state);
-        debug(`Accumulated chunk: +${chunkText.length} chars, total=${state.accumulated_text.length}`);
+        debug(`Accumulated chunk: +${chunkText.length} chars, total=${state.accumulated_text.length}, round=${round}`);
     }
     // Tool call in response parts
     const isToolTurn = hasToolCall || ['TOOL_CALLS', 'FUNCTION_CALL', 'TOOL_USE'].includes(finishReason);
@@ -533,7 +608,7 @@ function processChunk(hookData) {
     const finalTotal = Number(usage.totalTokenCount ?? 0) || (finalPrompt + finalCompletion);
     const tok = { prompt_tokens: finalPrompt, completion_tokens: finalCompletion, total_tokens: finalTotal };
     const config = loadRespanConfig(path.join(os.homedir(), '.gemini', 'respan.json'));
-    const spans = buildSpans(hookData, state.accumulated_text, tok, config, state.first_chunk_time || undefined, state.tool_turns ?? 0, state.tool_details ?? [], state.thoughts_tokens ?? 0);
+    const spans = buildSpans(hookData, state.accumulated_text, tok, config, state.first_chunk_time || undefined, state.tool_turns ?? 0, state.tool_details ?? [], state.thoughts_tokens ?? 0, state.text_rounds ?? [], state.round_start_times ?? []);
     // Method b: text + STOP → send immediately
     if (isFinished && chunkText) {
         debug(`Immediate send (text+STOP, tool_turns=${state.tool_turns ?? 0}), ${state.accumulated_text.length} chars`);