only emit metics for nodes that are run

Author: jsonbailey

packages/ai-providers/server-ai-openai/src/ldai_openai/openai_agent_graph_runner.py

@@ -86,6 +86,8 @@ async def run(self, input: Any) -> AgentGraphRunnerResult:
         try:
             from agents import Runner
             root_agent = self._build_agents(path, state)
+            if root_key:
+                self._node_metrics[root_key] = LDAIMetrics(success=False)
             result = await Runner.run(root_agent, input_str)
             self._flush_final_segment(state, result)
             self._collect_tool_calls(result)
@@ -152,12 +154,9 @@ def _build_agents(
 
         name_map: Dict[str, str] = {}
         tool_name_map: Dict[str, str] = {}
-        node_metrics: Dict[str, LDAIMetrics] = {}
 
         def build_node(node: AgentGraphNode, ctx: dict) -> Any:
             node_config = node.get_config()
-            metrics = LDAIMetrics(success=True)
-            node_metrics[node_config.key] = metrics
             model = node_config.model
 
             if not model:
@@ -178,7 +177,6 @@ def build_node(node: AgentGraphNode, ctx: dict) -> Any:
                             node_config.key,
                             target_key,
                             path,
-                            metrics,
                             state,
                         ),
                     )
@@ -212,19 +210,17 @@ def build_node(node: AgentGraphNode, ctx: dict) -> Any:
         root = self._graph.reverse_traverse(fn=build_node)
         self._agent_name_map = name_map
         self._tool_name_map = tool_name_map
-        self._node_metrics = node_metrics
         return root
 
     def _make_on_handoff(
         self,
         src: str,
         tgt: str,
         path: List[str],
-        metrics: LDAIMetrics,
         state: _RunState,
     ):
         def on_handoff(run_ctx: Any) -> None:
-            self._handle_handoff(run_ctx, src, tgt, path, metrics, state)
+            self._handle_handoff(run_ctx, src, tgt, path, state)
         return on_handoff
 
     def _handle_handoff(
@@ -233,24 +229,27 @@ def _handle_handoff(
         src: str,
         tgt: str,
         path: List[str],
-        metrics: LDAIMetrics,
         state: _RunState,
     ) -> None:
         path.append(tgt)
-        state.last_node_key = tgt
 
         now_ns = time.perf_counter_ns()
         duration_ms = (now_ns - state.last_handoff_ns) // 1_000_000
         state.last_handoff_ns = now_ns
 
-        try:
-            metrics.usage = extract_usage_from_request_entry(
-                run_ctx.usage.request_usage_entries[-1]
-            )
-        except Exception:
-            pass
+        src_metrics = self._node_metrics.get(src)
+        if src_metrics is not None:
+            src_metrics.success = True
+            src_metrics.duration_ms = int(duration_ms)
+            try:
+                src_metrics.usage = extract_usage_from_request_entry(
+                    run_ctx.usage.request_usage_entries[-1]
+                )
+            except Exception:
+                pass
 
-        metrics.duration_ms = int(duration_ms)
+        self._node_metrics[tgt] = LDAIMetrics(success=False)
+        state.last_node_key = tgt
 
     def _flush_final_segment(self, state: _RunState, result: Any) -> None:
         """Record duration/tokens for the last active agent (no handoff after it)."""
@@ -260,6 +259,7 @@ def _flush_final_segment(self, state: _RunState, result: Any) -> None:
         if metrics is None:
             return
 
+        metrics.success = True
         now_ns = time.perf_counter_ns()
         metrics.duration_ms = int((now_ns - state.last_handoff_ns) // 1_000_000)
 

packages/ai-providers/server-ai-openai/tests/test_openai_agent_graph_runner.py

@@ -94,10 +94,40 @@ async def test_openai_agent_graph_runner_run_failure_returns_metrics():
     assert isinstance(result, AgentGraphRunnerResult)
     assert result.metrics.success is False
     assert result.metrics.duration_ms is not None
+    # Import failure happens before node metrics are created
+    assert len(result.metrics.node_metrics) == 0
     # Runner no longer calls graph tracker — graph.create_tracker should NOT be called
     graph.create_tracker.assert_not_called()
 
 
+@pytest.mark.asyncio
+async def test_openai_agent_graph_runner_run_failure_marks_node_not_success():
+    """When Runner.run() raises, started nodes retain success=False."""
+    graph = _make_graph()
+
+    mock_agents = MagicMock()
+    mock_agents.Runner.run = AsyncMock(side_effect=RuntimeError("boom"))
+    mock_agents.Agent = MagicMock(return_value=MagicMock())
+    mock_agents.Handoff = MagicMock()
+    mock_agents.handoff = MagicMock()
+
+    mock_agents_ext = MagicMock()
+    mock_agents_ext.RECOMMENDED_PROMPT_PREFIX = '[PREFIX]'
+
+    with patch.dict('sys.modules', {
+        'agents': mock_agents,
+        'agents.extensions': MagicMock(),
+        'agents.extensions.handoff_prompt': mock_agents_ext,
+        'agents.tool_context': MagicMock(),
+    }):
+        runner = OpenAIAgentGraphRunner(graph, {})
+        result = await runner.run("test input")
+
+    assert result.metrics.success is False
+    assert 'root-agent' in result.metrics.node_metrics
+    assert result.metrics.node_metrics['root-agent'].success is False
+
+
 @pytest.mark.asyncio
 async def test_openai_agent_graph_runner_run_success():
     """Successful run returns AgentGraphRunnerResult with populated GraphMetrics."""
@@ -153,3 +183,4 @@ async def test_openai_agent_graph_runner_run_success():
 
     # Runner accumulates per-node metrics in _node_metrics
     assert 'root-agent' in runner._node_metrics
+    assert runner._node_metrics['root-agent'].success is True