loom-kernel 2.15.0__tar.gz → 2.15.1__tar.gz

{loom_kernel-2.15.0 → loom_kernel-2.15.1}/CHANGELOG.md

@@ -430,6 +430,19 @@
 
 ### ai
 
+- **ai:** a configured `ai.prices` rate prices runs again with pydantic-ai
+  2.54. That release records a response's usage before the
+  `after_model_request` hook loom priced it in, so every run reported
+  `AgentUsage.cost=None`: `policies.max_usd` stopped binding, a reported cost
+  was summed instead of replaced, and the ETL budget ledger kept each run's
+  whole reservation. The price is now applied by a model wrapper as the model
+  returns each response, in both run modes, before any engine release records
+  it. The lock moves to pydantic-ai-slim 2.54.0, which sends `tool_choice:
+  auto` for a `tool` output with adaptive thinking, so Anthropic models reason
+  again (2.47 forced the tool). `UsageExtractionFailedWarning`, new in 2.52, is
+  classified `COST_NOT_MEASURABLE` like its siblings. Every `ai-*` extra now
+  declares `pydantic-ai-slim>=2.45`, the oldest release loom imports and passes
+  its agent suites with, and CI runs those suites against that floor.
 - **ai:** an MCP session that dies after it opened no longer fails every later
   call until the worker restarts. The worker holds one session per server for
   its whole life, and that holder kept the dead client from ever being

{loom_kernel-2.15.0 → loom_kernel-2.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: loom-kernel
-Version: 2.15.0
+Version: 2.15.1
 Summary: Loom Python project
 License-File: LICENSE
 Classifier: Programming Language :: Python :: 3
@@ -22,17 +22,17 @@ Provides-Extra: ai-a2a
 Requires-Dist: a2a-sdk<2,>=1.1; extra == 'ai-a2a'
 Requires-Dist: fasta2a<1,>=0.6; extra == 'ai-a2a'
 Provides-Extra: ai-anthropic
-Requires-Dist: pydantic-ai-slim[anthropic]<3,>=2; extra == 'ai-anthropic'
+Requires-Dist: pydantic-ai-slim[anthropic]<3,>=2.45; extra == 'ai-anthropic'
 Provides-Extra: ai-bedrock
-Requires-Dist: pydantic-ai-slim[bedrock]<3,>=2; extra == 'ai-bedrock'
+Requires-Dist: pydantic-ai-slim[bedrock]<3,>=2.45; extra == 'ai-bedrock'
 Provides-Extra: ai-harness
 Requires-Dist: pydantic-ai-harness[skills]<1,>=0.28; extra == 'ai-harness'
 Provides-Extra: ai-openai
-Requires-Dist: pydantic-ai-slim[openai]<3,>=2; extra == 'ai-openai'
+Requires-Dist: pydantic-ai-slim[openai]<3,>=2.45; extra == 'ai-openai'
 Provides-Extra: ai-pydantic
-Requires-Dist: pydantic-ai-slim<3,>=2; extra == 'ai-pydantic'
+Requires-Dist: pydantic-ai-slim<3,>=2.45; extra == 'ai-pydantic'
 Provides-Extra: ai-templates
-Requires-Dist: pydantic-ai-slim[spec]<3,>=2; extra == 'ai-templates'
+Requires-Dist: pydantic-ai-slim[spec]<3,>=2.45; extra == 'ai-templates'
 Provides-Extra: ai-typesafe
 Requires-Dist: pydantic-ai-slim[typesafe]<3,>=2.45; extra == 'ai-typesafe'
 Provides-Extra: cache

{loom_kernel-2.15.0 → loom_kernel-2.15.1}/pyproject.toml

@@ -124,16 +124,16 @@ streaming = [
     "opentelemetry-exporter-otlp-proto-grpc>=1.27,<2.0",
 ]
 ai-pydantic = [
-    "pydantic-ai-slim>=2,<3",
+    "pydantic-ai-slim>=2.45,<3",
 ]
 ai-bedrock = [
-    "pydantic-ai-slim[bedrock]>=2,<3",
+    "pydantic-ai-slim[bedrock]>=2.45,<3",
 ]
 ai-openai = [
-    "pydantic-ai-slim[openai]>=2,<3",
+    "pydantic-ai-slim[openai]>=2.45,<3",
 ]
 ai-anthropic = [
-    "pydantic-ai-slim[anthropic]>=2,<3",
+    "pydantic-ai-slim[anthropic]>=2.45,<3",
 ]
 # TypeSafe's Jev: a decision model that fills a typed output from a state, no
 # text. Its model class first shipped in pydantic-ai 2.45.
@@ -144,7 +144,7 @@ ai-typesafe = [
 # the engine compiles a Handlebars template and renders it per request. An
 # artefact whose instructions are literal never reaches the import.
 ai-templates = [
-    "pydantic-ai-slim[spec]>=2,<3",
+    "pydantic-ai-slim[spec]>=2.45,<3",
 ]
 ai-a2a = [
     "fasta2a>=0.6,<1",

{loom_kernel-2.15.0 → loom_kernel-2.15.1}/src/loom/ai/engines/pydantic_ai/_errors.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 from collections.abc import Mapping
 from types import MappingProxyType
 
+from pydantic_ai import exceptions as pydantic_ai_exceptions
 from pydantic_ai.exceptions import (
     CostCalculationFailedWarning,
     CostNotFoundWarning,
@@ -27,6 +28,19 @@ from pydantic_ai.exceptions import (
 
 from loom.ai.errors import AgentRunError, AgentRunErrorCode
 
+_UNMEASURED_SPEND_WARNINGS: tuple[type[Warning], ...] = tuple(
+    warning
+    for warning in (
+        CostNotFoundWarning,
+        CostCalculationFailedWarning,
+        getattr(pydantic_ai_exceptions, "UsageExtractionFailedWarning", None),
+    )
+    if warning is not None
+)
+"""pydantic-ai's bare ``Warning`` subclasses, all of them a spend the run could
+not measure. ``UsageExtractionFailedWarning`` first ships in a pydantic-ai
+release newer than the supported floor, so it is mapped only where it exists."""
+
 _STATUS_CODES: Mapping[int, AgentRunErrorCode] = MappingProxyType(
     {
         401: AgentRunErrorCode.UNAUTHORIZED,
@@ -49,13 +63,12 @@ _EXCEPTION_CODES: Mapping[type[Exception], AgentRunErrorCode] = MappingProxyType
         UnexpectedModelBehavior: AgentRunErrorCode.OUTPUT_SCHEMA_VIOLATION,
         ModelAPIError: AgentRunErrorCode.PROVIDER_UNAVAILABLE,
         TimeoutError: AgentRunErrorCode.RUN_TIMEOUT,
-        # Both subclass ``Warning``, not ``UserWarning``; see "Spend caps" in
+        # They subclass ``Warning``, not ``UserWarning``; see "Spend caps" in
         # docs/ai/artifacts.md for why that makes this mapping load-bearing
         # under ``-W error``. ``test_pydantic_ai_errors.py`` walks every
         # ``pydantic_ai._warnings`` subclass of ``Warning`` that is not a
-        # ``UserWarning`` and fails the day a third one is added here unmapped.
-        CostNotFoundWarning: AgentRunErrorCode.COST_NOT_MEASURABLE,
-        CostCalculationFailedWarning: AgentRunErrorCode.COST_NOT_MEASURABLE,
+        # ``UserWarning`` and fails the day a new one is left unmapped.
+        **dict.fromkeys(_UNMEASURED_SPEND_WARNINGS, AgentRunErrorCode.COST_NOT_MEASURABLE),
     }
 )
 

{loom_kernel-2.15.0 → loom_kernel-2.15.1}/src/loom/ai/engines/pydantic_ai/_limits.py

@@ -15,20 +15,24 @@ model's cost can be permanently unpriceable.
 from __future__ import annotations
 
 import logging
-from dataclasses import dataclass, replace
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import replace
+from decimal import Decimal
 from typing import Any
 
 from genai_prices import calc_price
 from pydantic_ai import RunContext
-from pydantic_ai.capabilities import AbstractCapability
-from pydantic_ai.messages import ModelResponse
-from pydantic_ai.models import ModelRequestContext
-from pydantic_ai.usage import RunUsage, UsageLimits
+from pydantic_ai.messages import ModelMessage, ModelResponse
+from pydantic_ai.models import Model, ModelRequestParameters, StreamedResponse
+from pydantic_ai.models.wrapper import WrapperModel
+from pydantic_ai.settings import ModelSettings
+from pydantic_ai.usage import RequestUsage, RunUsage, UsageLimits
 
 from loom.ai.declarative import PolicySpec
 from loom.ai.pricing import ModelPrice
 
-__all__ = ["ConfiguredPrice", "is_priceable", "usage_limits", "warn_if_model_not_priceable"]
+__all__ = ["PricedModel", "is_priceable", "usage_limits", "warn_if_model_not_priceable"]
 
 _logger = logging.getLogger(__name__)
 
@@ -59,36 +63,58 @@ def usage_limits(policies: PolicySpec) -> UsageLimits:
     )
 
 
-@dataclass
-class ConfiguredPrice(AbstractCapability[Any]):
-    """Price every model response with the deployment's own rates.
+class PricedModel(WrapperModel):
+    """Model whose every response is priced with the deployment's own rates.
 
-    The cost is set before the response joins the run's usage, so the
-    engine's ``cost_limit`` and loom's ``on_unpriced_spend`` both read it,
-    and it replaces whatever genai-prices would have computed.
+    The cost is set on the response the wrapped model returns, before the
+    engine records it in the run's usage, so the engine's ``cost_limit`` and
+    loom's ``on_unpriced_spend`` both read it, whatever the engine version
+    does after the response leaves the model. It replaces any cost the model
+    reported and whatever genai-prices would have computed.
 
     Args:
-        price: Rates of the model the plan is bound to.
+        wrapped: Model built for the plan's binding.
+        price: Rates of that model.
     """
 
-    price: ModelPrice
+    def __init__(self, wrapped: Model, price: ModelPrice) -> None:
+        super().__init__(wrapped)
+        self.price = price
 
-    async def after_model_request(
+    async def request(
         self,
-        ctx: RunContext[Any],
-        *,
-        request_context: ModelRequestContext,
-        response: ModelResponse,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
     ) -> ModelResponse:
-        """Return *response* with its usage priced at :attr:`price`."""
-        usage = response.usage
-        cost = self.price.cost(
+        """Return the wrapped model's response with its usage priced at :attr:`price`."""
+        response = await super().request(messages, model_settings, model_request_parameters)
+        return replace(response, usage=replace(response.usage, cost=self._cost(response.usage)))
+
+    @asynccontextmanager
+    async def request_stream(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+        run_context: RunContext[Any] | None = None,
+    ) -> AsyncIterator[StreamedResponse]:
+        """Yield the wrapped model's stream, its usage priced at :attr:`price` once it closes."""
+        async with super().request_stream(
+            messages, model_settings, model_request_parameters, run_context
+        ) as stream:
+            try:
+                yield stream
+            finally:
+                stream.usage.cost = self._cost(stream.usage)
+
+    def _cost(self, usage: RequestUsage) -> Decimal:
+        return self.price.cost(
             input_tokens=usage.input_tokens,
             output_tokens=usage.output_tokens,
             cache_read_tokens=usage.cache_read_tokens,
             cache_write_tokens=usage.cache_write_tokens,
         )
-        return replace(response, usage=replace(usage, cost=cost))
 
 
 def is_priceable(model_name: str, provider_name: str | None) -> bool:

{loom_kernel-2.15.0 → loom_kernel-2.15.1}/src/loom/ai/engines/pydantic_ai/provider.py

@@ -19,7 +19,6 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, ClassVar
 
 from pydantic_ai import Agent, ModelRetry
-from pydantic_ai.capabilities import AbstractCapability
 from pydantic_ai.models import Model
 
 from loom.ai.abc import AgentEngine, DepsFactory, OutputCheck
@@ -36,7 +35,7 @@ from loom.ai.engines.pydantic_ai._instructions import (
     ensure_templating_available,
 )
 from loom.ai.engines.pydantic_ai._limits import (
-    ConfiguredPrice,
+    PricedModel,
     is_priceable,
     usage_limits,
     warn_if_model_not_priceable,
@@ -164,13 +163,9 @@ class PydanticAIEngineProvider:
         if not isinstance(plan, AgentPlan):
             raise TypeError(f"expected an AgentPlan, got {type(plan).__name__}")
         ensure_templating_available(plan)
-        model = self._resolve_model(plan.inference)
-        if plan.price is None:
-            warn_if_model_not_priceable(
-                model.model_name, _provider_name(model), plan.policies, f"agent '{plan.name}'"
-            )
+        model = _with_price(self._resolve_model(plan.inference), plan)
         toolsets = build_toolsets(plan, container, mcp=self._mcp)
-        capabilities = _with_price(build_capabilities(plan, container), plan)
+        capabilities = build_capabilities(plan, container)
         if not plan.inference.streaming and any(
             capability.has_wrap_run_event_stream for capability in capabilities
         ):
@@ -270,13 +265,14 @@ def _provider_name(model: Model) -> str | None:
     return model.provider.name if model.provider is not None else None
 
 
-def _with_price(
-    capabilities: tuple[AbstractCapability[Any], ...], plan: AgentPlan
-) -> tuple[AbstractCapability[Any], ...]:
-    """Append the plan's configured price, when it declares one, to *capabilities*."""
-    if plan.price is None:
-        return capabilities
-    return (*capabilities, ConfiguredPrice(price=plan.price))
+def _with_price(model: Model, plan: AgentPlan) -> Model:
+    """Price *model* with the plan's configured rates, or warn when it may stay unpriced."""
+    if plan.price is not None:
+        return PricedModel(model, plan.price)
+    warn_if_model_not_priceable(
+        model.model_name, _provider_name(model), plan.policies, f"agent '{plan.name}'"
+    )
+    return model
 
 
 def _register_output_check(agent: Agent[Any, Any], loom_type: LoomType, check: OutputCheck) -> None: