fix(tracing): stamp sgp evals ids on local activity spans too

Local activities go through start_local_activity, which the outbound
interceptor did not override, so their spans carried no run or row id.
Also pin the worker's interceptor wiring.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: mohammadatallah-scale

src/agentex/lib/core/tracing/sgp_evals_interceptor.py

@@ -16,6 +16,7 @@
     Interceptor,
     StartActivityInput,
     ExecuteActivityInput,
+    StartLocalActivityInput,
     ActivityInboundInterceptor,
     WorkflowInboundInterceptor,
     WorkflowOutboundInterceptor,
@@ -47,14 +48,23 @@ def init(self, outbound: WorkflowOutboundInterceptor) -> None:
         super().init(_WorkflowOutbound(outbound))
 
 
+def _add_attrs_header(input: StartActivityInput | StartLocalActivityInput) -> None:
+    attrs = workflow.memo_value(MEMO_KEY, default=None)
+    if isinstance(attrs, dict) and attrs:
+        input.headers = {**input.headers, ATTRS_HEADER: _converter.to_payload(attrs)}
+
+
 class _WorkflowOutbound(WorkflowOutboundInterceptor):
     @override
     def start_activity(self, input: StartActivityInput) -> workflow.ActivityHandle[Any]:
-        attrs = workflow.memo_value(MEMO_KEY, default=None)
-        if isinstance(attrs, dict) and attrs:
-            input.headers = {**input.headers, ATTRS_HEADER: _converter.to_payload(attrs)}
+        _add_attrs_header(input)
         return super().start_activity(input)
 
+    @override
+    def start_local_activity(self, input: StartLocalActivityInput) -> workflow.ActivityHandle[Any]:
+        _add_attrs_header(input)
+        return super().start_local_activity(input)
+
 
 class _ActivityInbound(ActivityInboundInterceptor):
     @override

tests/lib/core/tracing/test_sgp_evals.py

@@ -11,10 +11,11 @@
 import uuid
 from typing import Any
 from datetime import UTC, datetime
+from contextlib import ExitStack
 from unittest.mock import Mock, AsyncMock, patch
 
 import pytest
-from temporalio.worker import StartActivityInput
+from temporalio.worker import StartActivityInput, StartLocalActivityInput
 
 from agentex.types.span import Span
 from agentex.types.task import Task
@@ -24,6 +25,7 @@
 from agentex.types.task_message_content import TextContent
 from agentex.lib.sdk.fastacp.impl.sync_acp import SyncACP
 from agentex.lib.core.clients.temporal.types import ConflictWorkflowPolicy
+from agentex.lib.core.temporal.workers.worker import AgentexWorker
 from agentex.lib.core.temporal.services.temporal_task_service import TemporalTaskService
 from agentex.lib.core.tracing.processors.sgp_tracing_processor import _sgp_metadata
 
@@ -226,3 +228,33 @@ def test_workflow_without_memo_adds_no_header(self) -> None:
             interceptor._WorkflowOutbound(next_outbound).start_activity(start_input)
 
         assert sent["headers"] == {}
+
+    def test_local_activities_get_the_header_too(self) -> None:
+        sent: dict[str, Any] = {}
+        next_outbound = Mock()
+        next_outbound.start_local_activity = lambda input: sent.update(headers=input.headers)
+        start_input = Mock(spec=StartLocalActivityInput, headers={})
+
+        with patch.object(interceptor.workflow, "memo_value", return_value=EXPECTED_ATTRS):
+            interceptor._WorkflowOutbound(next_outbound).start_local_activity(start_input)
+
+        assert interceptor.ATTRS_HEADER in sent["headers"]
+
+    async def test_worker_runs_with_the_interceptor_ahead_of_agent_interceptors(self) -> None:
+        agent_interceptor = interceptor.SGPEvalsInterceptor()
+        module = "agentex.lib.core.temporal.workers.worker"
+        with ExitStack() as stack:
+            stack.enter_context(patch(f"{module}.EnvironmentVariables"))
+            stack.enter_context(patch(f"{module}.init_sgp_obs"))
+            for name in ("shutdown_sgp_obs", "shutdown_default_span_queue", "shutdown_sync_tracing_processors", "get_temporal_client"):
+                stack.enter_context(patch(f"{module}.{name}", new=AsyncMock()))
+            worker_cls = stack.enter_context(patch(f"{module}.Worker"))
+            worker_cls.return_value.run = AsyncMock()
+            worker = AgentexWorker(task_queue="q", interceptors=[agent_interceptor])
+            stack.enter_context(patch.object(worker, "start_health_check_server", new=AsyncMock()))
+            stack.enter_context(patch.object(worker, "_register_agent", new=AsyncMock()))
+            await worker.run(activities=[], workflow=object)
+
+        interceptors = worker_cls.call_args.kwargs["interceptors"]
+        assert isinstance(interceptors[0], interceptor.SGPEvalsInterceptor)
+        assert interceptors[1:] == [agent_interceptor]