loom-kernel 1.7.1__tar.gz → 1.8.0__tar.gz

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/CHANGELOG.md

@@ -1,3 +1,45 @@
+# 🚀 Release 1.8.0 ([#147](https://github.com/the-reacher-data/loom-py/pull/147)) ([`1d9667e`](https://github.com/the-reacher-data/loom-py/commit/1d9667e3))
+
+
+## ✨ Features
+### ai
+- **ai:** authenticate to remote A2A agents, and share one strategy registry ([#147](https://github.com/the-reacher-data/loom-py/pull/147))<br>
+  > `A2AAgentConfig.headers_ref` was declared, validated by the compiler and
+  > carried into the plan — then dropped, so an agent configured with
+  > credentials connected **unauthenticated, silently**. MCP at least refused.
+  >
+  > **BREAKING**: the entry-point group `loom.ai.mcp_auth` is renamed
+  > `loom.ai.remote_auth`, and `mcp_auth.py` becomes `remote_auth.py`. Anything
+  > registered under the old name stops being found. No deprecation cycle was
+  > run because the group shipped one release earlier with no consumers.
+  >
+  > One registry now serves both outbound transports: nothing about `bearer`,
+  > `oauth` or `static` is MCP-specific, since the contract is `httpx.Auth`.
+  > Sharing keys are scoped by transport, so an MCP server and an A2A agent of
+  > the same name remain two credentials. The credential is set on the client,
+  > so the card fetch — the *first* request of a session — carries it too.
+
+
+## 🐛 Fixes
+### ai
+- **ai:** give a plugin the setting types its signature declares ([#150](https://github.com/the-reacher-data/loom-py/pull/150))<br>
+  > Auth settings arrive as strings, because each passes the inline-credential
+  > refusal, which admits no spaces. A strategy declaring `timeout: int` got
+  > `"30"`, and one declaring `verify: bool` got `"false"` — which is truthy, so
+  > a deployment asking to turn verification off got it turned on.
+  >
+  > A setting whose parameter declares `str`, `int`, `float` or `bool` is now
+  > converted to it; a custom type or an unannotated parameter is passed exactly
+  > as before, so no existing strategy changes behaviour.
+
+
+## 🧹 Chores
+- **chore:** retire two expired Sonar suppressions and fix two lying test stubs ([#146](https://github.com/the-reacher-data/loom-py/pull/146))<br>
+  > Both suppressions carried a written expiry condition that the 1.7.0 split
+  > met; one pointed at a file that no longer exists. Two test stubs had
+  > silently stopped satisfying the protocols they stand in for.
+
+
 # 🚀 Release 1.7.1 ([#143](https://github.com/the-reacher-data/loom-py/pull/143)) ([`0322dbb`](https://github.com/the-reacher-data/loom-py/commit/0322dbb2))
 
 

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: loom-kernel
-Version: 1.7.1
+Version: 1.8.0
 Summary: Loom Python project
 License-File: LICENSE
 Classifier: Typing :: Typed

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/docs/ai/a2a.md

@@ -36,7 +36,7 @@ ai:
   a2a_agents:
     oncall:
       url: https://oncall.partner.example.com/a2a/rota
-      headers_ref: ONCALL_A2A_HEADERS
+      headers_ref: ${secrets:/loom/oncall/api-key}   # stores e.g. X-API-Key=abc123
 ```
 
 At start-up the remote card is fetched and validated. An unreachable agent fails
@@ -57,6 +57,55 @@ The remote URL must be `https://`, with no credentials in its userinfo and no
 query string. Compilation refuses anything else, and the offending URL is
 redacted in the error message.
 
+### Authenticating to the remote agent
+
+A remote agent declares its credential exactly as an MCP server does, and loom
+resolves it through the same registry — see
+[mcp.md § Authentication](mcp.md#authentication) for the full reference:
+
+```yaml
+ai:
+  a2a_agents:
+    oncall:
+      url: https://oncall.partner.example.com/a2a/rota
+      headers_ref: ${secrets:/loom/oncall/api-key}   # one Name=value pair
+    market:
+      url: https://market.partner.example.com/a2a
+      auth:
+        kind: bearer                                 # Authorization: Bearer <token>
+        token_ref: ${secrets:/loom/market/token}
+    orders:
+      url: https://orders.internal.example.com/a2a
+      auth:
+        kind: agent-session                          # a strategy you register
+        session_url: https://orders.internal.example.com/auth/agent/session
+        bootstrap_ref: ${secrets:/agents/prod/agent-sales}
+```
+
+The credential is set on the HTTP client, not on one request, so **every** call
+carries it — including the card fetch, which is the *first* request of the
+session. An agent that authenticates its card endpoint would otherwise fail
+start-up before a skill was ever called.
+
+`kind` names an entry point in the group `loom.ai.remote_auth`, the same group
+MCP servers resolve against: the strategy contract is
+[`httpx.Auth`](https://www.python-httpx.org/advanced/authentication/), which
+knows nothing of either protocol, so a deployment registers its strategy once
+and grants it to either transport. The one strategy an A2A agent cannot use is
+`kind: oauth`, which delegates to the MCP client library's own flow; naming it
+here is refused with `MCP_AUTH_STRATEGY_INVALID` rather than connecting without
+the credential the deployment asked for.
+
+What compilation guarantees is what it guarantees for an MCP server:
+`headers_ref` and `auth` are **mutually exclusive** (`MCP_AUTH_CONFLICT`); a
+`kind` nobody registers fails at compile time naming what is installed
+(`MCP_AUTH_STRATEGY_UNKNOWN`); and no literal secret is accepted anywhere in the
+block (`MCP_CREDENTIALS_INLINE`, and the rejection never repeats the value).
+
+The authentication object is built **once per configured agent and shared by
+every agent granted it**: the credential belongs to the deployment, so a
+renewing strategy renews once rather than once per caller.
+
 ## Inbound — publishing your agent
 
 ```yaml

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/docs/ai/mcp.md

@@ -167,7 +167,7 @@ ai:
         bootstrap_ref: ${secrets:/agents/prod/agent-sales}
 ```
 
-`kind` names an entry point in the group `loom.ai.mcp_auth`; every other key in
+`kind` names an entry point in the group `loom.ai.remote_auth`; every other key in
 the block is passed to it as a **keyword argument**. Loom registers three, all
 thin delegations to what the libraries already provide:
 
@@ -196,7 +196,7 @@ from **your own package**; loom does not change:
 
 ```toml
 # pyproject.toml of your own distribution
-[project.entry-points."loom.ai.mcp_auth"]
+[project.entry-points."loom.ai.remote_auth"]
 agent-session = "my_package.auth:AgentSessionAuth"
 ```
 
@@ -254,6 +254,14 @@ server's read permissions to that prefix and log failed attempts per path.
 - A strategy that cannot be built from its settings fails at start-up with
   `MCP_AUTH_STRATEGY_INVALID`.
 
+The group is `loom.ai.remote_auth`, not `loom.ai.mcp_auth`: one registry serves
+the MCP servers of `ai.mcp_servers` **and** the remote agents of `ai.a2a_agents`
+(see [a2a.md](a2a.md)), because the contract is `httpx.Auth` and knows neither
+protocol. A strategy is registered once and granted to either. The one
+exception is `kind: oauth`, which delegates to the MCP client library's own
+flow: an A2A agent naming it is refused with `MCP_AUTH_STRATEGY_INVALID` rather
+than connected without a credential.
+
 ### One instance per server
 
 The authentication object is built **once per server and shared by every agent

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "loom-kernel"
-version = "1.7.1"
+version = "1.8.0"
 description = "Loom Python project"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -138,13 +138,15 @@ celery = [
 [project.entry-points."loom.ai.engines"]
 pydantic-ai = "loom.ai.engines.pydantic_ai.provider:PydanticAIEngineProvider"
 
-# Authentication strategies for outbound MCP connections. A deployment plugs
-# in its own from its own package under the same group; loom ships only these
-# three thin delegations. See docs/ai/mcp.md.
-[project.entry-points."loom.ai.mcp_auth"]
-oauth = "loom.ai.mcp_auth:standard_oauth"
-bearer = "loom.ai.mcp_auth:bearer_token"
-static = "loom.ai.mcp_auth:static_headers"
+# Authentication strategies for the remote endpoints loom calls out to: MCP
+# servers and A2A agents alike, since the contract is httpx.Auth and knows
+# nothing of either protocol. A deployment plugs in its own from its own
+# package under the same group; loom ships only these three thin delegations.
+# See docs/ai/mcp.md and docs/ai/a2a.md.
+[project.entry-points."loom.ai.remote_auth"]
+oauth = "loom.ai.remote_auth:standard_oauth"
+bearer = "loom.ai.remote_auth:bearer_token"
+static = "loom.ai.remote_auth:static_headers"
 
 [project.entry-points."loom.etl.backends"]
 polars = "loom.etl.backends.polars.provider:PolarsProvider"
@@ -267,6 +269,11 @@ extend-immutable-calls = [
 
 [tool.pyright]
 pythonVersion = "3.11"
+# src only, deliberately. Checking tests as well surfaces 294 errors across
+# eight rules — mostly stubs that no longer satisfy the protocol they stand in
+# for. That is real signal and worth burning down, but it is a project, not a
+# flag flip: turning it on without the cleanup would make the gate meaningless
+# on its first run. Tracked in specs/feature/quality/typecheck_tests.md.
 include = [
     "src",
 ]
@@ -350,7 +357,7 @@ markers = [
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "1.7.1"
+version = "1.8.0"
 tag_format = "v$version"
 version_files = [
     "pyproject.toml:project.version",

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/sonar-project.properties

@@ -25,7 +25,7 @@ sonar.coverage.exclusions=tests/**,tests/**/*,**/.github/**,docs/**,docs/**/*
 #                   String(), DateTime(), Numeric()
 #
 # Renaming any of them would be a breaking public API change.
-sonar.issue.ignore.multicriteria=e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e46,e47,e48,e49,e50,e51
+sonar.issue.ignore.multicriteria=e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15,e16,e17,e18,e19,e20,e21,e22,e23,e24,e25,e26,e27,e28,e29,e30,e31,e32,e33,e34,e35,e36,e37,e38,e39,e40,e41,e42,e43,e44,e45,e48,e49,e50,e51
 
 # Use-case DSL markers: Input, Load, LoadById, Exists — S100 (method) + S1542 (function)
 sonar.issue.ignore.multicriteria.e1.ruleKey=python:S100
@@ -209,15 +209,6 @@ sonar.issue.ignore.multicriteria.e45.resourceKey=**/etl/declarative/target/_hist
 # reasoning as IntoHistory above: an options object would hide the very names a
 # reader needs, and for a wiring function the parameter list IS the contract —
 # it is what tells you, at a glance, everything the runtime is handed.
-#
-# TEMPORARY for two of them: runtime.py and a2a/server.py are scheduled to be
-# split by responsibility (runtime/{_lifecycle,_mcp,_limits,_health}.py and the
-# a2a binding already extracted). Both signatures shrink with that split, so
-# e46 and e47 should be removed then rather than inherited.
-sonar.issue.ignore.multicriteria.e46.ruleKey=python:S107
-sonar.issue.ignore.multicriteria.e46.resourceKey=**/ai/runtime.py
-sonar.issue.ignore.multicriteria.e47.ruleKey=python:S107
-sonar.issue.ignore.multicriteria.e47.resourceKey=**/ai/a2a/server.py
 sonar.issue.ignore.multicriteria.e48.ruleKey=python:S107
 sonar.issue.ignore.multicriteria.e48.resourceKey=**/ai/fastapi/endpoints.py
 sonar.issue.ignore.multicriteria.e49.ruleKey=python:S107

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/src/loom/ai/compiler/__init__.py

@@ -20,10 +20,10 @@ from loom.ai.compiler._plan import (
     AgentPlan,
     CompiledA2ACapability,
     CompiledCapability,
-    CompiledMcpAuth,
     CompiledMcpCapability,
     CompiledOutput,
     CompiledPythonCapability,
+    CompiledRemoteAuth,
     CompiledSkillsCapability,
     CompiledSqlCapability,
     CompiledUsecaseCapability,
@@ -38,10 +38,10 @@ __all__ = [
     "AgentPlan",
     "CompiledA2ACapability",
     "CompiledCapability",
-    "CompiledMcpAuth",
     "CompiledMcpCapability",
     "CompiledOutput",
     "CompiledPythonCapability",
+    "CompiledRemoteAuth",
     "CompiledSkillsCapability",
     "CompiledSqlCapability",
     "CompiledUsecaseCapability",

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/src/loom/ai/compiler/_plan.py

@@ -81,8 +81,12 @@ class CompiledSqlCapability(LoomFrozenStruct, frozen=True, kw_only=True):
     max_result_bytes: int
 
 
-class CompiledMcpAuth(LoomFrozenStruct, frozen=True, kw_only=True):
-    """Authentication strategy of one MCP server, resolved to a name and settings.
+class CompiledRemoteAuth(LoomFrozenStruct, frozen=True, kw_only=True):
+    """Authentication strategy of one remote endpoint, resolved to name and settings.
+
+    One struct serves both outbound transports, MCP servers and A2A agents, as
+    the one registry that builds it does: the strategy contract is
+    ``httpx.Auth``, which knows nothing of either protocol.
 
     ``kind`` is separated from the rest of the ``auth`` block once, here, so the
     engine never re-reads configuration to find out which strategy to build.
@@ -90,7 +94,7 @@ class CompiledMcpAuth(LoomFrozenStruct, frozen=True, kw_only=True):
     plan is a frozen, hashable value.
 
     Attributes:
-        kind: Strategy name registered in the ``loom.ai.mcp_auth`` group.
+        kind: Strategy name registered in the ``loom.ai.remote_auth`` group.
         settings: The rest of the ``auth`` block, passed to the strategy as
             keyword arguments in declaration order.
     """
@@ -125,7 +129,7 @@ class CompiledMcpCapability(LoomFrozenStruct, frozen=True, kw_only=True):
     server: str
     url: str
     headers_ref: str | None = None
-    auth: CompiledMcpAuth | None = None
+    auth: CompiledRemoteAuth | None = None
     timeout_ms: int = 20000
     include: tuple[str, ...] = ()
     exclude: tuple[str, ...] = ()
@@ -176,6 +180,9 @@ class CompiledA2ACapability(LoomFrozenStruct, frozen=True, kw_only=True):
         agent: Configured agent name, carried for the self-description.
         url: Validated ``https://`` remote agent URL, free of credentials.
         headers_ref: Reference to deployment-resolved headers; never a secret.
+            Applied to every request the client makes, the card fetch included.
+        auth: Named authentication strategy, mutually exclusive with
+            ``headers_ref``; ``None`` when the agent needs no credential.
         include: Skill names or glob patterns to expose; empty means all.
         exclude: Skill names or glob patterns to omit, applied after ``include``.
     """
@@ -185,6 +192,7 @@ class CompiledA2ACapability(LoomFrozenStruct, frozen=True, kw_only=True):
     agent: str
     url: str
     headers_ref: str | None = None
+    auth: CompiledRemoteAuth | None = None
     include: tuple[str, ...] = ()
     exclude: tuple[str, ...] = ()
 

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/src/loom/ai/compiler/phases/_capabilities.py

@@ -23,9 +23,9 @@ from loom.ai._filters import select_names
 from loom.ai.compiler._plan import (
     CompiledA2ACapability,
     CompiledCapability,
-    CompiledMcpAuth,
     CompiledMcpCapability,
     CompiledPythonCapability,
+    CompiledRemoteAuth,
     CompiledSkillsCapability,
     CompiledSqlCapability,
     CompiledUsecaseCapability,
@@ -221,7 +221,7 @@ def _compile_mcp(capability: McpCapability, context: _Context) -> _HandlerResult
             server=capability.server,
             url=server.url,
             headers_ref=server.headers_ref,
-            auth=_compile_mcp_auth(server.auth),
+            auth=_compile_auth(server.auth),
             timeout_ms=server.timeout_ms,
             include=capability.include,
             exclude=capability.exclude,
@@ -230,16 +230,17 @@ def _compile_mcp(capability: McpCapability, context: _Context) -> _HandlerResult
     )
 
 
-def _compile_mcp_auth(auth: Mapping[str, str] | None) -> CompiledMcpAuth | None:
+def _compile_auth(auth: Mapping[str, str] | None) -> CompiledRemoteAuth | None:
     """Split a validated ``auth`` block into the strategy name and its settings.
 
-    Configuration already refused a block whose ``kind`` names no registered
-    strategy, so the split is the only work left: ``kind`` selects the entry
-    point and everything else becomes its keyword arguments.
+    Shared by the ``mcp`` and ``a2a`` grants: both endpoints declare the same
+    block.  Configuration already refused a block whose ``kind`` names no
+    registered strategy, so the split is the only work left: ``kind`` selects
+    the entry point and everything else becomes its keyword arguments.
     """
     if auth is None:
         return None
-    return CompiledMcpAuth(
+    return CompiledRemoteAuth(
         kind=auth["kind"],
         settings=tuple((key, value) for key, value in auth.items() if key != "kind"),
     )
@@ -254,6 +255,7 @@ def _compile_a2a(capability: A2ACapability, context: _Context) -> _HandlerResult
             agent=capability.agent,
             url=agent.url,
             headers_ref=agent.headers_ref,
+            auth=_compile_auth(agent.auth),
             include=capability.include,
             exclude=capability.exclude,
         ),

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/src/loom/ai/config.py

@@ -34,7 +34,7 @@ from loom.ai.errors import (
     policy_out_of_range,
 )
 from loom.ai.inference import InferenceTarget
-from loom.ai.mcp_auth import is_strategy_registered, registered_strategy_names
+from loom.ai.remote_auth import is_strategy_registered, registered_strategy_names
 from loom.core.model import LoomFrozenStruct
 
 # Conservative allowlist for a secret *reference*: a name, path, ARN or key id
@@ -191,7 +191,7 @@ class McpServerConfig(LoomFrozenStruct, frozen=True, kw_only=True):
             here; a bearer token belongs in ``auth: {kind: bearer}``.
             Mutually exclusive with ``auth``.
         auth: Named authentication strategy and its settings, flattened:
-            ``kind`` selects an entry point registered in ``loom.ai.mcp_auth``
+            ``kind`` selects an entry point registered in ``loom.ai.remote_auth``
             and every other key is passed to it as a keyword argument.
             Mutually exclusive with ``headers_ref``.
         timeout_ms: Deadline of a single call to this server.
@@ -206,14 +206,26 @@ class McpServerConfig(LoomFrozenStruct, frozen=True, kw_only=True):
 class A2AAgentConfig(LoomFrozenStruct, frozen=True, kw_only=True):
     """One named remote A2A agent (``ai.a2a_agents.<name>``).
 
+    The credential is declared exactly as an MCP server declares it, and for
+    the same reason: the artifact names the agent, the deployment says how to
+    authenticate to it.
+
     Attributes:
         url: ``https://`` agent URL, free of userinfo and query string.
         headers_ref: Reference to headers resolved by the secrets resolver.
-            Never a literal secret.
+            Never a literal secret.  The resolved payload must be a single
+            ``Name=value`` header pair, a shape checked at start-up rather than
+            here; a bearer token belongs in ``auth: {kind: bearer}``.
+            Mutually exclusive with ``auth``.
+        auth: Named authentication strategy and its settings, flattened:
+            ``kind`` selects an entry point registered in ``loom.ai.remote_auth``
+            and every other key is passed to it as a keyword argument.
+            Mutually exclusive with ``headers_ref``.
     """
 
     url: str
     headers_ref: str | None = None
+    auth: dict[str, str] | None = None
 
 
 class AgentEndpointConfig(LoomFrozenStruct, frozen=True, kw_only=True):
@@ -342,19 +354,22 @@ def _validate_headers_ref(component: str, headers_ref: str | None) -> list[Agent
     return [mcp_credentials_inline(component, "headers_ref")]
 
 
-def _validate_auth(component: str, server: McpServerConfig) -> list[AgentCompilationIssue]:
-    """Collect the issues of one server's ``auth`` block.
-
-    Two credentials on one connection are ambiguous, so ``headers_ref`` and
-    ``auth`` are refused together; every setting in the block is held to the
-    same fail-closed reference test as ``headers_ref``, so no literal secret
-    reaches loom by the back door; and an unregistered strategy is refused here
-    rather than at the first message in production.
+def _validate_auth(
+    component: str, headers_ref: str | None, auth: Mapping[str, str] | None
+) -> list[AgentCompilationIssue]:
+    """Collect the issues of one endpoint's ``auth`` block.
+
+    Applied to MCP servers and A2A agents alike, since both declare the same
+    block and resolve it through the same registry.  Two credentials on one
+    connection are ambiguous, so ``headers_ref`` and ``auth`` are refused
+    together; every setting in the block is held to the same fail-closed
+    reference test as ``headers_ref``, so no literal secret reaches loom by the
+    back door; and an unregistered strategy is refused here rather than at the
+    first message in production.
     """
-    auth = server.auth
     if auth is None:
         return []
-    if server.headers_ref is not None:
+    if headers_ref is not None:
         return [mcp_auth_conflict(component)]
     issues = [
         # The rejected value is deliberately absent from the issue, as for
@@ -378,7 +393,7 @@ def _validate_mcp_servers(
         component = f"ai.mcp_servers.{name}"
         issues.extend(_validate_remote_url(component, server.url, mcp_url_invalid))
         issues.extend(_validate_headers_ref(component, server.headers_ref))
-        issues.extend(_validate_auth(component, server))
+        issues.extend(_validate_auth(component, server.headers_ref, server.auth))
         if not _TIMEOUT_MS_MIN <= server.timeout_ms <= _TIMEOUT_MS_MAX:
             issues.append(
                 policy_out_of_range(
@@ -401,4 +416,5 @@ def _validate_a2a_agents(
         component = f"ai.a2a_agents.{name}"
         issues.extend(_validate_remote_url(component, agent.url, a2a_url_invalid))
         issues.extend(_validate_headers_ref(component, agent.headers_ref))
+        issues.extend(_validate_auth(component, agent.headers_ref, agent.auth))
     return issues

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/src/loom/ai/engines/pydantic_ai/_a2a.py

@@ -14,6 +14,13 @@ Two entry points, one connection recipe:
   per delegation, bounded by ``tool_timeout_ms`` like the call it precedes, and
   it buys a stateless toolset — no cached client, no connection nobody closes.
 
+The remote agent's credential is applied to the HTTP client itself, not to a
+single request, so **every** call carries it — the card fetch included. The card
+is the first request made, and an agent that authenticates its card endpoint
+would otherwise fail start-up before a skill was ever called. The credential is
+resolved by :mod:`loom.ai.remote_auth`, the same registry the MCP transport
+uses; this module only carries the result to the client.
+
 **The remote agent's reply is untrusted input (FR-044a).** It is returned as a
 tool *value*, never merged into instructions; it is never logged; and no byte
 of it reaches an error message, so a remote agent cannot dictate what the
@@ -34,8 +41,10 @@ from typing import TYPE_CHECKING, Final
 from loom.ai._filters import matches, select_names
 from loom.ai.compiler import CompiledA2ACapability
 from loom.ai.errors import AgentCompilationError, provider_not_installed
+from loom.ai.remote_auth import headers_from_ref, shared_a2a_auth
 
 if TYPE_CHECKING:
+    import httpx
     from a2a.client import Client
     from a2a.types.a2a_pb2 import AgentCard
 
@@ -57,6 +66,42 @@ def require_a2a_sdk() -> None:
         raise AgentCompilationError([provider_not_installed("a2a", "ai-a2a")])
 
 
+def build_a2a_http_client(capability: CompiledA2ACapability) -> httpx.AsyncClient:
+    """Build the HTTP client of one grant, carrying the credential it declared.
+
+    Fixed headers from ``headers_ref``, or the object the named strategy
+    builds — one instance per configured agent, shared by every agent granted
+    it.  Both are set on the client, so the card fetch presents them exactly as
+    the delegations that follow do.  A remote agent that declares neither is
+    connected exactly as before, which is what lets one artifact move between
+    environments unchanged.
+
+    Args:
+        capability: Compiled grant carrying the validated remote agent URL and
+            the credential resolved for it.
+
+    Returns:
+        The unopened client the card resolver and the session both speak
+        through; the caller closes it.
+
+    Raises:
+        AgentCompilationError: When the ``headers_ref`` payload is not one
+            ``Name=value`` pair, or the named strategy cannot be built.
+
+    Example::
+
+        async with build_a2a_http_client(capability) as http_client:
+            ...
+    """
+    import httpx
+
+    component = f"a2a agent '{capability.agent}'"
+    return httpx.AsyncClient(
+        headers=headers_from_ref(component, capability.headers_ref),
+        auth=shared_a2a_auth(capability.agent, capability.auth),
+    )
+
+
 @asynccontextmanager
 async def create_a2a_client(capability: CompiledA2ACapability) -> AsyncIterator[Client]:
     """Open one session against a remote agent, card fetched and checked.
@@ -66,14 +111,16 @@ async def create_a2a_client(capability: CompiledA2ACapability) -> AsyncIterator[
     of it and a failure is reported as a coded start-up issue.
 
     Args:
-        capability: Compiled grant carrying the validated ``https://`` URL and
-            the ``include``/``exclude`` filter selecting the skills the
-            artifact delegates to.
+        capability: Compiled grant carrying the validated ``https://`` URL, the
+            credential the deployment declared for the remote agent, and the
+            ``include``/``exclude`` filter selecting the skills the artifact
+            delegates to.
 
     Yields:
         The connected client, closed together with its HTTP client on exit.
 
     Raises:
+        AgentCompilationError: When the grant's credential cannot be resolved.
         AgentCardResolutionError: When the card cannot be fetched, decoded or
             validated.
         ValueError: When the card advertises no transport this client speaks,
@@ -83,10 +130,9 @@ async def create_a2a_client(capability: CompiledA2ACapability) -> AsyncIterator[
 
         runtime = AgentRuntime(..., a2a_client_factory=create_a2a_client)
     """
-    import httpx
     from a2a.client import A2ACardResolver, ClientConfig, ClientFactory
 
-    async with httpx.AsyncClient() as http_client:
+    async with build_a2a_http_client(capability) as http_client:
         card = await A2ACardResolver(http_client, capability.url).get_agent_card()
         _reject_ungranted_card(capability, card)
         config = ClientConfig(

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/src/loom/ai/engines/pydantic_ai/_mcp.py

@@ -14,7 +14,7 @@ Two entry points, one connection recipe — the shape :mod:`._a2a` already uses:
 Both build the same ``MCPToolset``: the connection rules of one grant — its
 validated URL and its credential — live here once, so start-up cannot validate
 a server the run would not reach.  The credential itself is resolved by
-:mod:`loom.ai.mcp_auth`, which is where the deployment's own strategy plugs in;
+:mod:`loom.ai.remote_auth`, which is where the deployment's own strategy plugs in;
 this module only carries the result to the client.
 
 The MCP client ships as an optional ``pydantic-ai-slim`` dependency, so it is
@@ -30,7 +30,7 @@ from typing import TYPE_CHECKING, Any
 
 from loom.ai.compiler import CompiledMcpCapability
 from loom.ai.errors import AgentCompilationError, provider_not_installed
-from loom.ai.mcp_auth import headers_from_ref, shared_auth
+from loom.ai.remote_auth import headers_from_ref, shared_mcp_auth
 
 if TYPE_CHECKING:
     from pydantic_ai.mcp import MCPToolset
@@ -100,7 +100,7 @@ def build_mcp_toolset(capability: CompiledMcpCapability) -> MCPToolset[Any]:
         raise AgentCompilationError([provider_not_installed("mcp", "mcp")]) from exc
     component = f"mcp server '{capability.server}'"
     headers = headers_from_ref(component, capability.headers_ref) or None
-    auth = shared_auth(capability.server, capability.auth)
+    auth = shared_mcp_auth(capability.server, capability.auth)
     toolset: MCPToolset[Any] = MCPToolset(capability.url, headers=headers, auth=auth)
     return toolset
 

{loom_kernel-1.7.1 → loom_kernel-1.8.0}/src/loom/ai/errors.py

@@ -421,13 +421,13 @@ def mcp_auth_conflict(component: str) -> AgentCompilationIssue:
 def mcp_auth_strategy_unknown(
     component: str, kind: str, available: Sequence[str]
 ) -> AgentCompilationIssue:
-    """A named auth strategy resolves to no entry point in ``loom.ai.mcp_auth``."""
+    """A named auth strategy resolves to no entry point in ``loom.ai.remote_auth``."""
     installed = ", ".join(available) if available else "none"
     return AgentCompilationIssue(
         code=AgentErrorCode.MCP_AUTH_STRATEGY_UNKNOWN,
         message=(
             f"{component}: auth strategy '{kind}' is not registered in entry-point "
-            f"group 'loom.ai.mcp_auth'; registered: {installed}"
+            f"group 'loom.ai.remote_auth'; registered: {installed}"
         ),
         component=component,
         field="auth.kind",
@@ -439,7 +439,7 @@ def mcp_auth_strategy_invalid(kind: str, reason: str) -> AgentCompilationIssue:
     return AgentCompilationIssue(
         code=AgentErrorCode.MCP_AUTH_STRATEGY_INVALID,
         message=f"auth strategy '{kind}' is unusable: {reason}",
-        component=f"loom.ai.mcp_auth:{kind}",
+        component=f"loom.ai.remote_auth:{kind}",
         field="auth.kind",
     )