agent-engine-runner-shared 0.11.9__tar.gz → 0.11.11__tar.gz

{agent_engine_runner_shared-0.11.9 → agent_engine_runner_shared-0.11.11}/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Removed
+- Removed the unused pre-materialized connector bundle override
+  (`AGENTIC_CONNECTOR_BUNDLE_PATH`) and the `load_connector_bundle` /
+  `CONNECTOR_BUNDLE_PATH_ENV` exports. Connectors resolve only from
+  `agent.yaml` and its local connector authoring files.
+
+### Changed
+- Remote MCP servers now use MCP Python SDK 2.x (`mcp==2.3.0`). Each call
+  negotiates the protocol automatically: it probes `server/discover` and falls
+  back to the legacy `initialize` handshake, so servers on `2025-11-25` and
+  older keep working while `2026-07-28` servers are reached directly. Tool
+  result content keeps its wire field names (`mimeType`, `readOnlyHint`) and
+  failed HTTP calls keep reporting their status in error messages. OAuth caches
+  written by the previous SDK still load; new entries record the authorization
+  server's `issuer` when it provides one.
+- Reuse a process-wide keep-alive mTLS client for OE callbacks (tool
+  execute/result, node events, progress and custom events) and drain callback
+  response bodies so connections return to the pool; removes a full TLS
+  handshake per callback.
+
 ### Fixed
 - Uncaught exceptions in agent code now emit one filterable `level=ERROR`
   record instead of only `WARNING`. Ordinary stderr writes with no

{agent_engine_runner_shared-0.11.9 → agent_engine_runner_shared-0.11.11}/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-202512082043-f9f77a3
+ARG RUNNER_BASE_IMAGE=664315256653.dkr.ecr.us-east-1.amazonaws.com/base/amazonlinux2023-python:v3.11-202610191636-2ff39c3@sha256:30ecac067fceafe43a5f0f5e80d1725b60708204dcd2fe3f176363417e2a2402
 
 FROM --platform=${BASE_TARGETPLATFORM} ghcr.io/astral-sh/uv@sha256:ff07b86af50d4d9391d9daf4ff89ce427bc544f9aae87057e69a1cc0aa369946 AS uv
 

{agent_engine_runner_shared-0.11.9 → agent_engine_runner_shared-0.11.11}/Makefile

@@ -13,6 +13,16 @@ PYDOC_MARKDOWN := uv tool run --from 'pydoc-markdown>=4.8' pydoc-markdown
 # pydoc-markdown emits trailing spaces on blank lines and an extra trailing
 # blank line; strip both so docs-check only fails on content changes.
 NORMALIZE_DOCS := perl -0pe 's/[^\S\n]+$$//mg; s/\n+\z/\n/'
+# ruff formats the Python inside Markdown fences, so the generated reference has
+# to go through it too. Without this stage the pre-commit ruff-format hook
+# rewrites api.md and docs-check then fails on the unformatted generator output.
+# Ruff runs from the uv workspace root so it resolves from the workspace lock,
+# the same version the hook and CI pin.
+# $(CURDIR) rather than $(abspath ...): abspath splits its argument on
+# whitespace, so a checkout whose path contains a space would break. Both paths
+# are quoted at the point of use for the same reason.
+PYTHON_WORKSPACE := $(CURDIR)/../..
+FORMAT_DOCS := uv run --directory "$(PYTHON_WORKSPACE)" ruff format --stdin-filename "$(CURDIR)/docs/api.md" -
 
 # Output path for the generated reference. Defaults to the committed file;
 # override (e.g. DOCS_OUT=/tmp/api.md) to generate elsewhere without clobbering
@@ -21,11 +31,11 @@ DOCS_OUT ?= docs/api.md
 
 # Regenerate API reference from docstrings.
 docs:
-	$(PYDOC_MARKDOWN) pydoc-markdown.yml | $(NORMALIZE_DOCS) > $(DOCS_OUT)
+	$(PYDOC_MARKDOWN) pydoc-markdown.yml | $(NORMALIZE_DOCS) | $(FORMAT_DOCS) > $(DOCS_OUT)
 
 # CI: fail if docs/api.md is stale.
 docs-check:
-	@$(PYDOC_MARKDOWN) pydoc-markdown.yml | $(NORMALIZE_DOCS) > /tmp/api-docs-check.md
+	@$(PYDOC_MARKDOWN) pydoc-markdown.yml | $(NORMALIZE_DOCS) | $(FORMAT_DOCS) > /tmp/api-docs-check.md
 	@diff -u docs/api.md /tmp/api-docs-check.md || { \
 		echo ""; \
 		echo "ERROR: docs/api.md is stale. Run 'make docs' to regenerate."; \

{agent_engine_runner_shared-0.11.9 → agent_engine_runner_shared-0.11.11}/PKG-INFO

@@ -1,18 +1,19 @@
 Metadata-Version: 2.5
 Name: agent-engine-runner-shared
-Version: 0.11.9
+Version: 0.11.11
 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.9
-Requires-Dist: agent-engine-sdk==0.11.9
+Requires-Dist: agent-engine-sdk-memory==0.11.11
+Requires-Dist: agent-engine-sdk==0.11.11
 Requires-Dist: fastapi>=0.141.1
 Requires-Dist: filelock>=3.0.0
 Requires-Dist: httpx-sse>=0.4.0
+Requires-Dist: httpx2>=2.5.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: jsonschema>=4.26.0
-Requires-Dist: mcp==1.27.0
+Requires-Dist: mcp==2.3.0
 Requires-Dist: msgpack>=1.0.0
 Requires-Dist: protobuf<7,>=6.33.6
 Requires-Dist: pydantic>=2.0.0
@@ -21,7 +22,7 @@ Requires-Dist: pyyaml>=6.0
 Requires-Dist: regex>=2026.4.4
 Requires-Dist: sentry-sdk>=2.27.0
 Requires-Dist: starlette>=1.7.0
-Requires-Dist: uvicorn>=0.32.0
+Requires-Dist: uvicorn>=0.50.0
 Provides-Extra: debug
 Requires-Dist: debugpy>=1.8.0; extra == 'debug'
 Provides-Extra: dev

{agent_engine_runner_shared-0.11.9 → agent_engine_runner_shared-0.11.11}/docs/api.md

@@ -6,6 +6,8 @@
     * [agent\_config](#agent_engine_runner_shared.runtime.TenantRuntime.agent_config)
     * [memory\_enabled](#agent_engine_runner_shared.runtime.TenantRuntime.memory_enabled)
     * [get\_agent](#agent_engine_runner_shared.runtime.TenantRuntime.get_agent)
+    * [build\_graph](#agent_engine_runner_shared.runtime.TenantRuntime.build_graph)
+    * [uses\_per\_invocation\_build](#agent_engine_runner_shared.runtime.TenantRuntime.uses_per_invocation_build)
     * [warm\_up\_agent](#agent_engine_runner_shared.runtime.TenantRuntime.warm_up_agent)
     * [memory\_engine](#agent_engine_runner_shared.runtime.TenantRuntime.memory_engine)
     * [memory\_writer](#agent_engine_runner_shared.runtime.TenantRuntime.memory_writer)
@@ -174,10 +176,14 @@
     * [response\_from\_stream\_chunks](#agent_engine_runner_shared.secure_llm_proxy.SecureLLMProxy.response_from_stream_chunks)
     * [stream](#agent_engine_runner_shared.secure_llm_proxy.SecureLLMProxy.stream)
 * [agent\_engine\_runner\_shared.secure\_wrapper](#agent_engine_runner_shared.secure_wrapper)
+  * [\_OAuthAuthorizationRequired](#agent_engine_runner_shared.secure_wrapper._OAuthAuthorizationRequired)
+    * [\_\_init\_\_](#agent_engine_runner_shared.secure_wrapper._OAuthAuthorizationRequired.__init__)
+  * [oauth\_authorization\_wait\_id](#agent_engine_runner_shared.secure_wrapper.oauth_authorization_wait_id)
   * [extract\_usage](#agent_engine_runner_shared.secure_wrapper.extract_usage)
   * [PolicyDeniedException](#agent_engine_runner_shared.secure_wrapper.PolicyDeniedException)
   * [OERetryAfterError](#agent_engine_runner_shared.secure_wrapper.OERetryAfterError)
   * [ToolExecutionError](#agent_engine_runner_shared.secure_wrapper.ToolExecutionError)
+  * [ToolPlatformError](#agent_engine_runner_shared.secure_wrapper.ToolPlatformError)
   * [TerminalExecutionError](#agent_engine_runner_shared.secure_wrapper.TerminalExecutionError)
   * [raise\_for\_oe\_rejection](#agent_engine_runner_shared.secure_wrapper.raise_for_oe_rejection)
   * [ToolCallTimeoutError](#agent_engine_runner_shared.secure_wrapper.ToolCallTimeoutError)
@@ -343,7 +349,9 @@ Return the resolved agent.yaml Memory feature setting.
 #### get\_agent
 
 ```python
-def get_agent(callbacks: List[Any] | None = None) -> BaseAgent
+def get_agent(callbacks: List[Any] | None = None,
+              *,
+              graph: Any = None) -> BaseAgent
 ```
 
 Get a BaseAgent instance from the registered App.
@@ -355,6 +363,9 @@ framework-specific graph building and callback adaptation.
 
 - `callbacks` - Framework-neutral callbacks for observability
   (e.g., NodeExecutionLogger)
+- `graph` - A graph already built by ``build_graph`` for this
+  invocation (a per-execution agent). Only forwarded when
+  present, so an App that does not accept it keeps working.
 
 
 **Returns**:
@@ -366,6 +377,37 @@ framework-specific graph building and callback adaptation.
 
 - `RuntimeError` - If no App has been registered via register_and_run()
 
+<a id="agent_engine_runner_shared.runtime.TenantRuntime.build_graph"></a>
+
+#### build\_graph
+
+```python
+async def build_graph(agent_input: Any = None, ctx: Any = None) -> Any
+```
+
+Build the graph for this invocation before ``get_agent``.
+
+The AER awaits this so a per-execution agent's builder -- which may do
+its own async I/O -- runs off the build path. Returns ``None`` when the
+registered App declares no per-execution build (every global agent),
+which tells the caller to use the cached build path unchanged. A
+context-free discovery call passes ``(None, None)``.
+
+<a id="agent_engine_runner_shared.runtime.TenantRuntime.uses_per_invocation_build"></a>
+
+#### uses\_per\_invocation\_build
+
+```python
+def uses_per_invocation_build() -> bool
+```
+
+Whether the registered App builds its graph per invocation.
+
+True only for an App that opted into ``load_strategy="per-execution"``.
+The Tool Pod reads this to decide whether a failed context-free
+discovery build should keep the registrations the builder made before
+it raised, rather than discarding them.
+
 <a id="agent_engine_runner_shared.runtime.TenantRuntime.warm_up_agent"></a>
 
 #### warm\_up\_agent
@@ -2733,6 +2775,36 @@ This module provides:
 
 HITL is handled via LangGraph's native interrupt() / Command(resume=...) API.
 
+<a id="agent_engine_runner_shared.secure_wrapper._OAuthAuthorizationRequired"></a>
+
+## \_OAuthAuthorizationRequired
+
+```python
+class _OAuthAuthorizationRequired(Exception)
+```
+
+Leave durable dispatch with typed consent control instead of interrupting its activity.
+
+<a id="agent_engine_runner_shared.secure_wrapper._OAuthAuthorizationRequired.__init__"></a>
+
+#### \_\_init\_\_
+
+```python
+def __init__(elicitation: ElicitationInfo, step: int) -> None
+```
+
+Carry the OE response to its activity boundary without exposing it in errors.
+
+<a id="agent_engine_runner_shared.secure_wrapper.oauth_authorization_wait_id"></a>
+
+#### oauth\_authorization\_wait\_id
+
+```python
+def oauth_authorization_wait_id(value: Any) -> str | None
+```
+
+Identify a consent wait only when this attempt recorded the platform's challenge.
+
 <a id="agent_engine_runner_shared.secure_wrapper.extract_usage"></a>
 
 #### extract\_usage
@@ -2783,12 +2855,26 @@ class ToolExecutionError(Exception)
 
 Raised when tool execution fails.
 
+<a id="agent_engine_runner_shared.secure_wrapper.ToolPlatformError"></a>
+
+## ToolPlatformError
+
+```python
+class ToolPlatformError(ToolExecutionError)
+```
+
+Raised when the platform, not the tool, failed a tool call.
+
+The tool may already have run, for example when OE rejects or never
+acknowledges its result, so an adapter must not report this to the model as
+a failed tool it could call again.
+
 <a id="agent_engine_runner_shared.secure_wrapper.TerminalExecutionError"></a>
 
 ## TerminalExecutionError
 
 ```python
-class TerminalExecutionError(ToolExecutionError)
+class TerminalExecutionError(ToolPlatformError)
 ```
 
 Raised when OE rejects a tool call because the execution already ended.
@@ -3077,24 +3163,30 @@ Clean up resources owned by this execution's wrapper.
 #### execute\_tool
 
 ```python
-def execute_tool(tool_name: str,
-                 arguments: Dict[str, Any],
-                 *,
-                 metadata: Optional[Dict[str, Any]] = None,
-                 provider_type: Optional[str] = None,
-                 scopes: Optional[list[str]] = None,
-                 tool_call_id: Optional[str] = None,
-                 raw_on_interrupt: bool = False,
-                 redact_fields: Optional[list[str]] = None,
-                 is_local: bool = True,
-                 local_executor: Optional[Callable[[], Any]] = None,
-                 is_framework_control_flow: Optional[Callable[[BaseException],
-                                                              bool]] = None,
-                 call_channel_expected: bool = False) -> Any
+def execute_tool(
+        tool_name: str,
+        arguments: Dict[str, Any],
+        *,
+        metadata: Optional[Dict[str, Any]] = None,
+        provider_type: Optional[str] = None,
+        scopes: Optional[list[str]] = None,
+        tool_call_id: Optional[str] = None,
+        raw_on_interrupt: bool = False,
+        redact_fields: Optional[list[str]] = None,
+        is_local: bool = True,
+        local_executor: Optional[Callable[[], Any]] = None,
+        is_framework_control_flow: Optional[Callable[[BaseException],
+                                                     bool]] = None,
+        call_channel_expected: bool = False,
+        on_unknown_outcome: Optional[UnknownOutcomePolicy] = None) -> Any
 ```
 
 Execute a tool call through OE.
 
+Durable OAuth records a typed challenge before a separate framework
+wait, then records the actual resource call after reauthorization.
+Its consent answer never becomes a tool result or Memory content.
+
 **Arguments**:
 
 - `tool_name` - Name of the tool
@@ -3111,6 +3203,9 @@ Execute a tool call through OE.
 - `is_local` - Whether OE should return the approved call to this AER.
 - `local_executor` - Callback that invokes the registered tool on the
   current framework stack. Required for local tools.
+- `on_unknown_outcome` - What a retry does when the runner was lost while
+  this tool was in flight in a durable workflow: ``"rerun"`` runs it
+  again, ``"fail"`` refuses the retry.
 
 
 **Returns**:
@@ -3132,20 +3227,22 @@ Execute a tool call through OE.
 
 ```python
 def create_secure_tool_function(
-    original_tool: Any,
-    tool_name: str,
-    *,
-    allow_direct: bool = False,
-    metadata: Optional[Dict[str, Any]] = None,
-    is_local: bool = True,
-    provider_type: Optional[str] = None,
-    scopes: Optional[list[str]] = None,
-    response_format: Literal["content", "content_and_artifact"] = "content",
-    tool_declared_format: Optional[Literal["content",
-                                           "content_and_artifact"]] = None,
-    redact_fields: Optional[list[str]] = None,
-    is_framework_control_flow: Optional[Callable[[BaseException], bool]] = None
-) -> Callable
+        original_tool: Any,
+        tool_name: str,
+        *,
+        allow_direct: bool = False,
+        metadata: Optional[Dict[str, Any]] = None,
+        is_local: bool = True,
+        provider_type: Optional[str] = None,
+        scopes: Optional[list[str]] = None,
+        response_format: Literal["content",
+                                 "content_and_artifact"] = "content",
+        tool_declared_format: Optional[Literal["content",
+                                               "content_and_artifact"]] = None,
+        redact_fields: Optional[list[str]] = None,
+        is_framework_control_flow: Optional[Callable[[BaseException],
+                                                     bool]] = None,
+        on_unknown_outcome: Optional[UnknownOutcomePolicy] = None) -> Callable
 ```
 
 Create a wrapped tool function that routes through SecureToolWrapper.
@@ -3165,6 +3262,9 @@ to be built before execution context exists.
 - `tool_declared_format` - The tool author's own original format, used only
   to decide whether a normal result gets shape-matched into a tuple.
   Defaults to ``response_format``.
+- `on_unknown_outcome` - What a retry does when the runner was lost while
+  this tool was in flight in a durable workflow: ``"rerun"`` runs it
+  again, ``"fail"`` refuses the retry.
 
 
 **Returns**:

{agent_engine_runner_shared-0.11.9 → agent_engine_runner_shared-0.11.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-engine-runner-shared"
-version = "0.11.9"
+version = "0.11.11"
 description = "Runner SDK - Framework-agnostic agent runtime"
 readme = "README.md"
 license = {text = "Apache-2.0"}
@@ -12,20 +12,24 @@ dependencies = [
     # validation, which can disagree with scope["path"]. The
     # Host-validating _HOST_RE landed in starlette 1.4.1.
     "starlette>=1.7.0",
-    "uvicorn>=0.32.0",
+    # The launcher relies on uvicorn's STARTUP_FAILURE (exit 3) contract for
+    # lifespan startup and bind failures, added in 0.50.0.
+    "uvicorn>=0.50.0",
     "pydantic>=2.0.0",
     "protobuf>=6.33.6,<7",
     "httpx>=0.27.0",
+    # MCP 2.x talks httpx2; the two clients install side by side.
+    "httpx2>=2.5.0",
     "httpx-sse>=0.4.0",
-    "mcp==1.27.0",
+    "mcp==2.3.0",
     "python-dotenv>=1.0.0",
     "PyYAML>=6.0",
     "jsonschema>=4.26.0",
     "sentry-sdk>=2.27.0",
     # BaseAgent protocol and AgentInput/AgentEvent models
-    "agent-engine-sdk==0.11.9",
+    "agent-engine-sdk==0.11.11",
     # Memory models and the MemoryClient HTTP client
-    "agent-engine-sdk-memory==0.11.9",
+    "agent-engine-sdk-memory==0.11.11",
     # 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.9 → agent_engine_runner_shared-0.11.11}/src/agent_engine_runner_shared/__init__.py

@@ -96,6 +96,7 @@ from agent_engine_runner_shared.secure_wrapper import (
     TerminalExecutionError,
     ToolCallTimeoutError,
     ToolExecutionError,
+    ToolPlatformError,
     extract_usage,
 )
 from agent_engine_runner_shared.structured_logging import (
@@ -190,6 +191,7 @@ __all__ = [
     "TerminalExecutionError",
     "ToolCallTimeoutError",
     "ToolExecutionError",
+    "ToolPlatformError",
     "ExternalAPICallError",
     # Utilities
     "extract_usage",

agent_engine_runner_shared-0.11.11/src/agent_engine_runner_shared/caller_trace.py

@@ -0,0 +1,138 @@
+"""Distinguish an inbound caller trace from a root this runner created.
+
+AER always starts ``aer.execute``. With no inbound traceparent that span is a
+root, and ``tls_client`` injects it on the call to the OE. The OE forwards
+that header, so the tool process sees a remote parent even though no caller
+trace was bound. W3C traceparent cannot say who created the root, so the
+outgoing tracestate carries ``agentengine=root`` for a runner-created trace.
+Guardrail content is recorded only when that marker is absent.
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Any, Iterator
+
+# Simple W3C tracestate member. A value of "root" means a runner process
+# created this trace; an inbound caller does not set it.
+RUNNER_ROOT_TRACESTATE_KEY = "agentengine"
+RUNNER_ROOT_TRACESTATE_VALUE = "root"
+
+_RUNNER_ROOTED_KEY: Any = None
+
+
+def _runner_rooted_key() -> Any:
+    global _RUNNER_ROOTED_KEY
+    if _RUNNER_ROOTED_KEY is None:
+        from opentelemetry import context
+
+        _RUNNER_ROOTED_KEY = context.create_key("agentengine.runner_rooted_trace")
+    return _RUNNER_ROOTED_KEY
+
+
+def trace_state_marks_runner_root(trace_state: Any) -> bool:
+    """True when tracestate says a runner created this trace's root."""
+    if trace_state is None:
+        return False
+    try:
+        marked = RUNNER_ROOT_TRACESTATE_KEY in trace_state
+    except TypeError:
+        return False
+    if not marked:
+        return False
+    return trace_state[RUNNER_ROOT_TRACESTATE_KEY] == RUNNER_ROOT_TRACESTATE_VALUE
+
+
+def merge_runner_root_trace_state(existing: str | None) -> str:
+    """Return tracestate with the runner-root member first, without duplicates."""
+    kept: list[str] = []
+    prefix = f"{RUNNER_ROOT_TRACESTATE_KEY}="
+    for part in (existing or "").split(","):
+        item = part.strip()
+        if not item or item.startswith(prefix):
+            continue
+        kept.append(item)
+    member = f"{RUNNER_ROOT_TRACESTATE_KEY}={RUNNER_ROOT_TRACESTATE_VALUE}"
+    return ",".join([member, *kept])
+
+
+def parent_context_is_runner_rooted(parent_context: Any) -> bool:
+    """True when ``parent_context`` is not an inbound caller trace.
+
+    An invalid extract means this process is about to create the root. A
+    remote parent without the runner-root marker was already bound by a caller.
+    """
+    from opentelemetry import trace
+
+    span_context = trace.get_current_span(parent_context).get_span_context()
+    if span_context is None or not span_context.is_valid:
+        return True
+    if trace_state_marks_runner_root(getattr(span_context, "trace_state", None)):
+        return True
+    if getattr(span_context, "is_remote", False):
+        return False
+    return True
+
+
+def bind_runner_rooted_trace(ctx: Any, rooted: bool) -> Any:
+    """Return ``ctx`` with the runner-rooted flag set for descendant spans."""
+    from opentelemetry import context
+
+    return context.set_value(_runner_rooted_key(), rooted, ctx)
+
+
+def runner_rooted_trace_active() -> bool:
+    """True when the active span's trace was created by a runner, not a caller.
+
+    The flag set at span entry wins. Without it, a remote parent that carries
+    the marker — or any local root — is treated as runner-created so guardrail
+    content stays off unless a caller trace was already bound.
+    """
+    try:
+        from opentelemetry import context, trace
+    except ImportError:
+        return False
+
+    explicit = context.get_value(_runner_rooted_key())
+    if explicit is True:
+        return True
+    if explicit is False:
+        return False
+
+    span = trace.get_current_span()
+    span_context = span.get_span_context()
+    if trace_state_marks_runner_root(getattr(span_context, "trace_state", None)):
+        return True
+    parent = getattr(span, "parent", None)
+    if parent is not None and getattr(parent, "is_valid", False):
+        if trace_state_marks_runner_root(getattr(parent, "trace_state", None)):
+            return True
+        if getattr(parent, "is_remote", False):
+            return False
+        # Parent was created in this process and nobody bound a caller trace.
+        return True
+    if span_context is not None and span_context.is_valid:
+        if getattr(span_context, "is_remote", False):
+            return trace_state_marks_runner_root(getattr(span_context, "trace_state", None))
+        return True
+    return False
+
+
+@contextmanager
+def runner_trace_scope(parent_context: Any) -> Iterator[None]:
+    """Attach the runner-rooted flag for the span about to be started.
+
+    ``start_as_current_span`` copies the ambient context, so the flag has to
+    be attached before the span or nested ``tls_client`` calls will not see it.
+    """
+    try:
+        from opentelemetry import context as otel_context
+    except ImportError:
+        yield
+        return
+    rooted = parent_context_is_runner_rooted(parent_context)
+    token = otel_context.attach(bind_runner_rooted_trace(otel_context.get_current(), rooted))
+    try:
+        yield
+    finally:
+        otel_context.detach(token)

{agent_engine_runner_shared-0.11.9 → agent_engine_runner_shared-0.11.11}/src/agent_engine_runner_shared/connectors/README.md

@@ -5,20 +5,17 @@ opt-in registration. It is not exposed through the CLI. Connector tools use the
 AER → OE → Tool Pod execution path.
 
 Runtime integration follows the platform's config → discover → register flow: each
-process derives its own view from the same manifest. Resolution order in
+process derives its own view from the same manifest. Resolution in
 `resolve_runtime_bundle`:
 
-1. A pre-materialized bundle published by the platform build, located via the
-   platform-owned `AGENTIC_CONNECTOR_BUNDLE_PATH` environment variable (the
-   deployment contract for hosted builds).
-2. Otherwise, the `connectors` entries in `agent.yaml` are materialized in memory at
+1. The `connectors` entries in `agent.yaml` are materialized in memory at
    startup: each entry names a `tool.yaml` (resolved relative to `agent.yaml`) that
    selects operations from a local catalog file (resolved relative to the
    `tool.yaml`, contained within the agent workspace) and binds the endpoint and
    credential environment reference. Catalogs are local files only — HTTPS catalog
    references fail; there is no network fetch.
-3. With neither configured, loading is an immediate no-op without filesystem or
-   network access.
+2. With no connectors configured, loading is an immediate no-op without filesystem
+   or network access.
 
 ```yaml
 version: 1
@@ -61,9 +58,8 @@ Existing static auth modes continue to use their configured environment bindings
 Catalog regeneration preserves the authored OAuth binding and records only
 secret-free Bearer presentation in the catalog.
 
-The pre-materialized index paths are relative to the index and must remain inside its
-directory. AER loads the schemas as ordinary remote tools. Tool Pod startup loads the
-same materialized view and owns one `ConnectorExecutor` per connector.
+AER loads the materialized schemas as ordinary remote tools. Tool Pod startup
+materializes the same view and owns one `ConnectorExecutor` per connector.
 
 `load_tool_defs(path)` reads a local compiled YAML artifact into `ToolDefinitions`.
 `tool_schemas()` returns detached name, description and `inputSchema` dictionaries.
@@ -107,14 +103,17 @@ Only GET, HEAD and OPTIONS retry 429/503, at most three times; `Retry-After` is
 at 30 seconds. Each invocation carries a 30-second budget between requests, redirects,
 response chunks and retry waits. Every request
 uses its remaining budget for HTTPX's standard connect, read, write and pool timeouts;
-the read timeout bounds each blocking read, as defined by HTTPX.
+the read timeout bounds each blocking read, as defined by HTTPX. Requests carry
+`User-Agent: agent-engine-connector` unless the connector sets its own in
+`auth.headers`, matched case-insensitively.
 
 HTTP failures, including rejected provider redirects, use `httpx.HTTPStatusError`,
 and transport failures use the existing
 timeout/connection exception types recognized by `classify_tool_api_error`. An HTTP
 error may retain a bounded provider error body (at most 4 KB) so the shared classifier
-can surface the provider's own explanation. The retained body is never logged; the
-classifier applies rudimentary hygiene to the extracted explanation — control
-characters dropped, URL-shaped text rejected, exact credential values redacted, result
-bounded. This is best-effort, not a guarantee. Oversized bodies, redirect locations,
+can surface the provider's own explanation: a recognized JSON error field, or a
+plain-text body that is not HTML markup, up to its first link. The retained body is
+never logged; the classifier applies rudimentary hygiene to the extracted explanation
+— control characters dropped, URL-shaped text rejected, exact credential values
+redacted, result bounded. This is best-effort, not a guarantee. Oversized bodies, redirect locations,
 and credential-bearing request objects are never retained.

{agent_engine_runner_shared-0.11.9 → agent_engine_runner_shared-0.11.11}/src/agent_engine_runner_shared/connectors/__init__.py

@@ -1,12 +1,10 @@
-"""Compiled OpenAPI connector core, bundle loading, and authoring materialization."""
+"""Compiled OpenAPI connector core and authoring materialization."""
 
 from agent_engine_runner_shared.connectors.bundle import (
-    CONNECTOR_BUNDLE_PATH_ENV,
     BundledConnector,
     BundledTool,
     ConnectorBundle,
     ConnectorBundleError,
-    load_connector_bundle,
 )
 from agent_engine_runner_shared.connectors.definitions import (
     Auth,
@@ -33,7 +31,6 @@ from agent_engine_runner_shared.connectors.runtime import (
 )
 
 __all__ = [
-    "CONNECTOR_BUNDLE_PATH_ENV",
     "BundledConnector",
     "BundledTool",
     "CompileResult",
@@ -48,7 +45,6 @@ __all__ = [
     "Auth",
     "ToolDefinitions",
     "compile_catalog",
-    "load_connector_bundle",
     "load_tool_defs",
     "materialize_connectors",
     "regenerate_catalog",