agent-learning 0.4.1__tar.gz → 0.4.2__tar.gz

{agent_learning-0.4.1/src/agent_learning.egg-info → agent_learning-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-learning
-Version: 0.4.1
+Version: 0.4.2
 Summary: Native, in-process reinforcement learning SDK for AI agents — in-memory and local-file storage by default.
 Author: Chris Tava
 License: MIT License
@@ -75,7 +75,7 @@ The SDK improves agents without LLM weight fine-tuning. There are no GPU fine-tu
 
 1. The **policy** is a softmax distribution over `N` discrete actions (e.g., "take action A", "take action B", "take action C"). It lives in Python and updates in milliseconds.
 
-2. Each episode is **evaluated** by three AI Evaluation evaluators — `IntentResolutionEvaluator`, `TaskAdherenceEvaluator`, and `TaskCompletionEvaluator` — whose scores are combined into a single scalar reward.
+2. Each episode is **evaluated** on-device by three stdlib scorers for intent resolution, task adherence, and task completion. Their scores are combined into a single scalar reward with no scoring endpoint or environment variables required. Azure AI evaluators remain available as an opt-in.
 
 3. A **REINFORCE-with-baseline** learner updates the policy logits directly from logged episodes. Updates are tiny gradient steps that run on local compute and persist through a pluggable store — in-memory or local files by default, with Azure Cosmos DB optional.
 

{agent_learning-0.4.1 → agent_learning-0.4.2}/PYPI.md

@@ -8,7 +8,7 @@ The SDK improves agents without LLM weight fine-tuning. There are no GPU fine-tu
 
 1. The **policy** is a softmax distribution over `N` discrete actions (e.g., "take action A", "take action B", "take action C"). It lives in Python and updates in milliseconds.
 
-2. Each episode is **evaluated** by three AI Evaluation evaluators — `IntentResolutionEvaluator`, `TaskAdherenceEvaluator`, and `TaskCompletionEvaluator` — whose scores are combined into a single scalar reward.
+2. Each episode is **evaluated** on-device by three stdlib scorers for intent resolution, task adherence, and task completion. Their scores are combined into a single scalar reward with no scoring endpoint or environment variables required. Azure AI evaluators remain available as an opt-in.
 
 3. A **REINFORCE-with-baseline** learner updates the policy logits directly from logged episodes. Updates are tiny gradient steps that run on local compute and persist through a pluggable store — in-memory or local files by default, with Azure Cosmos DB optional.
 

{agent_learning-0.4.1 → agent_learning-0.4.2}/README.md

@@ -1,8 +1,8 @@
 # agent-learning
 
 Native reinforcement learning SDK for AI agents. An in-process
-learner optimizes a small, interpretable policy over discrete agent choices (e.g., "take action A", "take action B", "take action C") using AI Evaluation scores as the reward
-signal.
+learner optimizes a small, interpretable policy over discrete agent choices (e.g., "take action A", "take action B", "take action C") using on-device evaluation scores as the reward
+signal by default.
 
 <p align="center">
    <img src="images/agent-learning-loop.svg" alt="Animated loop: Policy chooses an action, Score evaluates the episode, and Learner updates the policy" width="960" style="max-width:100%; height:auto;" />
@@ -17,9 +17,10 @@ The SDK improves agents without LLM weight fine-tuning. There are no GPU fine-tu
 
    <img src="images/0f85e08d0c47cd01.png" alt="Policy selects one of N discrete actions" width="360" style="max-width:100%; height:auto;" />
 
-2. Each episode is **evaluated** by three AI Evaluation
-   evaluators — `IntentResolutionEvaluator`, `TaskAdherenceEvaluator`,
-   and `TaskCompletionEvaluator` — whose scores are combined into a single scalar reward.
+2. Each episode is **evaluated** locally by three stdlib scorers for intent
+   resolution, task adherence, and task completion. Their scores are combined
+   into one scalar reward. No scoring endpoint or environment variable is
+   required. Configured Azure AI evaluators remain available as an opt-in.
 
    <img src="images/246d112f995b785a.png" alt="Three evaluator scores feed a single scalar reward" width="360" style="max-width:100%; height:auto;" />
 
@@ -54,14 +55,16 @@ agent-learn.exe --help
 Released versions are published to PyPI:
 <https://pypi.org/project/agent-learning/>.
 
+## Functional Testing
+
+A good way to see the SDK in action is to run the
+interactive capture scenario first, followed by the offline batch update:
+
 ```powershell
-py -m pip install agent-learning
-agent-learn.exe --help
+python tests/functional_cli_interactive.py
+python tests/functional_cli_batch.py
 ```
 
-`pip` installs `agent-learn.exe` into the active Python environment's
-`Scripts` directory.
-
 ## Usage
 
 The `agent-learn` CLI provides the current task-learning-loop operations:
@@ -77,11 +80,3 @@ agent-learn score --agent-id <agent_id> [--task-id <task_id>] [--limit <1-500>]
 agent-learn train --agent-id <agent_id> [--task-id <task_id>] [--limit <1-500>] [--start-date <date>] [--end-date <date>] [--skip-scoring]
 agent-learn task-policy --agent-id <agent_id> --task-id <task_id>
 ```
-
-The subprocess-level functional workflow uses an isolated local store. Run the
-interactive capture scenario first, followed by the offline batch update:
-
-```powershell
-python tests/functional_cli_interactive.py
-python tests/functional_cli_batch.py
-```

{agent_learning-0.4.1 → agent_learning-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-learning"
-version = "0.4.1"
+version = "0.4.2"
 description = "Native, in-process reinforcement learning SDK for AI agents — in-memory and local-file storage by default."
 readme = "PYPI.md"
 requires-python = ">=3.10"

{agent_learning-0.4.1 → agent_learning-0.4.2}/src/agent_learning/__init__.py

@@ -7,9 +7,9 @@ native, in-process learner. The SDK is organised into five layers:
   ``Reward``, ``PolicySnapshot``, ...).
 - ``agent_learning.storage``  - pluggable persistence (Cosmos DB,
   local file system, and in-memory).
-- ``agent_learning.metrics``  - score-based metrics that wrap the
-  Azure AI Evaluation evaluators for Intent Resolution, Task
-  Adherence, and Task Completion.
+- ``agent_learning.metrics``  - on-device stdlib metrics by default,
+    with optional Azure AI evaluators for Intent Resolution, Task
+    Adherence, and Task Completion.
 - ``agent_learning.rewards``  - reward shaping + persistence.
 - ``agent_learning.policy``   - discrete softmax bandit policy.
 - ``agent_learning.learners`` - REINFORCE-with-baseline learner.

{agent_learning-0.4.1 → agent_learning-0.4.2}/src/agent_learning/_version.py

@@ -1,3 +1,3 @@
 """Package version."""
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"

{agent_learning-0.4.1 → agent_learning-0.4.2}/src/agent_learning/cli.py

@@ -216,11 +216,11 @@ def _cmd_score(args: argparse.Namespace) -> int:
     )
     scored = 0
     for episode in episodes:
-        existing = store.get_rewards_for_episode(episode.id, args.agent_id)
-        if existing:
+        if runner.has_usable_reward(episode):
             continue
-        runner.score_and_record(episode)
-        scored += 1
+        rewards = runner.score_and_record(episode)
+        if any(reward.source == RewardSource.AGGREGATE for reward in rewards):
+            scored += 1
     print(json.dumps({"episodes_seen": len(episodes), "newly_scored": scored}, indent=2))
     return 0
 

{agent_learning-0.4.1 → agent_learning-0.4.2}/src/agent_learning/learners/reinforce.py

@@ -49,14 +49,14 @@ class ReinforceLearner(Learner):
 
         # Index rewards by episode id - we only consume aggregate rewards
         episode_list = list(episodes)
-        aggregate_rewards: Dict[str, float] = {}
+        aggregate_rewards: Dict[str, Reward] = {}
         for r in rewards:
             if r.source != RewardSource.AGGREGATE:
                 continue
-            # Keep the most recent aggregate per episode (sorted by created_at desc)
+            # Rescoring may append a replacement aggregate. Keep the newest.
             current = aggregate_rewards.get(r.episode_id)
-            if current is None:
-                aggregate_rewards[r.episode_id] = r.value
+            if current is None or r.created_at > current.created_at:
+                aggregate_rewards[r.episode_id] = r
 
         snapshot = policy.snapshot()
         baseline_before = snapshot.baseline
@@ -72,9 +72,10 @@ class ReinforceLearner(Learner):
         for episode in episode_list:
             if episode.action_id is None or episode.action_id not in action_index:
                 continue
-            reward_value = aggregate_rewards.get(episode.id)
-            if reward_value is None:
+            reward = aggregate_rewards.get(episode.id)
+            if reward is None:
                 continue
+            reward_value = reward.value
             advantage = reward_value - baseline_before
 
             # Importance sampling weight when the episode was logged under a

{agent_learning-0.4.1 → agent_learning-0.4.2}/src/agent_learning/metrics/__init__.py

@@ -1,18 +1,19 @@
 """Score-based evaluation metrics for native RL reward shaping.
 
-Each metric is a thin wrapper around an evaluator from
-``azure-ai-evaluation``. The wrapper normalises the raw evaluator score
-into the ``[0, 1]`` range expected by the reward shaper.
+Metrics use on-device stdlib scorers by default. Configured Azure AI
+evaluators remain available for remote LLM scoring.
 """
 
 from .base import MetricEvaluator, MetricRequest
 from .intent_resolution import IntentResolutionMetric
+from .local import LocalScorerMetric
 from .task_adherence import TaskAdherenceMetric
 from .task_completion import TaskCompletionMetric
 from .registry import default_metrics, evaluate_all
 
 __all__ = [
     "IntentResolutionMetric",
+    "LocalScorerMetric",
     "MetricEvaluator",
     "MetricRequest",
     "TaskAdherenceMetric",

{agent_learning-0.4.1 → agent_learning-0.4.2}/src/agent_learning/metrics/base.py

@@ -42,6 +42,14 @@ class MetricRequest:
             system_message=episode.system_message,
             tool_calls=_format_tool_calls(episode),
             tool_definitions=episode.metadata.get("tool_definitions"),
+            extra={
+                "action_id": episode.action_id,
+                "context_features": episode.context_features,
+                "execution_status": episode.execution_status,
+                "expected_outcome": episode.expected_outcome,
+                "metadata": episode.metadata,
+                "result_summary": episode.result_summary,
+            },
         )
 
 

agent_learning-0.4.2/src/agent_learning/metrics/local.py

@@ -0,0 +1,151 @@
+"""Metric adapters for on-device scoring backends."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Sequence
+from typing import Any
+
+from ..scorers.base import Scorer, ScoreResult
+from ..scorers.stdlib._text import tokenize
+from ..types import MetricName, MetricResult
+from .base import MetricEvaluator, MetricRequest
+
+logger = logging.getLogger(__name__)
+
+
+class LocalScorerMetric(MetricEvaluator):
+    """Project a local :class:`Scorer` onto the metric interface."""
+
+    NAME = MetricName.INTENT_RESOLUTION
+
+    def __init__(self, metric: MetricName, scorer: Scorer) -> None:
+        super().__init__(evaluator=scorer)
+        self.NAME = metric
+        self._scorer = scorer
+
+    def _build_evaluator(self) -> Any:  # pragma: no cover - injected in __init__
+        return self._scorer
+
+    def _build_kwargs(self, request: MetricRequest) -> dict[str, Any]:
+        metadata = request.extra.get("metadata")
+        if not isinstance(metadata, dict):
+            metadata = {}
+        context_features = request.extra.get("context_features")
+        if not isinstance(context_features, dict):
+            context_features = {}
+        contract = metadata.get("score_contract") or metadata.get("adherence_contract")
+        if not isinstance(contract, dict):
+            contract = {}
+        expected_tokens = metadata.get("expected_tokens")
+        if not isinstance(expected_tokens, Sequence) or isinstance(
+            expected_tokens, (str, bytes)
+        ):
+            expected_tokens = tokenize(str(request.extra.get("expected_outcome") or ""))
+        return {
+            "query": request.query,
+            "response": request.response,
+            "system_message": request.system_message,
+            "tool_calls": request.tool_calls,
+            "action_id": request.extra.get("action_id"),
+            "phi": context_features.get("phi"),
+            "contract": contract,
+            "expected_tokens": expected_tokens,
+        }
+
+    def _normalize(self, raw: dict[str, Any]) -> float | None:
+        value = raw.get("normalized")
+        return float(value) if value is not None else None
+
+    def evaluate(self, request: MetricRequest) -> MetricResult:
+        if not (request.query and request.response):
+            return MetricResult(
+                metric=self.NAME,
+                score=None,
+                normalized=None,
+                status="skipped",
+                reason="query or response is empty",
+                evaluator=f"local:{self._scorer.name}",
+            )
+
+        authoritative = self._authoritative_completion(request)
+        if authoritative is not None:
+            value, reason = authoritative
+            return MetricResult(
+                metric=self.NAME,
+                score=value,
+                normalized=value,
+                status="completed",
+                reason=reason,
+                evaluator="local:episode-outcome",
+            )
+
+        try:
+            result = self._scorer.score(**self._build_kwargs(request))
+        except Exception as exc:  # noqa: BLE001  # pragma: no cover
+            logger.warning("Local metric %s failed: %s", self.NAME.value, exc)
+            return MetricResult(
+                metric=self.NAME,
+                score=None,
+                normalized=None,
+                status="skipped",
+                reason=f"local scorer error: {exc}",
+                evaluator=f"local:{self._scorer.name}",
+            )
+        return _to_metric_result(self.NAME, self._scorer.name, result)
+
+    def _authoritative_completion(
+        self, request: MetricRequest
+    ) -> tuple[float, str] | None:
+        if self.NAME != MetricName.TASK_COMPLETION:
+            return None
+        metadata = request.extra.get("metadata")
+        if not isinstance(metadata, dict):
+            metadata = {}
+        action_id = request.extra.get("action_id")
+        correct_action_id = metadata.get("correct_action_id")
+        if action_id and correct_action_id:
+            return (
+                float(action_id == correct_action_id),
+                "derived from action_id and metadata.correct_action_id",
+            )
+        completed = metadata.get("task_completed")
+        if isinstance(completed, bool):
+            return float(completed), "derived from metadata.task_completed"
+        status = str(request.extra.get("execution_status") or "").lower()
+        if status == "completed":
+            return 1.0, "derived from execution_status=completed"
+        if status == "failed":
+            return 0.0, "derived from execution_status=failed"
+        if status == "partial":
+            return 0.5, "derived from execution_status=partial"
+        return None
+
+
+def _to_metric_result(
+    metric: MetricName, scorer_name: str, result: ScoreResult
+) -> MetricResult:
+    normalized = max(0.0, min(1.0, float(result.normalized)))
+    return MetricResult(
+        metric=metric,
+        score=normalized,
+        normalized=normalized,
+        status="completed",
+        reason=f"local {result.label}",
+        properties=dict(result.features),
+        evaluator=f"local:{scorer_name}",
+        metadata={"label": result.label, "confidence": result.confidence},
+    )
+
+
+def local_metrics(scorers: tuple[Scorer, Scorer, Scorer]) -> list[MetricEvaluator]:
+    """Return local metric adapters in reward-shaping order."""
+    intent, adherence, completion = scorers
+    return [
+        LocalScorerMetric(MetricName.INTENT_RESOLUTION, intent),
+        LocalScorerMetric(MetricName.TASK_ADHERENCE, adherence),
+        LocalScorerMetric(MetricName.TASK_COMPLETION, completion),
+    ]
+
+
+__all__ = ["LocalScorerMetric", "local_metrics"]

agent_learning-0.4.2/src/agent_learning/metrics/registry.py

@@ -0,0 +1,59 @@
+"""Convenience helpers to evaluate an episode across all default metrics."""
+
+from __future__ import annotations
+
+from typing import Iterable, List, Optional
+
+from ..config import ScoreConfig, ScoreRuntimeConfig
+from ..scorers import build_scorers
+from ..types import Episode, MetricResult
+from .base import MetricEvaluator, MetricRequest
+from .intent_resolution import IntentResolutionMetric
+from .local import local_metrics
+from .task_adherence import TaskAdherenceMetric
+from .task_completion import TaskCompletionMetric
+
+
+def default_metrics(
+    score_config: Optional[ScoreConfig] = None,
+    score_runtime_config: Optional[ScoreRuntimeConfig] = None,
+) -> List[MetricEvaluator]:
+    """Return local metrics by default, or Azure metrics when configured."""
+    runtime = score_runtime_config or ScoreRuntimeConfig()
+    llm = score_config or runtime.llm
+    if score_config is not None or runtime.tier == "llm" or (
+        runtime.tier is None and llm.enabled
+    ):
+        return [
+            IntentResolutionMetric(llm),
+            TaskAdherenceMetric(llm),
+            TaskCompletionMetric(llm),
+        ]
+    if runtime.tier is None:
+        runtime.tier = "stdlib"
+    return local_metrics(build_scorers(runtime))
+
+
+def evaluate_all(
+    episode: Episode,
+    metrics: Optional[Iterable[MetricEvaluator]] = None,
+    *,
+    score_config: Optional[ScoreConfig] = None,
+    score_runtime_config: Optional[ScoreRuntimeConfig] = None,
+) -> List[MetricResult]:
+    """Evaluate one episode against every supplied metric.
+
+    Each metric is given its own try/except inside :meth:`evaluate`,
+    so a single failing scorer will not prevent the others from
+    producing scores.
+    """
+    metric_list = (
+        list(metrics)
+        if metrics is not None
+        else default_metrics(score_config, score_runtime_config)
+    )
+    request = MetricRequest.from_episode(episode)
+    return [m.evaluate(request) for m in metric_list]
+
+
+__all__ = ["default_metrics", "evaluate_all"]

{agent_learning-0.4.1 → agent_learning-0.4.2}/src/agent_learning/rewards/writer.py

@@ -98,7 +98,10 @@ class RewardWriter:
             except Exception as exc:  # pragma: no cover
                 logger.warning("Failed to persist %s penalty for %s: %s", kind, episode.id, exc)
 
-        # 4) Aggregate reward consumed by the learner
+        # 4) Aggregate reward consumed by the learner. Do not turn an
+        # all-skipped evaluation into a misleading neutral reward.
+        if not shaped.metric_contributions and not shaped.penalties:
+            return stored
         aggregate = Reward(
             episode_id=episode.id,
             agent_id=episode.agent_id,

{agent_learning-0.4.1 → agent_learning-0.4.2}/src/agent_learning/training/runner.py

@@ -19,7 +19,7 @@ import logging
 from datetime import datetime, timezone
 from typing import Dict, Iterable, List, Optional
 
-from ..config import LearnerConfig, ScoreConfig, ShapingConfig
+from ..config import LearnerConfig, ScoreConfig, ScoreRuntimeConfig, ShapingConfig
 from ..learners.base import Learner, LearnerResult
 from ..learners.reinforce import ReinforceLearner
 from ..metrics.base import MetricEvaluator
@@ -47,12 +47,17 @@ class LearningRunner:
         writer: Optional[RewardWriter] = None,
         learner: Optional[Learner] = None,
         score_config: Optional[ScoreConfig] = None,
+        score_runtime_config: Optional[ScoreRuntimeConfig] = None,
         learner_config: Optional[LearnerConfig] = None,
         shaping_config: Optional[ShapingConfig] = None,
     ) -> None:
         self._store = store or get_default_store()
         self._policy = policy
-        self._metrics = list(metrics) if metrics is not None else default_metrics(score_config)
+        self._metrics = (
+            list(metrics)
+            if metrics is not None
+            else default_metrics(score_config, score_runtime_config)
+        )
         self._shaper = shaper or RewardShaper(shaping_config)
         self._writer = writer or RewardWriter(self._store)
         self._learner = learner or ReinforceLearner(learner_config)
@@ -137,6 +142,19 @@ class LearningRunner:
     # Helpers
     # ------------------------------------------------------------------
 
+    def has_usable_reward(self, episode: Episode) -> bool:
+        """Return whether an episode has an aggregate backed by valid metrics."""
+        rewards = self._store.get_rewards_for_episode(episode.id, episode.agent_id)
+        if not any(reward.source.value == "aggregate" for reward in rewards):
+            return False
+        metrics = self._store.get_metric_results(episode.id, episode.agent_id)
+        if not metrics:
+            return True
+        return any(
+            result.status == "completed" and result.normalized is not None
+            for result in metrics
+        )
+
     def _collect_rewards(
         self,
         agent_id: str,
@@ -147,7 +165,7 @@ class LearningRunner:
         rewards: List[Reward] = []
         for episode in episodes:
             existing = self._store.get_rewards_for_episode(episode.id, agent_id)
-            if existing:
+            if self.has_usable_reward(episode):
                 rewards.extend(existing)
                 continue
             if not score_missing:

{agent_learning-0.4.1 → agent_learning-0.4.2/src/agent_learning.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-learning
-Version: 0.4.1
+Version: 0.4.2
 Summary: Native, in-process reinforcement learning SDK for AI agents — in-memory and local-file storage by default.
 Author: Chris Tava
 License: MIT License
@@ -75,7 +75,7 @@ The SDK improves agents without LLM weight fine-tuning. There are no GPU fine-tu
 
 1. The **policy** is a softmax distribution over `N` discrete actions (e.g., "take action A", "take action B", "take action C"). It lives in Python and updates in milliseconds.
 
-2. Each episode is **evaluated** by three AI Evaluation evaluators — `IntentResolutionEvaluator`, `TaskAdherenceEvaluator`, and `TaskCompletionEvaluator` — whose scores are combined into a single scalar reward.
+2. Each episode is **evaluated** on-device by three stdlib scorers for intent resolution, task adherence, and task completion. Their scores are combined into a single scalar reward with no scoring endpoint or environment variables required. Azure AI evaluators remain available as an opt-in.
 
 3. A **REINFORCE-with-baseline** learner updates the policy logits directly from logged episodes. Updates are tiny gradient steps that run on local compute and persist through a pluggable store — in-memory or local files by default, with Azure Cosmos DB optional.
 

{agent_learning-0.4.1 → agent_learning-0.4.2}/src/agent_learning.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ src/agent_learning/learners/reinforce.py
 src/agent_learning/metrics/__init__.py
 src/agent_learning/metrics/base.py
 src/agent_learning/metrics/intent_resolution.py
+src/agent_learning/metrics/local.py
 src/agent_learning/metrics/registry.py
 src/agent_learning/metrics/task_adherence.py
 src/agent_learning/metrics/task_completion.py
@@ -79,6 +80,7 @@ tests/test_contextual_policy.py
 tests/test_default_store.py
 tests/test_end_to_end.py
 tests/test_learner.py
+tests/test_metrics_local.py
 tests/test_policy.py
 tests/test_scorers.py
 tests/test_scorers_llm.py

{agent_learning-0.4.1 → agent_learning-0.4.2}/tests/test_cli.py

@@ -167,6 +167,96 @@ def test_task_episode_register_persists_full_episode(
     assert episode.is_full
 
 
+def test_score_uses_local_stdlib_without_configuration(
+    monkeypatch, capsys
+) -> None:
+    for name in (
+        "AGENT_LEARNING_SCORE_ENDPOINT",
+        "AGENT_LEARNING_SCORE_DEPLOYMENT",
+        "AGENT_LEARNING_SCORE_TIER",
+    ):
+        monkeypatch.delenv(name, raising=False)
+    store = InMemoryStore()
+    monkeypatch.setattr(cli, "get_default_store", lambda: store)
+    episode = Episode(
+        agent_id="scout",
+        task_id="context-window",
+        user_input="What is the context window?",
+        assistant_output="The context window is 922,000 tokens.",
+        intent_summary="Report the context window",
+        action_id="inspect_context",
+        expected_outcome="Return the live context limit",
+        execution_status="completed",
+        result_summary="Returned the live limit",
+        metadata={
+            "correct_action_id": "inspect_context",
+            "task_completed": True,
+        },
+    )
+    store.store_episode(episode)
+
+    assert cli.main(["score", "--agent-id", "scout"]) == 0
+    result = json.loads(capsys.readouterr().out)
+    assert result == {"episodes_seen": 1, "newly_scored": 1}
+    metrics = store.get_metric_results(episode.id, episode.agent_id)
+    assert len(metrics) == 3
+    assert all(metric.status == "completed" for metric in metrics)
+    assert all((metric.evaluator or "").startswith("local:") for metric in metrics)
+    rewards = store.get_rewards_for_episode(episode.id, episode.agent_id)
+    aggregate = next(reward for reward in rewards if reward.source == RewardSource.AGGREGATE)
+    assert aggregate.value > 0.0
+
+
+def test_score_replaces_skipped_only_evaluation(monkeypatch, capsys) -> None:
+    store = InMemoryStore()
+    monkeypatch.setattr(cli, "get_default_store", lambda: store)
+    episode = Episode(
+        agent_id="scout",
+        task_id="context-window",
+        user_input="What is the context window?",
+        assistant_output="The context window is 922,000 tokens.",
+        action_id="inspect_context",
+        execution_status="completed",
+        metadata={"task_completed": True},
+    )
+    store.store_episode(episode)
+    store.store_metric_results(
+        episode.id,
+        episode.agent_id,
+        [
+            MetricResult(
+                metric=metric,
+                score=None,
+                normalized=None,
+                status="skipped",
+                reason="remote scorer was not configured",
+            )
+            for metric in MetricName
+        ],
+    )
+    store.store_reward(
+        Reward(
+            episode_id=episode.id,
+            agent_id=episode.agent_id,
+            source=RewardSource.AGGREGATE,
+            value=0.0,
+            created_at="2026-08-09T00:00:00+00:00",
+        )
+    )
+
+    assert cli.main(["score", "--agent-id", "scout"]) == 0
+    assert json.loads(capsys.readouterr().out)["newly_scored"] == 1
+    metrics = store.get_metric_results(episode.id, episode.agent_id)
+    assert sum(metric.status == "completed" for metric in metrics) == 3
+    aggregates = [
+        reward
+        for reward in store.get_rewards_for_episode(episode.id, episode.agent_id)
+        if reward.source == RewardSource.AGGREGATE
+    ]
+    assert len(aggregates) == 2
+    assert max(aggregates, key=lambda reward: reward.created_at).value > 0.0
+
+
 def test_agent_training_uses_one_limit_and_preserves_task_policy_history(
     monkeypatch, capsys
 ) -> None:

{agent_learning-0.4.1 → agent_learning-0.4.2}/tests/test_learner.py

@@ -89,3 +89,30 @@ def test_unknown_action_is_skipped() -> None:
     ]
     result = learner.update(policy, [ep], rewards)
     assert result.episodes_used == 0
+
+
+def test_most_recent_aggregate_reward_wins() -> None:
+    policy = SoftmaxPolicy.from_actions([Action(id="a"), Action(id="b")])
+    learner = ReinforceLearner(LearnerConfig(learning_rate=0.5, entropy_bonus=0.0))
+    episode = _make_episode("default", "a")
+    rewards = [
+        Reward(
+            episode_id=episode.id,
+            agent_id=episode.agent_id,
+            source=RewardSource.AGGREGATE,
+            value=0.0,
+            created_at="2026-08-09T00:00:00+00:00",
+        ),
+        Reward(
+            episode_id=episode.id,
+            agent_id=episode.agent_id,
+            source=RewardSource.AGGREGATE,
+            value=0.8,
+            created_at="2026-08-09T00:00:01+00:00",
+        ),
+    ]
+
+    result = learner.update(policy, [episode], rewards)
+
+    assert result.mean_reward == 0.8
+    assert policy.snapshot().logits["a"] > 0.0

agent_learning-0.4.2/tests/test_metrics_local.py

@@ -0,0 +1,60 @@
+"""Tests for default on-device metric routing."""
+
+from __future__ import annotations
+
+from agent_learning.config import ScoreConfig
+from agent_learning.metrics import (
+    IntentResolutionMetric,
+    LocalScorerMetric,
+    default_metrics,
+    evaluate_all,
+)
+from agent_learning.types import Episode, MetricName
+
+
+def test_default_metrics_are_local_without_azure_configuration(monkeypatch) -> None:
+    for name in (
+        "AGENT_LEARNING_SCORE_ENDPOINT",
+        "AGENT_LEARNING_SCORE_DEPLOYMENT",
+        "AGENT_LEARNING_SCORE_TIER",
+    ):
+        monkeypatch.delenv(name, raising=False)
+
+    metrics = default_metrics()
+
+    assert len(metrics) == 3
+    assert all(isinstance(metric, LocalScorerMetric) for metric in metrics)
+
+
+def test_explicit_score_config_preserves_azure_metrics() -> None:
+    metrics = default_metrics(
+        ScoreConfig(
+            azure_endpoint="https://example.openai.azure.com",
+            azure_deployment="grader",
+            credential_mode="none",
+        )
+    )
+
+    assert isinstance(metrics[0], IntentResolutionMetric)
+
+
+def test_correct_action_id_overrides_contradictory_completion_flag(
+    monkeypatch,
+) -> None:
+    monkeypatch.delenv("AGENT_LEARNING_SCORE_ENDPOINT", raising=False)
+    monkeypatch.delenv("AGENT_LEARNING_SCORE_DEPLOYMENT", raising=False)
+    episode = Episode(
+        user_input="Answer the task",
+        assistant_output="Used the wrong action",
+        action_id="wrong",
+        execution_status="completed",
+        metadata={"correct_action_id": "right", "task_completed": True},
+    )
+
+    results = evaluate_all(episode)
+
+    completion = next(
+        result for result in results if result.metric == MetricName.TASK_COMPLETION
+    )
+    assert completion.normalized == 0.0
+    assert completion.reason == "derived from action_id and metadata.correct_action_id"

{agent_learning-0.4.1 → agent_learning-0.4.2}/tests/test_shaping.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 from agent_learning.config import ShapingConfig
+from agent_learning.rewards import RewardWriter
 from agent_learning.rewards.shaping import RewardShaper
-from agent_learning.types import MetricName, MetricResult
+from agent_learning.storage import InMemoryStore
+from agent_learning.types import Episode, MetricName, MetricResult, RewardSource
 
 
 def _result(metric: MetricName, normalized: float) -> MetricResult:
@@ -71,6 +73,26 @@ def test_skipped_metrics_are_ignored() -> None:
     assert abs(shaped.value - 0.7) < 1e-9
 
 
+def test_all_skipped_metrics_do_not_persist_aggregate() -> None:
+    store = InMemoryStore()
+    episode = Episode(agent_id="scout")
+    results = [
+        MetricResult(
+            metric=metric,
+            score=None,
+            normalized=None,
+            status="skipped",
+        )
+        for metric in MetricName
+    ]
+    shaped = RewardShaper().shape(results)
+
+    rewards = RewardWriter(store).write(episode, results, shaped)
+
+    assert not any(reward.source == RewardSource.AGGREGATE for reward in rewards)
+    assert store.get_rewards_for_episode(episode.id, episode.agent_id) == []
+
+
 def test_latency_penalty_applied() -> None:
     cfg = ShapingConfig(
         intent_resolution_weight=0.0,

agent_learning-0.4.1/src/agent_learning/metrics/registry.py

@@ -1,42 +0,0 @@
-"""Convenience helpers to evaluate an episode across all default metrics."""
-
-from __future__ import annotations
-
-from typing import Iterable, List, Optional
-
-from ..config import ScoreConfig
-from ..types import Episode, MetricResult
-from .base import MetricEvaluator, MetricRequest
-from .intent_resolution import IntentResolutionMetric
-from .task_adherence import TaskAdherenceMetric
-from .task_completion import TaskCompletionMetric
-
-
-def default_metrics(score_config: Optional[ScoreConfig] = None) -> List[MetricEvaluator]:
-    """Return the three native metrics wired with the same score config."""
-    cfg = score_config or ScoreConfig()
-    return [
-        IntentResolutionMetric(cfg),
-        TaskAdherenceMetric(cfg),
-        TaskCompletionMetric(cfg),
-    ]
-
-
-def evaluate_all(
-    episode: Episode,
-    metrics: Optional[Iterable[MetricEvaluator]] = None,
-    *,
-    score_config: Optional[ScoreConfig] = None,
-) -> List[MetricResult]:
-    """Evaluate one episode against every supplied metric.
-
-    Each metric is given its own try/except inside :meth:`evaluate`,
-    so a single failing scorer will not prevent the others from
-    producing scores.
-    """
-    metric_list = list(metrics) if metrics is not None else default_metrics(score_config)
-    request = MetricRequest.from_episode(episode)
-    return [m.evaluate(request) for m in metric_list]
-
-
-__all__ = ["default_metrics", "evaluate_all"]