@hatchway/cli 0.50.64 → 0.50.65

package/dist/index.js

@@ -4424,8 +4424,22 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
         let messageCount = 0;
         let toolCallCount = 0;
         let textBlockCount = 0;
-        // Wrap the entire agent execution in a gen_ai.invoke_agent span for Sentry AI monitoring
-        const agentSpan = Sentry.startInactiveSpan({
+        // Create the gen_ai.invoke_agent span using startSpanManual.
+        //
+        // Why startSpanManual and not startSpan?
+        // startSpan() takes a callback and ends the span when the callback returns.
+        // But this is an async generator — we can't yield from inside a callback.
+        // startSpanManual() makes the span active on the current scope AND gives us
+        // a handle to end it ourselves in the finally block.
+        //
+        // Why this works now (it didn't before):
+        // engine.ts captures the parent build.runner span before creating the
+        // ReadableStream, then restores it via Sentry.withActiveSpan() inside the
+        // stream's start() callback. So when this generator runs, the build.runner
+        // span is the active parent, and our gen_ai.invoke_agent becomes its child.
+        // Tool spans created with startSpan() inside the loop become children of
+        // gen_ai.invoke_agent because it's the active span at that point.
+        const agentSpan = Sentry.startSpanManual({
             op: 'gen_ai.invoke_agent',
             name: `Claude Agent (${modelId})`,
             attributes: {
@@ -4435,7 +4449,8 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
                 'gen_ai.system_prompt.length': appendedSystemPrompt.length,
                 'gen_ai.agent.available_tools': JSON.stringify(['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep', 'Task', 'TodoWrite', 'WebFetch']),
             },
-        });
+        }, (span) => span // Return the span so we control its lifecycle
+        );
         try {
             // Stream messages directly from the SDK
             for await (const sdkMessage of query({ prompt: finalPrompt, options })) {
@@ -4449,8 +4464,12 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
                             if (block.type === 'tool_use') {
                                 toolCallCount++;
                                 debugLog$4(`[runner] [native-sdk] 🔧 Tool call: ${block.name}\n`);
-                                // Emit a gen_ai.execute_tool span for each tool invocation
-                                const toolSpan = Sentry.startInactiveSpan({
+                                // Emit a gen_ai.execute_tool span as a child of gen_ai.invoke_agent.
+                                // Using startSpan (active) with an empty callback — the span is created,
+                                // becomes briefly active, records the tool invocation, and ends when
+                                // the callback returns. This gives Sentry the tool call event with
+                                // proper parent-child nesting.
+                                Sentry.startSpan({
                                     op: 'gen_ai.execute_tool',
                                     name: `Tool: ${block.name}`,
                                     attributes: {
@@ -4458,10 +4477,9 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
                                         'gen_ai.tool.call_id': block.id,
                                         'gen_ai.tool.input': JSON.stringify(block.input).substring(0, 1000),
                                     },
+                                }, () => {
+                                    // Span created and ended — marks the tool invocation point
                                 });
-                                // Tool spans are completed immediately since we get input and output
-                                // as separate messages — the output is captured in the tool_result handler below
-                                toolSpan?.end();
                             }
                             else if (block.type === 'text') {
                                 textBlockCount++;
@@ -7177,38 +7195,53 @@ async function createBuildStream(options) {
     debugLog$1();
     const generator = query(fullPrompt, actualWorkingDir, systemPrompt, agent, options.codexThreadId, messageParts);
     debugLog$1();
+    // Capture the active Sentry span BEFORE creating the ReadableStream.
+    // The ReadableStream.start() callback runs in a new async context where the
+    // parent build.runner span is no longer active. We restore it with withActiveSpan()
+    // so that gen_ai.invoke_agent spans created inside the query generator are
+    // properly nested as children of the build.runner span.
+    const parentSpan = Sentry.getActiveSpan();
     // Create a ReadableStream from the AsyncGenerator
     const stream = new ReadableStream({
         async start(controller) {
             debugLog$1();
-            let chunkCount = 0;
-            try {
-                for await (const chunk of generator) {
-                    chunkCount++;
-                    if (chunkCount % 5 === 0) {
-                        debugLog$1(`[runner] [build-engine] Processed ${chunkCount} chunks from generator\n`);
-                    }
-                    // Convert chunk to appropriate format
-                    if (typeof chunk === 'string') {
-                        controller.enqueue(new TextEncoder().encode(chunk));
-                    }
-                    else if (chunk instanceof Uint8Array) {
-                        controller.enqueue(chunk);
-                    }
-                    else if (typeof chunk === 'object') {
-                        controller.enqueue(new TextEncoder().encode(JSON.stringify(chunk)));
+            const consume = async () => {
+                let chunkCount = 0;
+                try {
+                    for await (const chunk of generator) {
+                        chunkCount++;
+                        if (chunkCount % 5 === 0) {
+                            debugLog$1(`[runner] [build-engine] Processed ${chunkCount} chunks from generator\n`);
+                        }
+                        // Convert chunk to appropriate format
+                        if (typeof chunk === 'string') {
+                            controller.enqueue(new TextEncoder().encode(chunk));
+                        }
+                        else if (chunk instanceof Uint8Array) {
+                            controller.enqueue(chunk);
+                        }
+                        else if (typeof chunk === 'object') {
+                            controller.enqueue(new TextEncoder().encode(JSON.stringify(chunk)));
+                        }
                     }
+                    debugLog$1(`[runner] [build-engine] ✅ Generator exhausted after ${chunkCount} chunks, closing stream\n`);
+                    controller.close();
                 }
-                debugLog$1(`[runner] [build-engine] ✅ Generator exhausted after ${chunkCount} chunks, closing stream\n`);
-                controller.close();
-            }
-            catch (error) {
-                debugLog$1();
-                controller.error(error);
+                catch (error) {
+                    debugLog$1();
+                    controller.error(error);
+                }
+                finally {
+                    // Restore the original working directory
+                    process.chdir(originalCwd);
+                }
+            };
+            // Restore the parent span context so child spans nest correctly
+            if (parentSpan) {
+                await Sentry.withActiveSpan(parentSpan, consume);
             }
-            finally {
-                // Restore the original working directory
-                process.chdir(originalCwd);
+            else {
+                await consume();
             }
         },
     });