agent-engine-runner-shared 0.11.12__tar.gz → 0.11.14__tar.gz

{agent_engine_runner_shared-0.11.12 → agent_engine_runner_shared-0.11.14}/CHANGELOG.md

@@ -8,6 +8,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Changed
+- Spans go to the platform trace endpoint (`POST /internal/traces`) by default
+  whenever `OE_URL` is set, so the OE can redact PII in them. `AGENTIC_TRACE_EXPORTER`
+  no longer needs to be `1`; set it to `0` or `false` to keep the direct MongoDB
+  path, which stores spans without redaction. `0.11.14` is the Python floor
+  for span redaction. Earlier releases write spans straight to MongoDB unless
+  `AGENTIC_TRACE_EXPORTER=1`, and the platform cannot detect this.
 - **Breaking:** the connector `tool.yaml` `auth` block no longer takes `type`.
   It names exactly one credential: `bearer: <secret>`, `basic: {username,
   password}`, `api_keys: [{env, location, name, prefix}]`, or

{agent_engine_runner_shared-0.11.12 → agent_engine_runner_shared-0.11.14}/Dockerfile

@@ -5,7 +5,7 @@
 # Usage: docker buildx build -t runner:latest -f packages/python/packages/agent-engine-runner-shared/Dockerfile .
 
 ARG BASE_TARGETPLATFORM=linux/amd64
-ARG RUNNER_BASE_IMAGE=664315256653.dkr.ecr.us-east-1.amazonaws.com/base/amazonlinux2023-python:v3.11-202610292259-5f96580@sha256:25c595ee77900889cc75ece11461542ab2b7251d3d0febf1b107b225ac7cac03
+ARG RUNNER_BASE_IMAGE=664315256653.dkr.ecr.us-east-1.amazonaws.com/base/amazonlinux2023-python:v3.11-202611021131-0cb5df7@sha256:059f4396b31473f85e83c9219255b37f7b24e3caaef1c129363d50bc50383ceb
 
 FROM --platform=${BASE_TARGETPLATFORM} ghcr.io/astral-sh/uv@sha256:ff07b86af50d4d9391d9daf4ff89ce427bc544f9aae87057e69a1cc0aa369946 AS uv
 

{agent_engine_runner_shared-0.11.12 → agent_engine_runner_shared-0.11.14}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: agent-engine-runner-shared
-Version: 0.11.12
+Version: 0.11.14
 Summary: Runner SDK - Framework-agnostic agent runtime
 License: Apache-2.0
 License-File: LICENSE
 Requires-Python: >=3.11
-Requires-Dist: agent-engine-sdk-memory==0.11.12
-Requires-Dist: agent-engine-sdk==0.11.12
+Requires-Dist: agent-engine-sdk-memory==0.11.14
+Requires-Dist: agent-engine-sdk==0.11.14
 Requires-Dist: fastapi>=0.141.1
 Requires-Dist: filelock>=3.0.0
 Requires-Dist: httpx-sse>=0.4.0

{agent_engine_runner_shared-0.11.12 → agent_engine_runner_shared-0.11.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-engine-runner-shared"
-version = "0.11.12"
+version = "0.11.14"
 description = "Runner SDK - Framework-agnostic agent runtime"
 readme = "README.md"
 license = {text = "Apache-2.0"}
@@ -27,9 +27,9 @@ dependencies = [
     "jsonschema>=4.26.0",
     "sentry-sdk>=2.27.0",
     # BaseAgent protocol and AgentInput/AgentEvent models
-    "agent-engine-sdk==0.11.12",
+    "agent-engine-sdk==0.11.14",
     # Memory models and the MemoryClient HTTP client
-    "agent-engine-sdk-memory==0.11.12",
+    "agent-engine-sdk-memory==0.11.14",
     # Required for checkpoint message decoding (query/sessions endpoints)
     "msgpack>=1.0.0",
     # Required by guardrails_evaluator/regex.py for advanced regex matching

{agent_engine_runner_shared-0.11.12 → agent_engine_runner_shared-0.11.14}/src/agent_engine_runner_shared/connectors/generate/authoring.py

@@ -269,17 +269,17 @@ def _egress_target(base_url: str) -> tuple[str, int]:
 def _guidance_comment(base_url: str, auth: Auth | None) -> str:
     """Report the agent.yaml policy this connector needs, as a file comment.
 
-    Platform policy stays explicit and developer-owned: nothing here writes or
-    derives agent.yaml. The egress hint is a command so it adapts to whichever
-    egress shape the manifest already uses, and every interpolated value passes
-    the generator's control-byte sanitizer so no value can escape the comment.
+    The generator never edits agent.yaml; the CLI's create-tool does that after it
+    returns. The egress hint is a command so it adapts to whichever egress shape
+    the manifest already uses, and every interpolated value passes the generator's
+    control-byte sanitizer so no value can escape the comment.
     """
     host, port = _egress_target(base_url)
     envs = auth.secret_names() if auth is not None else []
     target = f"{_quote(host)}:{port}"
     lines = [
-        "# Connector operations execute in the tool sandbox; this file enables no",
-        "# platform policy. Declare the connector's requirements in agent.yaml:",
+        "# Connector operations execute in the tool sandbox. agent.yaml needs these;",
+        "# agentengine agent create-tool and agent validate --fix can add them:",
         f"#   egress   allow {target} from the tool sandbox, e.g.",
         f"#            agentengine agent egress add --component tool {shlex.quote(target)}",
     ]
@@ -297,6 +297,8 @@ def _guidance_comment(base_url: str, auth: Auth | None) -> str:
         lines.append("#   secret   none required in the tool sandbox; tokens are request-local")
     else:
         lines.append("#   secret   none required; this connector authenticates anonymously")
+    lines.append("#   tools    list this connector's tools under sandboxes.tool.tools when")
+    lines.append("#            agent.yaml has a sandboxes block")
     return "\n".join(lines) + "\n"
 
 

{agent_engine_runner_shared-0.11.12 → agent_engine_runner_shared-0.11.14}/src/agent_engine_runner_shared/server/tool.py

@@ -66,6 +66,7 @@ from agent_engine_runner_shared.tool_api_error import (
     request_named_credential_values,
 )
 from agent_engine_runner_shared.toolpod_handlers import BUILTIN_TOOL_NAMES
+from agent_engine_runner_shared.tracing.conversation import caller_records_conversation
 from agent_engine_runner_shared.utils import (
     LLM_BACKOFF_MULTIPLIER,
     LLM_INITIAL_BACKOFF,
@@ -1172,11 +1173,15 @@ class ToolServer(ToolExecution, BaseServer):
             trace_id=request.platform_trace_id,
         )
         try:
-            # Usually a no-op after startup; keep any registry load inside the
-            # request's credential isolation, as with model execution below.
-            async with self._credential_isolation():
-                await self._ensure_llm_registry_loaded()
-                chunks = [chunk async for chunk in self._stream_llm_chunks(request)]
+            # The calling agent's span stores this prompt; the model span this
+            # call produces would be a second copy of it.
+            with caller_records_conversation():
+                # Usually a no-op after startup; keep any registry load inside
+                # the request's credential isolation, as with model execution
+                # below.
+                async with self._credential_isolation():
+                    await self._ensure_llm_registry_loaded()
+                    chunks = [chunk async for chunk in self._stream_llm_chunks(request)]
             llm_response = SecureLLMProxy.response_from_stream_chunks(chunks)
             duration_ms = (time.time() - start_time) * 1000
             return LLMPodInvokeResponse(
@@ -1277,24 +1282,27 @@ class ToolServer(ToolExecution, BaseServer):
         )
         try:
             usage = None
-            # See the gate + metadata-env ordering rationale in
-            # _handle_invoke_llm above.
-            async with self._credential_isolation():
-                await self._ensure_llm_registry_loaded()
-                async for stream_chunk in self._stream_llm_chunks(request):
-                    if not _stream_chunk_has_payload(stream_chunk):
-                        if stream_chunk.usage is not None:
-                            usage = stream_chunk.usage
-                        continue
-                    chunk_event = LLMPodStreamEvent(
-                        content=stream_chunk.content,
-                        tool_call_chunks=stream_chunk.tool_calls,
-                        id=stream_chunk.id,
-                        name=stream_chunk.name,
-                        response_metadata=stream_chunk.response_metadata,
-                        additional_kwargs=stream_chunk.additional_kwargs,
-                    )
-                    yield f"data: {chunk_event.model_dump_json(exclude_none=True)}\n\n"
+            # The calling agent's span stores this prompt; the model span this
+            # call produces would be a second copy of it.
+            with caller_records_conversation():
+                # See the gate + metadata-env ordering rationale in
+                # _handle_invoke_llm above.
+                async with self._credential_isolation():
+                    await self._ensure_llm_registry_loaded()
+                    async for stream_chunk in self._stream_llm_chunks(request):
+                        if not _stream_chunk_has_payload(stream_chunk):
+                            if stream_chunk.usage is not None:
+                                usage = stream_chunk.usage
+                            continue
+                        chunk_event = LLMPodStreamEvent(
+                            content=stream_chunk.content,
+                            tool_call_chunks=stream_chunk.tool_calls,
+                            id=stream_chunk.id,
+                            name=stream_chunk.name,
+                            response_metadata=stream_chunk.response_metadata,
+                            additional_kwargs=stream_chunk.additional_kwargs,
+                        )
+                        yield f"data: {chunk_event.model_dump_json(exclude_none=True)}\n\n"
 
             # Final summary event
             duration_ms = (time.time() - start_time) * 1000

{agent_engine_runner_shared-0.11.12 → agent_engine_runner_shared-0.11.14}/src/agent_engine_runner_shared/tracing/conversation.py

@@ -10,6 +10,11 @@ the previous call in the same trace and stream, and records where that slice
 starts. A reader replays the slices to rebuild the full context. Spans
 written before this existed carry no offset and read as a full list, so old
 and new traces read the same way.
+
+The platform forwards an agent's LLM call to a tool pod that makes the
+provider request, and both processes instrument it. The caller's span stores
+the conversation for that call, so the tool-pod copy is dropped outright
+(``omit_input_messages``) instead of being trimmed a second time.
 """
 
 from __future__ import annotations
@@ -18,6 +23,9 @@ import hashlib
 import os
 import re
 from collections import OrderedDict
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
 from typing import Any, Dict, List, Mapping
 
 # The trace UI reads these; keep the names in sync with
@@ -25,6 +33,11 @@ from typing import Any, Dict, List, Mapping
 ATTR_INPUT_MESSAGES_OFFSET = "agent_engine.internal.input_messages.offset"
 ATTR_INPUT_MESSAGES_TOTAL = "agent_engine.internal.input_messages.total"
 ATTR_INPUT_MESSAGES_STREAM = "agent_engine.internal.input_messages.stream"
+# Written on a span whose prompt the calling pod stores itself. The platform
+# forwards an agent's LLM call to a tool pod that makes the provider request, so
+# both processes record the same conversation; the tool-pod copy is redundant.
+ATTR_INPUT_MESSAGES_RECORDED_BY = "agent_engine.internal.input_messages.recorded_by"
+RECORDED_BY_CALLER = "caller"
 
 # Resource attribute carrying the pod's role. The name predates the product
 # rename and is the contract the runner already emits on every span, not
@@ -39,6 +52,52 @@ _INPUT_MESSAGES_KEY = re.compile(r"^llm\.input_messages\.(\d+)\.(.+)$")
 # correctness, since a missing entry reads as "store the full list".
 MAX_TRACKED_CONVERSATIONS = 256
 
+# True while the tool pod runs an LLM call the agent made and already records.
+# A span ends — and is exported — before the request span that names the call,
+# so the trace tree cannot say at write time where a prompt is stored; the
+# process that forwards the call is the only one that knows.
+_CALLER_RECORDED: ContextVar[bool] = ContextVar("caller_recorded_conversation", default=False)
+
+
+@contextmanager
+def caller_records_conversation() -> Iterator[None]:
+    """Mark spans started in this block as a call the caller already stores.
+
+    Scoped to the tool pod's platform-forwarded LLM routes. A prompt recorded
+    only here — a tool that calls a provider itself — stays unmarked and keeps
+    its messages.
+    """
+    token = _CALLER_RECORDED.set(True)
+    try:
+        yield
+    finally:
+        _CALLER_RECORDED.reset(token)
+
+
+def mark_recorded_by_caller(span: Any) -> None:
+    """Attribute a span whose prompt the calling pod already stores.
+
+    Called for every span as it starts; only spans carrying a prompt use the
+    attribute, which is how the trace store and its readers find the copy.
+    """
+    if _CALLER_RECORDED.get():
+        span.set_attribute(ATTR_INPUT_MESSAGES_RECORDED_BY, RECORDED_BY_CALLER)
+
+
+def omit_input_messages(attributes: Mapping[str, Any]) -> Dict[str, Any]:
+    """Drop a span's prompt, keeping the marker that says where it lives."""
+    omitted = {
+        name: value
+        for name, value in attributes.items()
+        if not name.startswith(_INPUT_MESSAGES_PREFIX)
+    }
+    # OpenInference also serializes the prompt into input.value; leaving it
+    # would store the conversation the marker says is stored elsewhere.
+    omitted.pop("input.value", None)
+    omitted.pop("input.mime_type", None)
+    omitted[ATTR_INPUT_MESSAGES_RECORDED_BY] = RECORDED_BY_CALLER
+    return omitted
+
 
 def _fingerprint(message: Mapping[str, Any]) -> bytes:
     """Stable digest of one message's fields, for prefix comparison.

{agent_engine_runner_shared-0.11.12 → agent_engine_runner_shared-0.11.14}/src/agent_engine_runner_shared/tracing/exporters.py

@@ -22,15 +22,18 @@ import random
 import threading
 import time
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, Sequence
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, Mapping, Sequence
 
 import httpx
 from opentelemetry.sdk.trace import Event, ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
 from agent_engine_runner_shared.tracing.conversation import (
+    ATTR_INPUT_MESSAGES_RECORDED_BY,
+    RECORDED_BY_CALLER,
     ConversationDeltaTracker,
     has_input_messages,
+    omit_input_messages,
     trace_stream,
 )
 
@@ -109,16 +112,45 @@ def _span_to_dict(span: ReadableSpan) -> Dict[str, Any]:
     return doc
 
 
+def _conversation_attributes(
+    attributes: Mapping[str, Any],
+    *,
+    trace_id: str,
+    resource: Mapping[str, Any],
+    tracker: ConversationDeltaTracker,
+) -> Dict[str, Any] | None:
+    """Return the attributes to store for one span, or None to keep them as-is.
+
+    Shared by both export destinations so a span's conversation is deduplicated
+    the same way whichever store it reaches.
+    """
+    if attributes.get(ATTR_INPUT_MESSAGES_RECORDED_BY) == RECORDED_BY_CALLER:
+        # The caller's span holds this prompt. Dropping it here and leaving the
+        # tracker alone keeps a later tool-pod span — one that records its own
+        # conversation — starting from a full list rather than a bogus offset.
+        return omit_input_messages(attributes)
+    if not has_input_messages(attributes):
+        return None
+    return tracker.trim(
+        attributes,
+        trace_id=trace_id,
+        stream_id=trace_stream(resource),
+    )
+
+
 def _trim_conversation(doc: Dict[str, Any], tracker: ConversationDeltaTracker) -> Dict[str, Any]:
     """Keep only the input messages this call added (see tracing.conversation)."""
     attributes = doc.get("attributes")
-    if not attributes or not has_input_messages(attributes):
+    if not attributes:
         return doc
-    doc["attributes"] = tracker.trim(
+    trimmed = _conversation_attributes(
         attributes,
         trace_id=doc["trace_id"],
-        stream_id=trace_stream(doc.get("resource") or {}),
+        resource=doc.get("resource") or {},
+        tracker=tracker,
     )
+    if trimmed is not None:
+        doc["attributes"] = trimmed
     return doc
 
 
@@ -372,6 +404,51 @@ def _redact_span(span: ReadableSpan) -> ReadableSpan:
     )
 
 
+def _with_attributes(span: ReadableSpan, attributes: Dict[str, Any]) -> ReadableSpan:
+    """Return a copy of ``span`` carrying ``attributes`` in place of its own.
+
+    The OTLP encoder reads ``dropped_attributes`` off the container, so a plain
+    dict goes into the same wrapper the redaction path builds.
+    """
+    return _RedactedReadableSpan(
+        dropped_attributes=span.dropped_attributes,
+        dropped_events=span.dropped_events,
+        name=span.name,
+        context=span.context,
+        parent=span.parent,
+        resource=span.resource,
+        attributes=attributes,
+        events=span.events,
+        links=span.links,
+        kind=span.kind,
+        status=span.status,
+        start_time=span.start_time,
+        end_time=span.end_time,
+        instrumentation_scope=span.instrumentation_scope,
+    )
+
+
+def _trim_span(span: ReadableSpan, tracker: ConversationDeltaTracker) -> ReadableSpan | None:
+    """Return ``span`` with only this call's new messages, or None if unchanged.
+
+    The span-level form of ``_trim_conversation``, for destinations that encode
+    the span rather than building a document from it.
+    """
+    attributes = span.attributes
+    if not attributes:
+        return None
+    context = span.get_span_context()
+    trimmed = _conversation_attributes(
+        attributes,
+        trace_id=format(context.trace_id, "032x"),  # type: ignore[union-attr]  # ctx is set by get_span_context()
+        resource=dict(span.resource.attributes) if span.resource else {},
+        tracker=tracker,
+    )
+    if trimmed is None:
+        return None
+    return _with_attributes(span, trimmed)
+
+
 class ContentPolicyOTLPSpanExporter(SpanExporter):
     """Wraps an OTLP SpanExporter, enforcing AGENTIC_PLATFORM_OTEL_CONTENT_CAPTURE.
 
@@ -653,6 +730,7 @@ class PlatformSpanExporter(SpanExporter):
         self._sleep = sleep
         self._clock = clock
         self._lock = threading.Lock()
+        self._conversations = ConversationDeltaTracker()
         self._dropped_spans = 0
         self._failed_batches = 0
         self._last_error: str | None = None
@@ -675,7 +753,17 @@ class PlatformSpanExporter(SpanExporter):
         dropped_before = self.dropped_spans
         ok = True
         for chunk in self._chunk_by_size(list(spans)):
-            if not self._export_chunk(chunk, deadline):
+            # Stage per chunk and commit only what the OE stored, so a batch it
+            # refused does not advance past messages the store never received.
+            staged = self._conversations.copy()
+            trimmed = [_trim_span(span, staged) or span for span in chunk]
+            dropped_before_chunk = self.dropped_spans
+            if self._export_chunk(trimmed, deadline):
+                # A partial success drops spans without naming them, so the
+                # next call restates those messages instead of leaving a gap.
+                if self.dropped_spans == dropped_before_chunk:
+                    self._conversations = staged
+            else:
                 ok = False
 
         if ok:

{agent_engine_runner_shared-0.11.12 → agent_engine_runner_shared-0.11.14}/src/agent_engine_runner_shared/tracing/setup.py

@@ -27,6 +27,7 @@ from opentelemetry.sdk.trace import ReadableSpan, Span, SpanProcessor, TracerPro
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
 
+from .conversation import mark_recorded_by_caller
 from .exporters import (
     ContentPolicyOTLPSpanExporter,
     MongoDBSpanExporter,
@@ -62,16 +63,17 @@ _retry_thread: Optional[threading.Thread] = None
 # clients.
 _tracing_mongo_client: Optional["MongoClient"] = None
 
-# Platform trace-exporter state. The exporter is off by default and enabled
-# per workspace with the flag named by `_PLATFORM_TRACE_EXPORTER_ENV`; when on
-# (and OE_URL is set) the guest sends spans to the OE instead of writing
-# MongoDB directly. `_platform_exporter` is retained so /health can report its
-# recent export results and shutdown can reset it.
+# Platform trace-exporter state. The exporter is on whenever OE_URL is set; the
+# flag named by `_PLATFORM_TRACE_EXPORTER_ENV` only turns it off. When on, the
+# guest sends spans to the OE instead of writing MongoDB directly.
+# `_platform_exporter` is retained so /health can report its recent export
+# results and shutdown can reset it.
 _platform_exporter: Optional[PlatformSpanExporter] = None
 _platform_exporter_attached: bool = False
 
-# Feature flag: route runner spans to the OE platform trace endpoint. Off by
-# default, so an unset value keeps the MongoDB trace-store path. Deliberately
+# Opt-out for routing runner spans to the OE platform trace endpoint. Unset
+# means on. Setting it to "0" or "false" keeps the MongoDB trace-store path: the
+# OE never sees those spans, so PII redaction cannot apply to them. Deliberately
 # avoids the reserved tenant-secret prefix, which a workspace secret cannot use
 # (pkg/tenantsecrets), so a workspace can set this one directly.
 _PLATFORM_TRACE_EXPORTER_ENV = "AGENTIC_TRACE_EXPORTER"
@@ -145,13 +147,12 @@ def _otlp_endpoint_configured() -> bool:
 def platform_trace_exporter_enabled() -> bool:
     """Whether the OE platform trace exporter is enabled.
 
-    Off by default: the flag gates the rollout, so an unset (or unrecognized)
-    value keeps the MongoDB trace-store path. A workspace enables it by setting
-    the env var named by ``_PLATFORM_TRACE_EXPORTER_ENV`` to ``1`` or ``true``.
-    It is only half the condition — the exporter also needs ``OE_URL`` to know
-    where to send spans.
+    On unless the env var named by ``_PLATFORM_TRACE_EXPORTER_ENV`` is ``0`` or
+    ``false``. Any other value, including an unrecognized one, keeps it on so a
+    typo cannot silently route spans past the OE. It is only half the
+    condition — the exporter also needs ``OE_URL`` to know where to send spans.
     """
-    return os.getenv(_PLATFORM_TRACE_EXPORTER_ENV, "").strip().lower() in ("1", "true")
+    return os.getenv(_PLATFORM_TRACE_EXPORTER_ENV, "").strip().lower() not in ("0", "false")
 
 
 class ExecutionContextSpanProcessor(SpanProcessor):
@@ -164,6 +165,8 @@ class ExecutionContextSpanProcessor(SpanProcessor):
             get_current_workspace_id,
         )
 
+        mark_recorded_by_caller(span)
+
         session_id = get_current_session_id()
         attrs = {
             "execution.id": get_current_execution_id(),
@@ -234,13 +237,20 @@ def setup_tracing(
 
     provider.add_span_processor(ExecutionContextSpanProcessor())
 
-    # Destination: the OE platform trace endpoint when the feature flag is on
-    # and OE_URL is set, otherwise the caller-supplied MongoDB collection. With
-    # the flag on the OE is the platform trace path and takes precedence — a
-    # guest with both must not keep writing MongoDB directly.
+    # Destination: the OE platform trace endpoint whenever OE_URL is set,
+    # otherwise the caller-supplied MongoDB collection. The OE is the platform
+    # trace path and takes precedence — a guest with both must not keep writing
+    # MongoDB directly.
     oe_url = os.getenv("OE_URL", "").strip()
     otlp_configured = _otlp_endpoint_configured()
-    if oe_url and platform_trace_exporter_enabled():
+    use_platform = bool(oe_url) and platform_trace_exporter_enabled()
+    if oe_url and not use_platform:
+        logger.warning(
+            "Tracing: %s disables the platform trace exporter; spans go to the "
+            "trace store without PII redaction",
+            _PLATFORM_TRACE_EXPORTER_ENV,
+        )
+    if use_platform:
         _attach_platform_exporter(provider, oe_url)
     elif mongodb_collection is not None:
         provider.add_span_processor(BatchSpanProcessor(MongoDBSpanExporter(mongodb_collection)))
@@ -396,7 +406,7 @@ def tracing_status() -> dict[str, str]:
 
     ``platform_exporter`` is ``attached`` (spans are sent to the OE),
     ``degraded`` (the most recent export did not fully succeed), or
-    ``disabled`` (the feature flag is off or OE_URL unset; OTLP may still be
+    ``disabled`` (the opt-out is set or OE_URL unset; OTLP may still be
     configured).
     """
     if _platform_exporter_attached:

{agent_engine_runner_shared-0.11.12 → agent_engine_runner_shared-0.11.14}/tests/unit/connectors/test_generate.py

@@ -2236,6 +2236,7 @@ class TestAuthoringGuidance:
         )
         assert "#   secret   grant WEATHER_TOKEN to the tool sandbox under" in text
         assert "#            sandboxes.tool.secrets (sandboxes requires an agent block)" in text
+        assert "#   tools    list this connector's tools under sandboxes.tool.tools when" in text
         # Guidance is a comment only: the parsed authoring file is unchanged.
         assert yaml.safe_load(text) == {
             "name": "weather",

{agent_engine_runner_shared-0.11.12 → agent_engine_runner_shared-0.11.14}/tests/unit/test_llm_routing.py

@@ -1585,3 +1585,60 @@ class TestNamedLLMRouting:
         )
         _ = [chunk async for chunk in server._stream_llm_chunks(request)]
         assert captured["llm_id"] == "secondary"
+
+
+class TestCallerRecordedConversation:
+    """The tool pod does not store a prompt the calling agent already stores."""
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize("streaming", [False, True])
+    async def test_the_platform_forwarded_call_marks_its_spans(self, streaming):
+        from agent_engine_runner_shared.tracing.conversation import (
+            ATTR_INPUT_MESSAGES_RECORDED_BY,
+            RECORDED_BY_CALLER,
+            mark_recorded_by_caller,
+        )
+
+        server = _make_tool_server()
+        markers: list[object] = []
+
+        async def provider_stream(*args, **kwargs):
+            # Stands in for the framework instrumentor creating the model span.
+            span = MagicMock()
+            mark_recorded_by_caller(span)
+            markers.append(span.set_attribute.call_args)
+            yield LLMStreamChunk(content="ok")
+
+        request = LLMPodInvokeRequest(
+            execution_id="exec-1",
+            arguments=InvokeLLMRequestArguments(
+                model="gpt-4o",
+                messages=[{"role": "user", "content": "Hi"}],
+            ),
+        )
+        with patch.object(
+            server,
+            "_create_llm_for_pod",
+            return_value=SimpleNamespace(astream=provider_stream),
+        ):
+            if streaming:
+                _ = [frame async for frame in server._handle_invoke_llm_stream(request)]
+            else:
+                await server._handle_invoke_llm(request)
+
+        assert markers == [
+            ((ATTR_INPUT_MESSAGES_RECORDED_BY, RECORDED_BY_CALLER),),
+        ]
+
+    @pytest.mark.asyncio
+    async def test_a_direct_tool_llm_call_is_not_marked(self):
+        from agent_engine_runner_shared.tracing.conversation import (
+            mark_recorded_by_caller,
+        )
+
+        # No platform route wrapped this call: the tool pod is the only
+        # recorder, so it keeps the conversation.
+        span = MagicMock()
+        mark_recorded_by_caller(span)
+
+        span.set_attribute.assert_not_called()