Disambiguate tool_call vs tool_result item_id fallback

cursor[bot] 3151054134 (Low): _map_tool_call and _map_tool_output
both used ``item_id = str(getattr(raw, "id", "") or call_id)``. When
the SDK's raw item lacks an ``id``, both fall back to the same
``call_id``, so the two AgentContextItems collide on item_id.
AgentContext._index is keyed by item_id, so the second append()
silently overwrites the first — get_context_item then returns the
wrong item even though both still live in self.items.

Namespace the fallback: tool-call-{call_id} for the assistant call
and tool-result-{call_id} for the tool result. Items with intact
raw.id are unaffected. Includes a regression test that constructs
a tool_call/tool_output pair without raw.id and asserts distinct
item_ids; verified the test fails when the fix is reverted.

Author: declanatinference

engine/engine/agents/openai_event_mapper.py

@@ -152,7 +152,11 @@ def _map_tool_call(self, item: Any, *, execution: AgentExecution) -> MappedEvent
                 arguments=str(getattr(raw, "arguments", "") or ""),
             ),
         )
-        item_id = str(getattr(raw, "id", "") or call_id)
+        # Namespace the fallback so a tool_call and its tool_output don't
+        # collide on the same call_id when the SDK doesn't populate raw.id
+        # — AgentContext._index keys by item_id and the second append would
+        # silently overwrite the first, breaking get_context_item.
+        item_id = str(getattr(raw, "id", "") or f"tool-call-{call_id}")
         context_item = AgentContextItem(
             item_id=item_id,
             role="assistant",
@@ -181,7 +185,9 @@ def _map_tool_output(self, item: Any, *, execution: AgentExecution) -> MappedEve
             output = getattr(raw, "output", "")
         content = str(output)
         name = getattr(raw, "name", None) or getattr(item, "name", None)
-        item_id = str(getattr(raw, "id", "") or call_id)
+        # See ``_map_tool_call``: namespaced fallback prevents the tool_call
+        # and tool_output for the same call_id from sharing an item_id.
+        item_id = str(getattr(raw, "id", "") or f"tool-result-{call_id}")
         context_item = AgentContextItem(
             item_id=item_id,
             role="tool",

engine/tests/unit/agents/test_openai_event_mapper.py

@@ -138,3 +138,36 @@ def test_raw_text_delta_produces_delta_only() -> None:
     assert mapped.output_item is None
     assert mapped.delta is not None
     assert mapped.delta.text_delta == "par"
+
+
+def test_tool_call_and_output_have_distinct_item_ids_when_raw_id_missing() -> None:
+    """Regression: when the SDK's raw item lacks an ``id``, both the
+    tool_call and tool_output events used to fall back to the same
+    ``call_id`` for ``item_id``, so ``AgentContext._index`` overwrote the
+    first entry and ``get_context_item`` returned the wrong item.
+    """
+    mapper = OpenAiEventMapper()
+    call_event = _wrap_item(
+        SimpleNamespace(
+            type="tool_call_item",
+            raw_item=SimpleNamespace(
+                # No ``id`` attribute — exercises the fallback.
+                call_id="call_xyz",
+                name="query_traces",
+                arguments="{}",
+            ),
+        )
+    )
+    output_event = _wrap_item(
+        SimpleNamespace(
+            type="tool_call_output_item",
+            raw_item=SimpleNamespace(call_id="call_xyz", name="query_traces"),
+            output="ok",
+        )
+    )
+
+    call_mapped = mapper.to_mapped_event(call_event, execution=_exec(), is_root=True)
+    output_mapped = mapper.to_mapped_event(output_event, execution=_exec(), is_root=True)
+    assert call_mapped.context_item is not None
+    assert output_mapped.context_item is not None
+    assert call_mapped.context_item.item_id != output_mapped.context_item.item_id