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

{loom_kernel-1.7.0 → loom_kernel-1.8.0}/.github/workflows/ci-main.yml

@@ -31,7 +31,7 @@ jobs:
           pip install --only-binary :all: "uv==0.10.2"
 
       - name: Quality report (strict)
-        uses: the-reacher-data/loom-actions/actions/python/quality-report@e731576f4f9cf4ec2b36fddfc895d328c856d29f # v1
+        uses: the-reacher-data/loom-actions/actions/python/quality-report@bdb1b5bc76f37f3f33a6598224e864c17b8d756a # v1.0.5
         with:
           src-dir: src
           test-dir: tests

{loom_kernel-1.7.0 → loom_kernel-1.8.0}/.github/workflows/ci-pr.yml

@@ -50,7 +50,7 @@ jobs:
       - name: Quality report (strict gate)
         id: quality
         continue-on-error: true
-        uses: the-reacher-data/loom-actions/actions/python/quality-report@e731576f4f9cf4ec2b36fddfc895d328c856d29f # v1
+        uses: the-reacher-data/loom-actions/actions/python/quality-report@bdb1b5bc76f37f3f33a6598224e864c17b8d756a # v1.0.5
         with:
           src-dir: src
           test-dir: tests
@@ -61,7 +61,7 @@ jobs:
 
       - name: Publish PR quality comment
         if: ${{ always() && steps.quality.outputs.report-file != '' }}
-        uses: the-reacher-data/loom-actions/actions/core/pr-comment-update@e731576f4f9cf4ec2b36fddfc895d328c856d29f # v1
+        uses: the-reacher-data/loom-actions/actions/core/pr-comment-update@bdb1b5bc76f37f3f33a6598224e864c17b8d756a # v1.0.5
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           tags: "<!-- loom-quality-report -->"
@@ -69,7 +69,7 @@ jobs:
 
       - name: Compute candidate prerelease version
         id: version
-        uses: the-reacher-data/loom-actions/actions/release/versioning-branch-semantic@e731576f4f9cf4ec2b36fddfc895d328c856d29f # v1
+        uses: the-reacher-data/loom-actions/actions/release/versioning-branch-semantic@bdb1b5bc76f37f3f33a6598224e864c17b8d756a # v1.0.5
         with:
           branch: ${{ github.head_ref }}
           prerelease: "true"
@@ -77,7 +77,7 @@ jobs:
       - name: Generate changelog preview
         id: changelog
         continue-on-error: true
-        uses: the-reacher-data/loom-actions/actions/release/changelog-conventional-commit@e731576f4f9cf4ec2b36fddfc895d328c856d29f # v1
+        uses: the-reacher-data/loom-actions/actions/release/changelog-conventional-commit@bdb1b5bc76f37f3f33a6598224e864c17b8d756a # v1.0.5
         with:
           mode: "pr"
           branch: ${{ github.event.pull_request.head.sha }}
@@ -88,7 +88,7 @@ jobs:
 
       - name: Publish PR changelog comment
         if: ${{ steps.changelog.outcome == 'success' && steps.changelog.outputs.output_path != '' }}
-        uses: the-reacher-data/loom-actions/actions/core/pr-comment-update@e731576f4f9cf4ec2b36fddfc895d328c856d29f # v1
+        uses: the-reacher-data/loom-actions/actions/core/pr-comment-update@bdb1b5bc76f37f3f33a6598224e864c17b8d756a # v1.0.5
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           tags: "<!-- changelog-preview -->,<!-- branch-source:${{ github.head_ref }} -->"

{loom_kernel-1.7.0 → loom_kernel-1.8.0}/.github/workflows/release.yml

@@ -47,7 +47,7 @@ jobs:
 
       - name: Compute release version from merged branch
         id: version
-        uses: the-reacher-data/loom-actions/actions/release/versioning-branch-semantic@e731576f4f9cf4ec2b36fddfc895d328c856d29f # v1
+        uses: the-reacher-data/loom-actions/actions/release/versioning-branch-semantic@bdb1b5bc76f37f3f33a6598224e864c17b8d756a # v1.0.5
         with:
           branch: ${{ env.RELEASE_BRANCH }}
           prerelease: "false"
@@ -67,7 +67,7 @@ jobs:
       - name: Generate release changelog
         id: changelog
         if: ${{ steps.version.outputs.deploy == 'true' && github.event_name != 'workflow_dispatch' }}
-        uses: the-reacher-data/loom-actions/actions/release/changelog-conventional-commit@e731576f4f9cf4ec2b36fddfc895d328c856d29f # v1
+        uses: the-reacher-data/loom-actions/actions/release/changelog-conventional-commit@bdb1b5bc76f37f3f33a6598224e864c17b8d756a # v1.0.5
         with:
           mode: "release"
           branch: ${{ env.RELEASE_BRANCH }}

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

@@ -1,3 +1,71 @@
+# 🚀 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))
+
+
+## 🐛 Fixes
+### streaming
+- **streaming:** emit a terminal span for outbound topic writes ([#143](https://github.com/the-reacher-data/loom-py/pull/143))<br>
+  > `TerminalReason.SINK_WRITE` has documented "written to a storage sink or an
+  > outbound topic" since 1.7.0, but the outbound half was never true: the Kafka
+  > sink partition had no observability runtime in reach, so a flow ending in
+  > `IntoTopic` produced a trace that stopped at its last node span.
+  >
+  > A message written to an outbound topic now emits one terminal span in its own
+  > trace, plus the same N+1 batch shape as the storage sink. Failed writes close
+  > failed and carry `terminal.failure_scope="batch"`, because the producer keeps
+  > one delivery error for a whole batch — without the marker a trace would claim
+  > that messages the broker acknowledged had failed. A batch diverted to a DLQ
+  > also closes failed: `send_batch_to_dlq` never flushes, so at span-close time
+  > the landing is unverified.
+  >
+  > The untraced path gained no branch: tracing is a wrapper returned only when
+  > bound, so a flow without observability runs exactly the code it ran before.
+  >
+  > Three of five death paths are now traced. Drop sinks and `Drain` still emit
+  > no terminal span.
+
+
 # 🚀 Release 1.7.0 ([#142](https://github.com/the-reacher-data/loom-py/pull/142)) ([`1a9240a`](https://github.com/the-reacher-data/loom-py/commit/1a9240a6))
 
 

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

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

{loom_kernel-1.7.0 → 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.0 → 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.0 → loom_kernel-1.8.0}/docs/streaming/tracing.md

@@ -22,7 +22,7 @@ rather than emitting an unusable one.
 | --- | --- |
 | `transport:kafka_consume` | The consumer, from the inbound header — the message's birth |
 | `node:<flow>:<idx>` | Each node the message traverses |
-| `terminal:sink_write` | Written to a storage sink |
+| `terminal:sink_write` | Written to a storage sink or an outbound Kafka topic |
 | `terminal:error_envelope` | Turned into an error envelope or routed to a DLQ |
 | `terminal:dropped_no_route` | Expanded or routed to zero rows |
 
@@ -112,6 +112,27 @@ broken.
   ratio, most batch spans are dropped along with most messages. What holds at
   every ratio is that an exported batch span links to exactly the participation
   spans that were also exported.
-- **`IntoTopic` outputs do not yet emit a terminal span.** A message written to
-  an outbound topic ends its trace at its last node span. Storage sinks, error
-  envelopes and no-route drops are covered.
+- **Two death paths are still untraced.** `_DropSinkPartition` (an unrouted
+  branch or error kind) and `Drain` discard a message without a terminal span,
+  so `TerminalReason.DROPPED_NO_ROUTE` is not emitted on either. Three of the
+  five death paths — outbound topic, storage sink, error envelope — are traced.
+- **A wire decode failure has no terminal span, and cannot have one.** A
+  `DecodeError` never became a message: it carries no `MessageMeta`, so there is
+  no trace id, no message id and no lineage to open a span in. Fabricating a
+  synthetic meta would invent a message that never existed.
+- **A failed outbound batch fails every message in it.** The Kafka producer
+  keeps one pending delivery error and `flush()` raises it for the whole batch,
+  so a single rejected record closes all N terminal spans failed. Those spans
+  carry `terminal.failure_scope="batch"` to say the attribution is batch-wide,
+  not per record. Success carries no such attribute: `flush()` waited for every
+  record, so a successful death is per-message truth.
+- **A batch diverted to a DLQ closes failed, with `terminal.dlq_topic` set.**
+  The diversion never flushes and swallows per-item failures, so at span-close
+  time the DLQ landing is unverified. The batch still commits, as it did before.
+- **A delivery error can be attributed to the wrong batch.** The producer's
+  pending error is consumed by whichever `flush()` observes it, which may be the
+  next batch's. The terminal spans that close failed are then one batch late.
+- **Epoch replay produces duplicate terminal spans.** Bytewax replays an epoch
+  from the last snapshot after a failure, so a message written twice records two
+  `terminal:sink_write` spans under one trace id. That is at-least-once delivery
+  being visible, not a tracing fault; deduplicate on `loom.batch_id`.

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

@@ -1,6 +1,6 @@
 [project]
 name = "loom-kernel"
-version = "1.7.0"
+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.0"
+version = "1.8.0"
 tag_format = "v$version"
 version_files = [
     "pyproject.toml:project.version",

{loom_kernel-1.7.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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