@respan/cli 0.6.9 → 0.7.1

package/dist/hooks/gemini-cli.js

@@ -142,6 +142,36 @@ function detectModel(hookData) {
     return String(llmReq.model ?? '') || 'gemini-cli';
 }
 // ── Span construction ─────────────────────────────────────────────
+function buildToolSpan(detail, idx, traceUniqueId, rootSpanId, safeId, turnTs, workflowName, beginTime, endTime) {
+    const toolName = detail?.name ?? '';
+    const toolArgs = detail?.args ?? detail?.input ?? {};
+    const toolOutput = detail?.output ?? '';
+    const displayName = toolName ? toolDisplayName(toolName) : `Call ${idx + 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);
+    return {
+        trace_unique_id: traceUniqueId,
+        span_unique_id: `gcli_${safeId}_${turnTs}_tool_${idx + 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 } : {}),
+    };
+}
 function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurns, toolDetails, thoughtsTokens, textRounds, roundStartTimes) {
     const spans = [];
     const sessionId = String(hookData.session_id ?? '');
@@ -233,76 +263,18 @@ function buildSpans(hookData, outputText, tokens, config, startTimeIso, toolTurn
         }
         // 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 } : {}),
-                });
+                spans.push(buildToolSpan(toolDetails[toolIdx], toolIdx, traceUniqueId, rootSpanId, safeId, turnTs, workflowName, beginTime, endTime));
                 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;
             }
         }
     }
-    // Any remaining tools not yet emitted (e.g. only one round but tools exist)
+    // Any remaining tools not yet emitted
     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 } : {}),
-        });
+        spans.push(buildToolSpan(toolDetails[toolIdx], toolIdx, traceUniqueId, rootSpanId, safeId, turnTs, workflowName, beginTime, endTime));
         toolIdx++;
     }
     // Reasoning span
@@ -448,7 +420,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) {
@@ -624,66 +595,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,
                     }],
             }],