loom-kernel 9.0.0__tar.gz → 9.2.0__tar.gz

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/CHANGELOG.md

@@ -2,6 +2,87 @@
 
 ## ✨ Features
 
+### etl
+
+- **etl:** `IntoTable(...).upsert(..., delete_flag=...)` deletes matched rows
+  whose boolean source column is true and does not insert unmatched rows with
+  that flag. A false or null flag keeps the normal update or insert; null is
+  read as false (`coalesce(s.<flag>, false)`). The column is removed before
+  schema alignment, including `SchemaMode.STRICT`, so it is never written and
+  never appears in the update or insert maps. It must exist on the source
+  frame, be boolean, must not be a key, a partition column, or listed in
+  `exclude` or `include`, and must not name a column of the target table;
+  otherwise `UpsertDeleteFlagError` is raised before anything is written. The
+  Polars writer applies it. Any other writer, including Spark, raises
+  `UnsupportedUpsertDeleteFlagError` and does not write. On first write the
+  table is created from the unflagged rows, so a batch where every row is
+  flagged creates an empty table. A key repeated in the source batch (for
+  example a tombstone and a live row) fails the MERGE. With
+  `SchemaMode.EVOLVE` the MERGE does not add new source columns, as before.
+  Omitting `delete_flag` leaves the MERGE byte-for-byte as it was: matched
+  update and unmatched insert, with no delete clause. `UpsertSpec` gains
+  `delete_flag`; `UpsertDeleteFlagError` and
+  `UnsupportedUpsertDeleteFlagError` are exported from `loom.etl`.
+- **etl:** `PolarsStepRunner` tests steps that use temps and real Delta
+  targets. `FromTemp`/`IntoTemp` work through an in-memory `CheckpointStore`
+  that keeps the production checks (an `IntoTemp` step returning a
+  `pl.DataFrame` raises `TypeError`, fan-in aligns to the first schema,
+  RUN then CORRELATION lookup); temps persist across `run()` calls of one
+  runner, which keeps a fixed run context. `seed_temp(name, data, columns,
+  *, schema=)` seeds a temp by `temp_name` from row tuples or a Polars frame;
+  `seed_temp(result)` seeds the `StepResult` of an `IntoTemp` step under the
+  name it wrote. A seeded temp lives in RUN scope, which `FromTemp` reads
+  before CORRELATION scope. A step whose target is `IntoTemp` returns, as its
+  `StepResult`, the temp read from the scope the step wrote (the accumulated
+  temp for fan-in) instead of raising "Step produced no output". `seed` and
+  `ETLScenario.with_table` accept `schema=` (loom types) so empty and all-null
+  columns keep their dtype. `PolarsStepRunner(*scenarios, delta_root=)`
+  applies scenarios at construction; with `delta_root` the real
+  `PolarsSourceReader`/`PolarsTargetWriter` run on that directory, seeds are
+  written as Delta tables (a column left without dtype raises `SchemaError`
+  asking for `schema=`), missing targets are created, and `table(ref)`
+  returns the final state. `StepResult` keeps the step's `target` spec and
+  derives `temp_name` and `delete_flag` from it. `StepResult.deletes` counts
+  the rows the step emitted with its upsert `delete_flag` set, and raises
+  `UpsertDeleteFlagError` when the output lacks the flag column or it is not
+  boolean; `StepResult.merged` returns the `MergeMetrics(inserted, updated,
+  deleted)` the Delta MERGE applied, only with `delta_root` and an upsert or
+  update that merged into an existing table. `ETLScenario` gains `with_temp`,
+  `after(step, params)` and `+`. `after()` runs the `IntoTemp` step once, on
+  a fresh in-memory runner seeded only with the scenario entries before it
+  (not the runner's config or other seeds), and seeds the memoized output on
+  every application. The scenario `repr` lists `tables`, `temps` and
+  `after` separately.
+  `SparkStepRunner.seed_temp` and `SparkStepRunner.seed(..., schema=...)`
+  raise `NotImplementedError`. Cache scenarios and frames, not runners: tests
+  that mutate state need a function-scoped runner on their own `tmp_path`.
+
+## ⚠ Behaviour changes
+
+### etl
+
+- **etl:** the `PolarsStepRunner` reader applies what a `FromTable` or
+  `FromFile` declares, as `PolarsSourceReader` does: `.where()` filters,
+  `.columns()` projects (an unknown column raises
+  `polars.exceptions.ColumnNotFoundError`), `with_schema` casts and
+  `parse_json` decodes. Before, the seeded frame reached the step unchanged;
+  a seed that was already decoded for a `parse_json` column must now hold the
+  JSON text.
+- **etl:** `ETLScenario` is immutable: `with_table` returns a new scenario
+  and no longer changes the one it is called on. Chained calls work as before;
+  code that called `scenario.with_table(...)` without using the result must
+  use it.
+- **etl:** `StepRunnerProto` requires `seed(..., *, schema=None)`,
+  `seed_temp` and `run`. `ETLScenario.apply` still calls `seed(ref, data,
+  columns)` positionally when no schema is declared.
+
+# 🚀 Releases 2.1.3 to 9.0.0
+
+Entries from 2.1.3 to 9.0.0 were kept under one heading and are not split
+by version; each release's own list is in its GitHub Release notes.
+
+## ✨ Features
+
 ### core
 
 - **core:** range-partitioned row-scoped tables.
@@ -99,6 +180,13 @@
   parameter raises a `TypeError` naming the code. `AgentErrorCode`,
   `StreamingErrorCode` and `ETLErrorCode` are such catalogues, and
   `ETLCompilationError.from_issue(issue)` raises the ETL error for an issue.
+- **core:** `loom.core.logger.log_context(**values)` adds fields to every log
+  record emitted inside the block through `get_logger` with its default
+  factory, and to plain stdlib records once `configure_logging` has installed
+  loom's formatter, so an application can bind, say, an audit `request_id`
+  without importing structlog. The values follow the current thread or
+  asyncio task, and each key regains its previous value on exit, even by
+  exception. The block must be entered and exited in the same context.
 
 ### ai
 
@@ -965,12 +1053,11 @@
 - **rest:** a JSON object body that fails `Command` validation now answers
   `422 boundary_validation` with a `violations` list (`{field, message}`
   pairs, `field` being the wire name the client sent, the same shape
-  `rule_violations` already uses) instead of a generic `500`; malformed
-  JSON and a non-object body are unchanged. `Command.from_payload` now
-  raises `BoundaryValidationError` — a `ValueError` — instead of
-  `msgspec.ValidationError`. The root `title` is dropped on pydantic
-  OpenAPI schemas for request bodies and responses alike, matching the
-  untitled document a Struct always produced.
+  `rule_violations` already uses) instead of a generic `500`.
+  `Command.from_payload` now raises `BoundaryValidationError` — a
+  `ValueError` — instead of `msgspec.ValidationError`. The root `title` is
+  dropped on pydantic OpenAPI schemas for request bodies and responses alike,
+  matching the untitled document a Struct always produced.
 - **rest:** a `sortable` column must be a field of the items the route
   answers with (`PageResult[T]`, `CursorResult[T]` or `list[T]`); a column
   the response does not show, or a result type that does not say, fails
@@ -998,6 +1085,24 @@
   `QUERY_PARAM_SORT`, `QUERY_PARAM_DIRECTION` and `QUERY_PARAM_PROFILE`
   re-exports of `loom.rest.fastapi.openapi` are removed; use the matching
   `loom.rest.constants.QueryParam` member (`QueryParam.PAGE`, ...).
+- **rest:** a request body that is not well-formed JSON — a syntax error,
+  bytes that are not UTF-8, nesting too deep to decode, or an empty body on a
+  route that takes input — now answers `400` with the standard error body
+  (`code: bad_request`, the fixed message `Request body is not valid JSON`,
+  `trace_id`) instead of a generic `500 internal_error` without the `detail`
+  envelope. Well-formed JSON that is not an object (an array, a string, a
+  number, `null`) answers `422 boundary_validation` with the fixed message
+  `Request body must be a JSON object` and one `body` violation, instead of
+  that same `500`. Neither echoes the body. A JSON object that fails
+  validation still answers `422` as before, and the `Content-Type` header is
+  still not checked.
+- **rest:** the SQL endpoint answers a body that is not well-formed JSON the
+  same way: `400` with `code: bad_request` and the fixed message
+  `Request body is not valid JSON`, instead of a `422 rule_violation` that
+  carried the decoder's message. Bytes that are not UTF-8 inside a JSON
+  string and nesting too deep to decode, which answered a generic
+  `500 internal_error`, are now that `400` too. A well-formed body
+  that does not fit the schema still answers `422 rule_violation`.
 
 ### prefect
 

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: loom-kernel
-Version: 9.0.0
+Version: 9.2.0
 Summary: Loom Python project
 License-File: LICENSE
 Classifier: Programming Language :: Python :: 3

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/a2a/card.py

@@ -136,7 +136,7 @@ def build_agent_card(
         "protocolVersion": PROTOCOL_VERSION,
         "name": plan.name,
         "description": plan.description,
-        "url": agent_url(config.base_url, plan.name, prefix=prefix),
+        "url": agent_url(config.base_url.reveal(), plan.name, prefix=prefix),
         "version": str(plan.spec_version),
         "capabilities": dict(_TRANSPORT_CAPABILITIES),
         "defaultInputModes": list(_INPUT_MODES),

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/a2a/server.py

@@ -221,5 +221,8 @@ def bind_a2a_endpoints(
             methods=["POST"],
         )
         announce_publication(
-            agent, base_url=config.a2a.base_url, mechanism=mechanism, prefix=prefix
+            agent,
+            base_url=str(config.a2a.base_url),
+            mechanism=mechanism,
+            prefix=prefix,
         )

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/compiler/_plan.py

@@ -30,6 +30,7 @@ from loom.ai.inference import InferenceTarget
 from loom.ai.pricing import ModelPrice
 from loom.core.engine.compilable import Compilable
 from loom.core.model import LoomFrozenStruct, LoomType
+from loom.core.model.redaction import Secret
 from loom.core.sql.config import SqlConnectionConfig
 
 
@@ -111,11 +112,12 @@ class CompiledRemoteAuth(LoomFrozenStruct, frozen=True, kw_only=True):
     Attributes:
         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.
+            keyword arguments in declaration order. A repr masks them; the
+            strategy receives the text when it is built.
     """
 
     kind: str
-    settings: tuple[tuple[str, str], ...] = ()
+    settings: tuple[tuple[str, Secret[str] | str], ...] = ()
 
 
 class CompiledMcpCapability(LoomFrozenStruct, frozen=True, kw_only=True):
@@ -139,7 +141,8 @@ class CompiledMcpCapability(LoomFrozenStruct, frozen=True, kw_only=True):
             of this worker.
         url: Validated ``https://`` server URL, free of inline credentials;
             ``None`` under ``stdio``.
-        headers_ref: Reference to deployment-resolved headers; never a secret.
+        headers_ref: Resolved header payload. A repr masks it; the client
+            reveals it when the connection opens.
         auth: Named authentication strategy, mutually exclusive with
             ``headers_ref``; ``None`` when the server needs no credential.
         timeout_ms: Deadline of a single call to this server.
@@ -148,6 +151,7 @@ class CompiledMcpCapability(LoomFrozenStruct, frozen=True, kw_only=True):
         args: Arguments passed to ``command``.
         env: Environment handed to the subprocess as key-sorted pairs, so the
             plan stays a hashable value whatever order the operator wrote.
+            Values are masked in a repr and revealed when the process starts.
         include: Tool names or glob patterns to expose; empty means all.
         exclude: Tool names or glob patterns to omit, applied after ``include``.
     """
@@ -157,12 +161,12 @@ class CompiledMcpCapability(LoomFrozenStruct, frozen=True, kw_only=True):
     server: str
     transport: str = "http"
     url: str | None = None
-    headers_ref: str | None = None
+    headers_ref: Secret[str] | None = None
     auth: CompiledRemoteAuth | None = None
     timeout_ms: int = 20000
     command: str | None = None
     args: tuple[str, ...] = ()
-    env: tuple[tuple[str, str], ...] = ()
+    env: tuple[tuple[str, Secret[str] | str], ...] = ()
     include: tuple[str, ...] = ()
     exclude: tuple[str, ...] = ()
 
@@ -244,7 +248,8 @@ class CompiledA2ACapability(LoomFrozenStruct, frozen=True, kw_only=True):
     Attributes:
         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.
+        headers_ref: Resolved header payload. A repr masks it; the client
+            reveals it when the connection opens.
             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.
@@ -256,7 +261,7 @@ class CompiledA2ACapability(LoomFrozenStruct, frozen=True, kw_only=True):
 
     agent: str
     url: str
-    headers_ref: str | None = None
+    headers_ref: Secret[str] | None = None
     auth: CompiledRemoteAuth | None = None
     include: tuple[str, ...] = ()
     exclude: tuple[str, ...] = ()

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/compiler/phases/_capabilities.py

@@ -49,6 +49,7 @@ from loom.ai.declarative import (
 from loom.ai.errors import AgentCompilationError, AgentCompilationIssue, AgentErrorCode
 from loom.ai.inference import InferenceTarget
 from loom.core.engine.compilable import Compilable
+from loom.core.model.redaction import Secret
 from loom.core.sql.config import SqlConfig, roles_need_identity_binding
 from loom.core.symbols import import_symbol
 from loom.core.use_case.registry import UseCaseRegistry
@@ -319,13 +320,13 @@ def compile_mcp_capability(
         CompiledMcpCapability(
             server=server_name,
             transport=server.transport,
-            url=server.url,
+            url=None if server.url is None else server.url.reveal(),
             headers_ref=server.headers_ref,
             auth=_compile_auth(server.auth),
             timeout_ms=server.timeout_ms,
             command=server.command,
             args=server.args,
-            env=tuple(sorted((server.env or {}).items())),
+            env=tuple(sorted((key, _carry(value)) for key, value in (server.env or {}).items())),
             include=include,
             exclude=exclude,
         ),
@@ -343,7 +344,17 @@ def _compile_mcp(capability: McpCapability, context: _Context) -> _HandlerResult
     )
 
 
-def _compile_auth(auth: Mapping[str, str] | None) -> CompiledRemoteAuth | None:
+def _carry(value: object) -> Secret[str] | str:
+    """Hold a resolved setting. A blank string stays text: ``Secret`` rejects it."""
+    if isinstance(value, Secret):
+        return value
+    text = value if isinstance(value, str) else str(value)
+    if text.strip():
+        return Secret(text)
+    return text
+
+
+def _compile_auth(auth: Mapping[str, object] | None) -> CompiledRemoteAuth | None:
     """Split a validated ``auth`` block into the strategy name and its settings.
 
     Shared by the ``mcp`` and ``a2a`` grants: both endpoints declare the same
@@ -354,8 +365,8 @@ def _compile_auth(auth: Mapping[str, str] | None) -> CompiledRemoteAuth | None:
     if auth is None:
         return None
     return CompiledRemoteAuth(
-        kind=auth["kind"],
-        settings=tuple((key, value) for key, value in auth.items() if key != "kind"),
+        kind=str(auth["kind"]),
+        settings=tuple((key, _carry(value)) for key, value in auth.items() if key != "kind"),
     )
 
 
@@ -370,7 +381,7 @@ def _compile_a2a(capability: A2ACapability, context: _Context) -> _HandlerResult
     return (
         CompiledA2ACapability(
             agent=capability.agent,
-            url=agent.url,
+            url=agent.url.reveal(),
             headers_ref=agent.headers_ref,
             auth=_compile_auth(agent.auth),
             include=capability.include,

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/config.py

@@ -25,6 +25,7 @@ from loom.ai.inference import OUTPUT_MODES, InferenceTarget
 from loom.ai.pricing import ModelPrice
 from loom.ai.remote_auth import is_strategy_registered, registered_strategy_names
 from loom.core.model import LoomFrozenStruct
+from loom.core.model.redaction import Dsn, RedactedMap, Secret
 
 # Conservative allowlist for a secret *reference*: a name, path, ARN or key id
 # the secrets resolver can look up.  It excludes whitespace, newlines, quotes,
@@ -241,13 +242,13 @@ class McpServerConfig(LoomFrozenStruct, frozen=True, kw_only=True):
     """
 
     transport: str = "http"
-    url: str | None = None
-    headers_ref: str | None = None
-    auth: dict[str, str] | None = None
+    url: Dsn | None = None
+    headers_ref: Secret[str] | None = None
+    auth: RedactedMap | None = None
     timeout_ms: int = 20000
     command: str | None = None
     args: tuple[str, ...] = ()
-    env: dict[str, str] | None = None
+    env: RedactedMap | None = None
 
 
 class A2AAgentConfig(LoomFrozenStruct, frozen=True, kw_only=True):
@@ -270,9 +271,9 @@ class A2AAgentConfig(LoomFrozenStruct, frozen=True, kw_only=True):
             Mutually exclusive with ``headers_ref``.
     """
 
-    url: str
-    headers_ref: str | None = None
-    auth: dict[str, str] | None = None
+    url: Dsn
+    headers_ref: Secret[str] | None = None
+    auth: RedactedMap | None = None
 
 
 class AgentEndpointConfig(LoomFrozenStruct, frozen=True, kw_only=True):
@@ -306,7 +307,7 @@ class A2AConfig(LoomFrozenStruct, frozen=True, kw_only=True):
             when ``expose`` names no agent.
     """
 
-    base_url: str
+    base_url: Dsn
     expose: tuple[str, ...]
 
     def __post_init__(self) -> None:
@@ -317,15 +318,17 @@ class A2AConfig(LoomFrozenStruct, frozen=True, kw_only=True):
         # advertise a plaintext channel to every discovering client, and
         # userinfo would publish a credential outright. Same rule the compiler
         # already applies to the remote URLs it validates, applied where this
-        # one actually lives (FR-038).
-        fault = _url_fault(self.base_url)
+        # one actually lives (FR-038). The check reads the address; the card
+        # and the error publish only the redacted form.
+        address = self.base_url.reveal()
+        fault = _url_fault(address)
         if fault is None:
-            _warn_plaintext_loopback("ai.a2a.base_url", self.base_url)
+            _warn_plaintext_loopback("ai.a2a.base_url", address)
         if fault is not None:
             raise AgentCompilationError(
                 [
                     AgentErrorCode.A2A_BASE_URL_INVALID.issue(
-                        url=_redact_url(self.base_url), reason=fault
+                        url=_redact_url(address), reason=fault
                     )
                 ]
             )
@@ -450,21 +453,27 @@ def _warn_unused_prices(
 
 
 def _validate_remote_url(
-    component: str, url: str, invalid: AgentErrorCode
+    component: str, url: Dsn | str, invalid: AgentErrorCode
 ) -> list[AgentCompilationIssue]:
     """Collect the fault of one remote URL, redacted so it cannot leak a secret.
 
     The *invalid* code takes ``component, url, reason``.
     """
-    fault = _url_fault(url)
+    address = url.reveal() if isinstance(url, Dsn) else url
+    fault = _url_fault(address)
     if fault is None:
-        _warn_plaintext_loopback(component, url)
+        _warn_plaintext_loopback(component, address)
         return []
-    return [invalid.issue(component=component, url=_redact_url(url), reason=fault)]
+    return [invalid.issue(component=component, url=_redact_url(address), reason=fault)]
 
 
-def _validate_headers_ref(component: str, headers_ref: str | None) -> list[AgentCompilationIssue]:
-    if headers_ref is None or _is_credentials_reference(headers_ref):
+def _validate_headers_ref(
+    component: str, headers_ref: Secret[str] | str | None
+) -> list[AgentCompilationIssue]:
+    if headers_ref is None:
+        return []
+    text = headers_ref.reveal() if isinstance(headers_ref, Secret) else headers_ref
+    if _is_credentials_reference(text):
         return []
     # The rejected value is deliberately absent: the message must not leak the
     # very secret it rejects.
@@ -472,7 +481,9 @@ def _validate_headers_ref(component: str, headers_ref: str | None) -> list[Agent
 
 
 def _validate_auth(
-    component: str, headers_ref: str | None, auth: Mapping[str, str] | None
+    component: str,
+    headers_ref: Secret[str] | str | None,
+    auth: Mapping[str, object] | None,
 ) -> list[AgentCompilationIssue]:
     """Collect the issues of one endpoint's ``auth`` block.
 
@@ -493,9 +504,11 @@ def _validate_auth(
         # ``headers_ref``: the message must not leak what it rejects.
         AgentErrorCode.MCP_CREDENTIALS_INLINE.issue(component=component, field=f"auth.{key}")
         for key, value in auth.items()
-        if key != _AUTH_KIND_KEY and not _is_credentials_reference(value)
+        if key != _AUTH_KIND_KEY
+        and not (isinstance(value, str) and _is_credentials_reference(value))
     ]
-    kind = auth.get(_AUTH_KIND_KEY, "")
+    raw_kind = auth.get(_AUTH_KIND_KEY, "")
+    kind = raw_kind if isinstance(raw_kind, str) else ""
     if not is_strategy_registered(kind):
         issues.append(
             AgentErrorCode.MCP_AUTH_STRATEGY_UNKNOWN.issue(
@@ -582,7 +595,9 @@ def _validate_stdio_server(component: str, server: McpServerConfig) -> list[Agen
     return issues
 
 
-def _validate_mcp_env(component: str, env: Mapping[str, str] | None) -> list[AgentCompilationIssue]:
+def _validate_mcp_env(
+    component: str, env: Mapping[str, object] | None
+) -> list[AgentCompilationIssue]:
     """Collect the issues of a subprocess ``env`` block: valid names, single-token values."""
     if env is None:
         return []
@@ -596,7 +611,7 @@ def _validate_mcp_env(component: str, env: Mapping[str, str] | None) -> list[Age
                     reason=f"'{name}' is not a valid environment variable name",
                 )
             )
-        if not _has_reference_shape(value):
+        if not isinstance(value, str) or not _has_reference_shape(value):
             # The rejected value is deliberately absent: a broken interpolation
             # may still contain part of the secret it failed to resolve.
             issues.append(

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/engines/pydantic_ai/_mcp.py

@@ -47,6 +47,7 @@ from loom.ai.compiler import CompiledMcpCapability, mcp_connection
 from loom.ai.errors import AgentCompilationError, AgentErrorCode
 from loom.ai.registry import require_provider_sdk
 from loom.ai.remote_auth import headers_from_ref, shared_mcp_auth
+from loom.core.model.redaction import Secret
 
 if TYPE_CHECKING:
     from fastmcp.client.transports import ClientTransport, StdioTransport
@@ -299,7 +300,11 @@ def _stdio_transport(command: str, capability: CompiledMcpCapability) -> ClientT
     return _sdk().StdioTransport(
         command=command,
         args=list(capability.args),
-        env=dict(capability.env) or None,
+        env={
+            key: value.reveal() if isinstance(value, Secret) else value
+            for key, value in capability.env
+        }
+        or None,
         keep_alive=False,
     )
 

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/engines/pydantic_ai/providers/_shared.py

@@ -38,6 +38,17 @@ def model_settings(target: InferenceTarget) -> ModelSettings | None:
     return cast(ModelSettings, dict(target.options))
 
 
+def provider_endpoint(target: InferenceTarget) -> str | None:
+    """Return the endpoint string the provider SDK connects to.
+
+    ``None`` leaves the SDK on its own default. The stored address stays a
+    :class:`~loom.core.model.redaction.Dsn`, whose text form hides a password.
+    """
+    if target.endpoint is None:
+        return None
+    return target.endpoint.reveal()
+
+
 def api_key(target: InferenceTarget) -> str | None:
     """Read the API key of a target whose ``credentials_ref`` names a variable.
 

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/engines/pydantic_ai/providers/anthropic.py

@@ -6,7 +6,7 @@ from pydantic_ai.models import Model
 from pydantic_ai.models.anthropic import AnthropicModel
 from pydantic_ai.providers.anthropic import AnthropicProvider
 
-from loom.ai.engines.pydantic_ai.providers._shared import api_key, model_settings
+from loom.ai.engines.pydantic_ai.providers._shared import api_key, model_settings, provider_endpoint
 from loom.ai.inference import InferenceTarget
 
 MODEL_CLASS: type[Model] = AnthropicModel
@@ -14,5 +14,5 @@ MODEL_CLASS: type[Model] = AnthropicModel
 
 def build(target: InferenceTarget) -> Model:
     """Build the Anthropic model of one binding; ``endpoint`` overrides the base URL."""
-    provider = AnthropicProvider(api_key=api_key(target), base_url=target.endpoint)
+    provider = AnthropicProvider(api_key=api_key(target), base_url=provider_endpoint(target))
     return AnthropicModel(target.model, provider=provider, settings=model_settings(target))

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/engines/pydantic_ai/providers/bedrock.py

@@ -6,7 +6,7 @@ from pydantic_ai.models import Model
 from pydantic_ai.models.bedrock import BedrockConverseModel
 from pydantic_ai.providers.bedrock import BedrockProvider
 
-from loom.ai.engines.pydantic_ai.providers._shared import model_settings
+from loom.ai.engines.pydantic_ai.providers._shared import model_settings, provider_endpoint
 from loom.ai.inference import InferenceTarget
 from loom.ai.registry import require_provider_setting
 
@@ -19,6 +19,6 @@ def build(target: InferenceTarget) -> Model:
     provider = BedrockProvider(
         region_name=target.region,
         profile_name=target.credentials_ref,
-        base_url=target.endpoint,
+        base_url=provider_endpoint(target),
     )
     return BedrockConverseModel(target.model, provider=provider, settings=model_settings(target))

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/engines/pydantic_ai/providers/openai.py

@@ -6,7 +6,7 @@ from pydantic_ai.models import Model
 from pydantic_ai.models.openai import OpenAIChatModel
 from pydantic_ai.providers.openai import OpenAIProvider
 
-from loom.ai.engines.pydantic_ai.providers._shared import api_key, model_settings
+from loom.ai.engines.pydantic_ai.providers._shared import api_key, model_settings, provider_endpoint
 from loom.ai.inference import InferenceTarget
 
 MODEL_CLASS: type[Model] = OpenAIChatModel
@@ -14,5 +14,5 @@ MODEL_CLASS: type[Model] = OpenAIChatModel
 
 def build(target: InferenceTarget) -> Model:
     """Build the OpenAI chat model of one binding; ``endpoint`` overrides the base URL."""
-    provider = OpenAIProvider(base_url=target.endpoint, api_key=api_key(target))
+    provider = OpenAIProvider(base_url=provider_endpoint(target), api_key=api_key(target))
     return OpenAIChatModel(target.model, provider=provider, settings=model_settings(target))

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/engines/pydantic_ai/providers/typesafe.py

@@ -11,7 +11,7 @@ from pydantic_ai.models import Model
 from pydantic_ai.models.typesafe import TypeSafeModel
 from pydantic_ai.providers.typesafe import TypeSafeProvider
 
-from loom.ai.engines.pydantic_ai.providers._shared import api_key, model_settings
+from loom.ai.engines.pydantic_ai.providers._shared import api_key, model_settings, provider_endpoint
 from loom.ai.errors import AgentCompilationError, AgentErrorCode
 from loom.ai.inference import InferenceTarget
 
@@ -31,5 +31,5 @@ def build(target: InferenceTarget) -> Model:
                 )
             ]
         )
-    provider = TypeSafeProvider(api_key=api_key(target), base_url=target.endpoint)
+    provider = TypeSafeProvider(api_key=api_key(target), base_url=provider_endpoint(target))
     return TypeSafeModel(target.model, provider=provider, settings=model_settings(target))

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/inference.py

@@ -25,6 +25,7 @@ from typing import Any, Final, Literal, get_args
 from msgspec import field, structs
 
 from loom.core.model import LoomFrozenStruct
+from loom.core.model.redaction import Dsn
 
 OutputMode = Literal["tool", "native"]
 """How the engine asks the model for the structured answer.
@@ -131,7 +132,7 @@ class InferenceTarget(LoomFrozenStruct, frozen=True, kw_only=True):
     provider: str
     model: str
     region: str | None = None
-    endpoint: str | None = None
+    endpoint: Dsn | None = None
     output_mode: str | None = None
     streaming: bool = True
     credentials_ref: str | None = None

{loom_kernel-9.0.0 → loom_kernel-9.2.0}/src/loom/ai/remote_auth.py

@@ -82,6 +82,7 @@ from typing import TYPE_CHECKING, Any, Final, cast, get_type_hints
 import msgspec
 
 from loom.ai.errors import AgentCompilationError, AgentErrorCode
+from loom.core.model.redaction import Secret
 from loom.core.plugins.entrypoints import (
     DuplicateEntryPointError,
     EntryPointNotFoundError,
@@ -154,7 +155,7 @@ def is_strategy_registered(kind: str) -> bool:
     return select_entry_point(REMOTE_AUTH_ENTRY_POINT_GROUP, kind, on_duplicate="error") is not None
 
 
-def headers_from_ref(component: str, headers_ref: str | None) -> dict[str, str]:
+def headers_from_ref(component: str, headers_ref: Secret[str] | str | None) -> dict[str, str]:
     """Read the header a resolved ``headers_ref`` carries.
 
     The deployment's secret resolver has already run — ``${secrets:/path}`` is
@@ -184,7 +185,8 @@ def headers_from_ref(component: str, headers_ref: str | None) -> dict[str, str]:
     """
     if headers_ref is None:
         return {}
-    name, separator, value = headers_ref.partition(_HEADER_SEPARATOR)
+    payload = headers_ref.reveal() if isinstance(headers_ref, Secret) else headers_ref
+    name, separator, value = payload.partition(_HEADER_SEPARATOR)
     if not separator or not name or not value:
         raise AgentCompilationError(
             [AgentErrorCode.MCP_HEADERS_REF_INVALID.issue(component=component)]
@@ -415,7 +417,11 @@ def _build(auth: CompiledRemoteAuth) -> ClientAuth:
     """Load the named strategy and construct it from its settings."""
     strategy = _load_strategy(auth.kind)
     try:
-        settings = _coerce_settings(strategy, dict(auth.settings))
+        plain = {
+            key: value.reveal() if isinstance(value, Secret) else value
+            for key, value in auth.settings
+        }
+        settings = _coerce_settings(strategy, plain)
     except msgspec.ValidationError as exc:
         raise AgentCompilationError(
             [