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

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

@@ -8,6 +8,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Changed
+- **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
+  `provider: <OAuth app>` with optional `scopes`, plus optional `headers`; omit
+  the block for no credential. A block that still uses `type` or its fields
+  fails validation and names the key to use instead. `compile_catalog` and
+  `scaffold_tool_yaml` propose the block from the document's security schemes
+  and derive secret names from the connector name; `auth` now takes `none`,
+  `bearer`, `basic` or `api_keys`, and an OAuth document needs `provider`.
+  Generated catalogs record the credential kind without `type`.
+  `Auth.header_name()` and `Auth.credential_bindings()` are removed; read
+  `Auth.api_keys`. Regenerating a connector with no `auth` block compiles every
+  operation anonymously instead of from the OpenAPI document's security, so
+  operations the first compile skipped can appear as tools; they send no
+  credential.
+
+### 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

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

{agent_engine_runner_shared-0.11.10 → agent_engine_runner_shared-0.11.12}/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.10 → agent_engine_runner_shared-0.11.12}/PKG-INFO

@@ -1,18 +1,19 @@
 Metadata-Version: 2.5
 Name: agent-engine-runner-shared
-Version: 0.11.10
+Version: 0.11.12
 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.10
-Requires-Dist: agent-engine-sdk==0.11.10
+Requires-Dist: agent-engine-sdk-memory==0.11.12
+Requires-Dist: agent-engine-sdk==0.11.12
 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

{agent_engine_runner_shared-0.11.10 → agent_engine_runner_shared-0.11.12}/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)
@@ -181,6 +183,7 @@
   * [PolicyDeniedException](#agent_engine_runner_shared.secure_wrapper.PolicyDeniedException)
   * [OERetryAfterError](#agent_engine_runner_shared.secure_wrapper.OERetryAfterError)
   * [ToolExecutionError](#agent_engine_runner_shared.secure_wrapper.ToolExecutionError)
+  * [ToolOutcomeUnknownError](#agent_engine_runner_shared.secure_wrapper.ToolOutcomeUnknownError)
   * [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)
@@ -347,7 +350,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.
@@ -359,6 +364,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**:
@@ -370,6 +378,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
@@ -2398,9 +2437,9 @@ return parse(html)
 Runtime-transparent custom-event emission across Atlas Agent Engine runtimes.
 
 Authors call :func:`emit_custom_event` without knowing which runtime is
-hosting the code (AER agent process vs Tool Pod / function mode). The active
-runtime installs exactly one :class:`CustomEventTransport` before invoking
-tenant code; the helper dispatches to that transport.
+hosting the code (AER agent process vs Tool Pod). The active runtime installs
+exactly one :class:`CustomEventTransport` before invoking tenant code; the
+helper dispatches to that transport.
 
 Atlas Agent Engine transports an opaque author-final JSON object as ``custom_event``.
 It does not interpret keys — customers who need a shaped vocabulary (e.g.
@@ -2532,7 +2571,7 @@ no transport is installed (outside an execution context).
 class OEHTTPCustomEventTransport()
 ```
 
-Tool Pod / function-mode transport: POST final ``custom_event`` chunks to OE.
+Tool Pod transport: POST final ``custom_event`` chunks to OE.
 
 Delivery is awaited with a bounded timeout and is non-fatal: delivery
 failures are logged and swallowed so a progress event cannot fail the tool.
@@ -2548,10 +2587,10 @@ class FeatureOffCustomEventTransport()
 Fail closed when ``use_custom_parser`` is disabled.
 
 Runtime-neutral rejecting transport shared by AER streaming (when Atlas Agent Engine
-does not subscribe to LangGraph ``custom``) and Tool Pod / function mode
-(when OE POSTs would otherwise succeed while Gateway strips client
-delivery). Authors must not observe a successful emit when the workspace
-cannot deliver custom events to clients.
+does not subscribe to LangGraph ``custom``) and the Tool Pod (when OE POSTs
+would otherwise succeed while Gateway strips client delivery). Authors
+must not observe a successful emit when the workspace cannot deliver custom
+events to clients.
 
 <a id="agent_engine_runner_shared.custom_events.install_tool_custom_event_transport"></a>
 
@@ -2562,7 +2601,7 @@ def install_tool_custom_event_transport(
         *, enabled: bool = True) -> Token[Optional[CustomEventTransport]]
 ```
 
-Install Tool Pod / function-mode custom-event transport; return reset token.
+Install the Tool Pod custom-event transport; return reset token.
 
 When ``enabled`` is false (workspace does not have ``use_custom_parser``),
 install a rejecting transport so emit fails closed instead of POSTing an
@@ -2817,6 +2856,19 @@ class ToolExecutionError(Exception)
 
 Raised when tool execution fails.
 
+<a id="agent_engine_runner_shared.secure_wrapper.ToolOutcomeUnknownError"></a>
+
+## ToolOutcomeUnknownError
+
+```python
+class ToolOutcomeUnknownError(ToolExecutionError)
+```
+
+The runner was lost while this durable tool call was in flight.
+
+It may have taken effect and OE did not run it again. ``error`` is OE's
+message, written for the model reading it.
+
 <a id="agent_engine_runner_shared.secure_wrapper.ToolPlatformError"></a>
 
 ## ToolPlatformError
@@ -2939,7 +2991,7 @@ def request_oe_approval(
         is_local: bool = True,
         metadata: Optional[Dict[str, Any]] = None,
         redact_fields: Optional[list[str]] = None,
-        provider_type: Optional[str] = None,
+        provider: Optional[str] = None,
         scopes: Optional[list[str]] = None,
         tool_call_id: Optional[str] = None,
         custom_headers: Optional[Dict[str, str]] = None,
@@ -3125,22 +3177,22 @@ 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,
-        on_unknown_outcome: Optional[UnknownOutcomePolicy] = None) -> Any
+def execute_tool(tool_name: str,
+                 arguments: Dict[str, Any],
+                 *,
+                 metadata: Optional[Dict[str, Any]] = None,
+                 provider: 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,
+                 owning_tool_call: Optional[OwningToolCall] = None) -> Any
 ```
 
 Execute a tool call through OE.
@@ -3168,6 +3220,10 @@ Its consent answer never becomes a tool result or Memory content.
 - `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.
+- `owning_tool_call` - The tool call or subagent this operation is performed
+  for, when it is not itself a tool the model requested. In a durable
+  workflow it runs alongside other activities, at a position derived
+  from that call.
 
 
 **Returns**:
@@ -3195,7 +3251,7 @@ def create_secure_tool_function(
         allow_direct: bool = False,
         metadata: Optional[Dict[str, Any]] = None,
         is_local: bool = True,
-        provider_type: Optional[str] = None,
+        provider: Optional[str] = None,
         scopes: Optional[list[str]] = None,
         response_format: Literal["content",
                                  "content_and_artifact"] = "content",
@@ -3891,7 +3947,7 @@ stdout output so the Local Dev UI can read the agent's logs.
 **Arguments**:
 
 - `app_name` - Application name for log file naming
-- `mode` - Runtime mode (aer, tool, tool_function)
+- `mode` - Runtime mode (aer, tool)
 - `log_dir` - Directory for log files (default: ./logs)
 - `log_level` - Log level (default: from LOG_LEVEL env or INFO)
 - `backup_count` - Number of rotated backup files to keep

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

@@ -1,6 +1,6 @@
 [project]
 name = "agent-engine-runner-shared"
-version = "0.11.10"
+version = "0.11.12"
 description = "Runner SDK - Framework-agnostic agent runtime"
 readme = "README.md"
 license = {text = "Apache-2.0"}
@@ -18,16 +18,18 @@ dependencies = [
     "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.10",
+    "agent-engine-sdk==0.11.12",
     # Memory models and the MemoryClient HTTP client
-    "agent-engine-sdk-memory==0.11.10",
+    "agent-engine-sdk-memory==0.11.12",
     # 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.10 → agent_engine_runner_shared-0.11.12}/src/agent_engine_runner_shared/__init__.py

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

agent_engine_runner_shared-0.11.12/src/agent_engine_runner_shared/__main__.py

@@ -0,0 +1,12 @@
+"""Generic platform entrypoint for the runner-shared image.
+
+Dispatches via RUNNER_MODE (aer | tool) through
+TenantRuntime.register_and_run(). Tool mode does not need a graph builder; aer
+mode does, so user agents provide their own __main__.py for that case
+(App.run() enforces the builder check there).
+"""
+
+from agent_engine_runner_shared.runtime import TenantRuntime
+
+if __name__ == "__main__":
+    TenantRuntime().register_and_run()

{agent_engine_runner_shared-0.11.10 → agent_engine_runner_shared-0.11.12}/src/agent_engine_runner_shared/agent_config.py

@@ -340,7 +340,20 @@ class RuntimeMCPServerConfig(BaseModel):
         default="streamable_http",
         description="MCP transport used to connect to the server.",
     )
-    url: NonEmptyString = Field(description="Streamable HTTP endpoint for the MCP server.")
+    url: NonEmptyString | None = Field(
+        default=None,
+        description=(
+            "Streamable HTTP endpoint for the MCP server. An entry with no url names "
+            "a project OAuth app with its key, and the app's resource is the endpoint."
+        ),
+    )
+    scopes: list[NonEmptyString] = Field(
+        default_factory=list,
+        description=(
+            "Scopes requested from the OAuth app the entry names, instead of the "
+            "app's defaults. Refused beside a url."
+        ),
+    )
     headers: dict[str, str] = Field(
         default_factory=dict,
         description="Static non-secret HTTP headers sent to the MCP server.",
@@ -361,11 +374,25 @@ class RuntimeMCPServerConfig(BaseModel):
 
     @model_validator(mode="after")
     def validate_server_config(self) -> "RuntimeMCPServerConfig":
-        parsed = urlparse(self.url)
-        if parsed.scheme not in {"http", "https"} or parsed.hostname is None:
-            raise ValueError("mcp server url must be an absolute http(s) URL")
-        if parsed.scheme == "http" and self.auth.type != "none":
-            raise ValueError("mcp server url must be https when auth.type is set")
+        if self.url is None:
+            # The app supplies the credential, so an auth block here could only
+            # disagree with it. auth has a default, so ask whether it was written.
+            if "auth" in self.model_fields_set:
+                raise ValueError(
+                    "mcp server auth is not allowed without url; "
+                    "an entry with no url names an OAuth app"
+                )
+        else:
+            if "scopes" in self.model_fields_set:
+                raise ValueError(
+                    "mcp server scopes is not allowed with url; "
+                    "scopes apply to an entry that names an OAuth app"
+                )
+            parsed = urlparse(self.url)
+            if parsed.scheme not in {"http", "https"} or parsed.hostname is None:
+                raise ValueError("mcp server url must be an absolute http(s) URL")
+            if parsed.scheme == "http" and self.auth.type != "none":
+                raise ValueError("mcp server url must be https when auth.type is set")
 
         forbidden_headers = sorted(
             header for header in self.headers if header.lower() in _FORBIDDEN_MCP_HEADER_KEYS
@@ -452,8 +479,8 @@ class RuntimeAgentConfig(BaseModel):
     a2a: A2AConfig = Field(default_factory=A2AConfig)
     mcp: RuntimeMCPConfig = Field(default_factory=RuntimeMCPConfig)
     required_secrets: SecretsConfig = Field(default_factory=SecretsConfig)
-    # Python/LangGraph only: connector authoring files materialized at startup.
-    # The shared Go parser rejects the key for TypeScript agents.
+    # LangGraph only: connector authoring files materialized at startup.
+    # The shared Go parser rejects the key for other frameworks.
     connectors: list[RuntimeConnectorReference] = Field(default_factory=list)
 
     def feature_enabled(

{agent_engine_runner_shared-0.11.10 → agent_engine_runner_shared-0.11.12}/src/agent_engine_runner_shared/connectors/README.md

@@ -1,24 +1,23 @@
 # Compiled connector core
 
-This Python-only package implements definition loading, synchronous HTTP execution and
-opt-in registration. It is not exposed through the CLI. Connector tools use the existing
-AER → OE → Tool Pod execution path.
+The Python and TypeScript Runner SDKs share this connector contract. The Python
+implementation covers definition loading, synchronous HTTP execution, and opt-in
+registration; the TypeScript implementation mirrors the same materialization,
+registration, and execution contract. It is not exposed through the CLI. Connector
+tools use the existing 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
@@ -38,32 +37,33 @@ source:
 expose:
   allow: [jiradc_getComments]
 auth:
-  type: bearer
-  env: JIRA_TOKEN
+  bearer: JIRA_TOKEN
 ```
 
-For delegated OAuth, replace that auth block with an explicit provider binding:
+The block names exactly one of `bearer`, `basic`, `api_keys` or `provider`, by
+workspace secret name or OAuth app; no block means no credential. For OAuth,
+bind the project's OAuth app instead:
 
 ```yaml
 auth:
-  type: oauth
-  provider_type: github
+  provider: github
   scopes: [repo]
 ```
 
-`provider_type` is the key of a provider configured for the project, independent
+`provider` names an OAuth app configured for the project, independent
 of the resource API's base URL. The scopes apply to every exposed operation in
 this connector. Registration carries this policy outside the model's argument
-schema. The Orchestration Engine resolves a credential for the saved application
-user and passes it to the Tool Pod for that invocation. A missing or invalid token
+schema. The Orchestration Engine resolves a credential and passes it to the Tool
+Pod for that invocation. The app's grant decides whose: an authorization code app
+gives the saved application user's token, and a client credentials app gives the
+project's shared token with no user and no consent. A missing or invalid token
 stops the HTTP call; OAuth never falls back to a tenant environment secret.
 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.

{agent_engine_runner_shared-0.11.10 → agent_engine_runner_shared-0.11.12}/src/agent_engine_runner_shared/connectors/__init__.py

@@ -1,15 +1,14 @@
-"""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,
+    BasicAuth,
     Credential,
     ToolDefinitions,
     load_tool_defs,
@@ -33,7 +32,6 @@ from agent_engine_runner_shared.connectors.runtime import (
 )
 
 __all__ = [
-    "CONNECTOR_BUNDLE_PATH_ENV",
     "BundledConnector",
     "BundledTool",
     "CompileResult",
@@ -46,9 +44,9 @@ __all__ = [
     "GenerateError",
     "MaterializeError",
     "Auth",
+    "BasicAuth",
     "ToolDefinitions",
     "compile_catalog",
-    "load_connector_bundle",
     "load_tool_defs",
     "materialize_connectors",
     "regenerate_catalog",

agent_engine_runner_shared-0.11.12/src/agent_engine_runner_shared/connectors/bundle.py

@@ -0,0 +1,93 @@
+"""Validated runtime views shared by AER and Tool Pod connector registration.
+
+The authoring materializer builds these objects from ``agent.yaml``,
+``tool.yaml``, and the local compiled catalog. AER consumes each tool's schema
+and registration metadata; Tool Pod consumes the same views to bind executor
+callables. Nothing here reads files or performs I/O.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import urlsplit
+
+from agent_engine_runner_shared.connectors.definitions import (
+    Operation,
+    ToolDefinitions,
+)
+from agent_engine_runner_shared.connectors.executor import DEFAULT_EXECUTION_TIMEOUT_SECONDS
+
+__all__ = [
+    "BundledConnector",
+    "BundledTool",
+    "ConnectorBundle",
+    "ConnectorBundleError",
+]
+
+
+class ConnectorBundleError(ValueError):
+    """Raised when a connector bundle cannot be registered safely."""
+
+
+@dataclass(frozen=True)
+class BundledConnector:
+    """One validated compiled connector from the materialized runtime view."""
+
+    name: str
+    definitions: ToolDefinitions
+
+
+@dataclass(frozen=True)
+class BundledTool:
+    """One operation and the connector definitions needed to execute it."""
+
+    connector: BundledConnector
+    operation: Operation
+
+    @property
+    def schema(self) -> dict[str, Any]:
+        """Return a detached SDK-visible schema."""
+        return self.operation.model_dump(include={"name", "description", "inputSchema"})
+
+    @property
+    def network(self) -> list[str]:
+        """Return the single outbound host declared by this connector."""
+        hostname = urlsplit(self.connector.definitions.source.base_url).hostname
+        assert hostname is not None  # ToolDefinitions validated the URL.
+        return [hostname]
+
+    @property
+    def registration_metadata(self) -> dict[str, Any]:
+        """Return detached AER/Tool Pod policy, with delegated binding outside the schema."""
+        operation = self.operation
+        auth = self.connector.definitions.auth
+        provider = auth.provider if auth is not None else None
+        return {
+            "name": operation.name,
+            "description": operation.description.strip() or f"REST connector tool {operation.name}",
+            "is_local": False,
+            "provider": provider,
+            "scopes": list(auth.scopes or []) if auth is not None and provider else [],
+            "network": self.network,
+            "timeout_seconds": DEFAULT_EXECUTION_TIMEOUT_SECONDS,
+            "redact_fields": [],
+            "connector": self.connector.name,
+        }
+
+
+@dataclass(frozen=True)
+class ConnectorBundle:
+    """Fully validated runtime bundle shared by AER and Tool Pod startup."""
+
+    connectors: tuple[BundledConnector, ...] = ()
+    tools: tuple[BundledTool, ...] = ()
+
+    def require_available_names(self, registered_names: set[str]) -> None:
+        """Reject all name collisions before a caller mutates its registry."""
+        collisions = sorted({tool.operation.name for tool in self.tools} & registered_names)
+        if collisions:
+            raise ConnectorBundleError(
+                "connector tool names collide with registered or reserved tools: "
+                + ", ".join(collisions)
+            )