@respan/cli 0.6.8 → 0.7.0

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);
 }
@@ -390,7 +448,6 @@ function processBeforeTool(hookData) {
     // 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) {
@@ -482,11 +539,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();
@@ -494,10 +553,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);
@@ -537,7 +607,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`);
@@ -553,66 +623,87 @@ function processChunk(hookData) {
     launchDelayedSend(sessionId, state.send_version, spans, creds.apiKey, creds.baseUrl);
 }
 // ── Main ──────────────────────────────────────────────────────────
-function mainWorker(raw) {
+function processChunkInWorker(dataFile) {
     try {
+        const raw = fs.readFileSync(dataFile, 'utf-8');
+        fs.unlinkSync(dataFile);
         if (!raw.trim())
             return;
         const hookData = JSON.parse(raw);
-        const event = String(hookData.hook_event_name ?? '');
         const unlock = acquireLock(LOCK_PATH);
         try {
-            if (event === 'BeforeTool') {
-                processBeforeTool(hookData);
-            }
-            else if (event === 'AfterTool') {
-                processAfterTool(hookData);
-            }
-            else {
-                processChunk(hookData);
-            }
+            processChunk(hookData);
         }
         finally {
             unlock?.();
         }
     }
     catch (e) {
-        if (e instanceof SyntaxError) {
-            log('ERROR', `Invalid JSON from stdin: ${e}`);
-        }
-        else {
-            log('ERROR', `Hook error: ${e}`);
+        log('ERROR', `Worker error: ${e}`);
+        try {
+            fs.unlinkSync(dataFile);
         }
+        catch { }
     }
 }
 function main() {
-    // Worker mode: re-invoked as detached subprocess
+    // Worker mode: process chunk from temp file
     if (process.env._RESPAN_GEM_WORKER === '1') {
-        const raw = process.env._RESPAN_GEM_DATA ?? '';
-        mainWorker(raw);
+        const dataFile = process.env._RESPAN_GEM_FILE ?? '';
+        if (dataFile)
+            processChunkInWorker(dataFile);
         return;
     }
-    // Read stdin synchronously, respond immediately, fork worker, exit
     let raw = '';
     try {
         raw = fs.readFileSync(0, 'utf-8');
     }
     catch { }
+    // Respond immediately so Gemini CLI doesn't block
     process.stdout.write('{}\n');
     if (!raw.trim()) {
         process.exit(0);
     }
     try {
-        const scriptPath = __filename || process.argv[1];
-        const child = execFile('node', [scriptPath], {
-            env: { ...process.env, _RESPAN_GEM_WORKER: '1', _RESPAN_GEM_DATA: raw },
-            stdio: 'ignore',
-            detached: true,
-        });
-        child.unref();
+        const hookData = JSON.parse(raw);
+        const event = String(hookData.hook_event_name ?? '');
+        if (event === 'BeforeTool' || event === 'AfterTool') {
+            // Tool events are fast (just state updates) and must run in order.
+            // Process inline, don't fork.
+            const unlock = acquireLock(LOCK_PATH);
+            try {
+                if (event === 'BeforeTool')
+                    processBeforeTool(hookData);
+                else
+                    processAfterTool(hookData);
+            }
+            finally {
+                unlock?.();
+            }
+        }
+        else {
+            // AfterModel chunks: fork to background so Gemini CLI doesn't block.
+            // Write data to temp file (avoids env var size limits).
+            const dataFile = path.join(STATE_DIR, `respan_chunk_${process.pid}.json`);
+            fs.mkdirSync(STATE_DIR, { recursive: true });
+            fs.writeFileSync(dataFile, raw);
+            try {
+                const scriptPath = __filename || process.argv[1];
+                const child = execFile('node', [scriptPath], {
+                    env: { ...process.env, _RESPAN_GEM_WORKER: '1', _RESPAN_GEM_FILE: dataFile },
+                    stdio: 'ignore',
+                    detached: true,
+                });
+                child.unref();
+            }
+            catch (e) {
+                // Fallback: run inline
+                processChunkInWorker(dataFile);
+            }
+        }
     }
     catch (e) {
-        // Fallback: run inline
-        mainWorker(raw);
+        log('ERROR', `Hook error: ${e}`);
     }
     process.exit(0);
 }

package/dist/hooks/shared.js

@@ -395,7 +395,7 @@ export function toOtlpPayload(spans) {
                     }),
                 },
                 scopeSpans: [{
-                        scope: { name: 'respan-cli-hooks', version: '0.5.3' },
+                        scope: { name: 'respan-cli-hooks', version: '0.7.0' },
                         spans: otlpSpans,
                     }],
             }],