@hatchway/cli 0.50.63 → 0.50.65

package/dist/index.js

@@ -4335,9 +4335,10 @@ function buildPromptWithImages(prompt, messageParts) {
  * query() SDK function -> minimal transformation -> output
  *
  * Sentry Integration:
- * - The query() function is auto-instrumented by Sentry's claudeCodeAgentSdkIntegration
- * - Instrumentation hooks into @anthropic-ai/claude-agent-sdk via OpenTelemetry
- * - IMPORTANT: Sentry must be initialized BEFORE claude-agent-sdk is imported
+ * - Manual gen_ai.* spans for AI Agent Monitoring in Sentry
+ * - gen_ai.invoke_agent wraps the full query lifecycle
+ * - gen_ai.execute_tool spans are emitted per tool call
+ * - Token usage and cost are captured from the SDK result message
  */
 function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortController) {
     return async function* nativeClaudeQuery(prompt, workingDirectory, systemPrompt, _agent, _codexThreadId, messageParts) {
@@ -4423,20 +4424,62 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
         let messageCount = 0;
         let toolCallCount = 0;
         let textBlockCount = 0;
+        // 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: {
+                'gen_ai.agent.name': 'hatchway-builder',
+                'gen_ai.request.model': modelId,
+                'gen_ai.agent.input': finalPrompt.substring(0, 500),
+                '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
-            // NOTE: query() is auto-instrumented by Sentry's claudeCodeAgentSdkIntegration
             for await (const sdkMessage of query({ prompt: finalPrompt, options })) {
                 messageCount++;
                 // Transform SDK message to our internal format
                 const transformed = transformSDKMessage(sdkMessage);
                 if (transformed) {
-                    // Track stats for logging
+                    // Track stats and emit gen_ai.execute_tool spans for tool calls
                     if (transformed.type === 'assistant' && transformed.message?.content) {
                         for (const block of transformed.message.content) {
                             if (block.type === 'tool_use') {
                                 toolCallCount++;
                                 debugLog$4(`[runner] [native-sdk] 🔧 Tool call: ${block.name}\n`);
+                                // 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: {
+                                        'gen_ai.tool.name': block.name,
+                                        '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
+                                });
                             }
                             else if (block.type === 'text') {
                                 textBlockCount++;
@@ -4485,13 +4528,31 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
                         process.stderr.write(`[native-sdk] Tool use summary: ${summaryMsg.summary}\n`);
                     }
                 }
-                // Log result messages
+                // Capture result messages — record token usage and cost on the agent span
                 if (sdkMessage.type === 'result') {
-                    if (sdkMessage.subtype === 'success') {
-                        debugLog$4(`[runner] [native-sdk] ✅ Query complete - ${sdkMessage.num_turns} turns, $${sdkMessage.total_cost_usd?.toFixed(4)} USD\n`);
+                    const resultMsg = sdkMessage;
+                    if (agentSpan) {
+                        agentSpan.setAttribute('gen_ai.usage.input_tokens', resultMsg.usage?.input_tokens ?? 0);
+                        agentSpan.setAttribute('gen_ai.usage.output_tokens', resultMsg.usage?.output_tokens ?? 0);
+                        agentSpan.setAttribute('gen_ai.usage.total_tokens', (resultMsg.usage?.input_tokens ?? 0) + (resultMsg.usage?.output_tokens ?? 0));
+                        agentSpan.setAttribute('gen_ai.usage.cost_usd', resultMsg.total_cost_usd ?? 0);
+                        agentSpan.setAttribute('gen_ai.agent.num_turns', resultMsg.num_turns ?? 0);
+                        agentSpan.setAttribute('gen_ai.agent.num_tool_calls', toolCallCount);
+                        agentSpan.setAttribute('gen_ai.agent.result', resultMsg.subtype ?? 'unknown');
+                        agentSpan.setAttribute('gen_ai.agent.duration_ms', resultMsg.duration_ms ?? 0);
+                        agentSpan.setAttribute('gen_ai.agent.duration_api_ms', resultMsg.duration_api_ms ?? 0);
+                        if (resultMsg.usage?.cache_read_input_tokens) {
+                            agentSpan.setAttribute('gen_ai.usage.cache_read_tokens', resultMsg.usage.cache_read_input_tokens);
+                        }
+                        if (resultMsg.usage?.cache_creation_input_tokens) {
+                            agentSpan.setAttribute('gen_ai.usage.cache_creation_tokens', resultMsg.usage.cache_creation_input_tokens);
+                        }
+                    }
+                    if (resultMsg.subtype === 'success') {
+                        debugLog$4(`[runner] [native-sdk] ✅ Query complete - ${resultMsg.num_turns} turns, $${resultMsg.total_cost_usd?.toFixed(4)} USD\n`);
                     }
                     else {
-                        debugLog$4(`[runner] [native-sdk] ⚠️  Query ended with: ${sdkMessage.subtype}\n`);
+                        debugLog$4(`[runner] [native-sdk] ⚠️  Query ended with: ${resultMsg.subtype}\n`);
                     }
                 }
             }
@@ -4499,9 +4560,16 @@ function createNativeClaudeQuery(modelId = DEFAULT_CLAUDE_MODEL_ID, abortControl
         }
         catch (error) {
             debugLog$4(`[runner] [native-sdk] ❌ Error: ${error instanceof Error ? error.message : String(error)}\n`);
+            if (agentSpan) {
+                agentSpan.setStatus({ code: 2, message: error instanceof Error ? error.message : String(error) });
+            }
             Sentry.captureException(error);
             throw error;
         }
+        finally {
+            // End the agent span regardless of success/failure
+            agentSpan?.end();
+        }
     };
 }
 
@@ -7127,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();
             }
         },
     });