matrx-ai 0.5.330__tar.gz → 0.5.332__tar.gz

{matrx_ai-0.5.330 → matrx_ai-0.5.332}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: matrx-ai
-Version: 0.5.330
+Version: 0.5.332
 Summary: Unified multi-provider AI client, orchestration, and tool system
 Project-URL: Homepage, https://github.com/AI-Matrix-Engine/aidream-current
 Project-URL: Repository, https://github.com/AI-Matrix-Engine/aidream-current
@@ -31,13 +31,13 @@ Requires-Dist: google-genai>=1.75.0
 Requires-Dist: groq>=1.2.0
 Requires-Dist: httpx
 Requires-Dist: json-repair
-Requires-Dist: matrx-assignment>=0.1.20
-Requires-Dist: matrx-connect>=0.1.109
-Requires-Dist: matrx-files>=0.2.170
-Requires-Dist: matrx-graph>=0.2.169
-Requires-Dist: matrx-runtime>=0.0.103
-Requires-Dist: matrx-scraper[browser]>=0.2.216
-Requires-Dist: matrx-utils>=2.0.42
+Requires-Dist: matrx-assignment>=0.1.21
+Requires-Dist: matrx-connect>=0.1.110
+Requires-Dist: matrx-files>=0.2.172
+Requires-Dist: matrx-graph>=0.2.170
+Requires-Dist: matrx-runtime>=0.0.104
+Requires-Dist: matrx-scraper[browser]>=0.2.218
+Requires-Dist: matrx-utils>=2.0.43
 Requires-Dist: numpy>=2.0
 Requires-Dist: openai>=2.35.1
 Requires-Dist: pathspec>=1.0.0

{matrx_ai-0.5.330 → matrx_ai-0.5.332}/matrx_ai/graph_nodes/FEATURE.md

@@ -231,6 +231,11 @@ told the step "stopped partway through". Guards:
 
 ## Change log
 
+- 2026-09-16 — An unbound `workflow.step_intelligence` step now records only
+  `mandate_holder_unbound`: the generic resolver does not also file
+  `mandate_resolution_failed`, because the step continues on its authored
+  configuration rather than refusing the run.
+
 - 2026-09-15 — A strict-JSON call made directly by a graph action still resolves
   `workflow.step_intelligence` when its ambient context is `workflow_run`.
   The generic funnel does not stamp that mandate for non-workflow callers.

{matrx_ai-0.5.330 → matrx_ai-0.5.332}/matrx_ai/graph_nodes/mandates.py

@@ -192,7 +192,9 @@ async def hold_step(
     agent = None
     try:
         resolution = await resolve_mandate_by_key(
-            WORKFLOW_STEP_INTELLIGENCE_MANDATE, consumer=consumer
+            WORKFLOW_STEP_INTELLIGENCE_MANDATE,
+            consumer=consumer,
+            report_failure=False,
         )
         if resolution.holder_type != "agent" or resolution.source is None:
             raise MandateResolutionUnavailable(

{matrx_ai-0.5.330 → matrx_ai-0.5.332}/matrx_ai/mandates.py

@@ -251,7 +251,12 @@ def _capture_user_input(value: Any) -> str | None:
     return json.dumps(value, ensure_ascii=False, default=str)
 
 
-async def resolve_mandate_by_key(mandate_key: str, *, consumer: str) -> MandateResolution:
+async def resolve_mandate_by_key(
+    mandate_key: str,
+    *,
+    consumer: str,
+    report_failure: bool = True,
+) -> MandateResolution:
     """Ask the host WHICH agent a mandate KEY points at, or refuse.
 
     THE one resolution door. Two kinds of consumer arrive here and both must
@@ -274,6 +279,11 @@ async def resolve_mandate_by_key(mandate_key: str, *, consumer: str) -> MandateR
 
     Raises :class:`MandateResolutionUnavailable` when no resolver is installed or
     the resolver fails. It NEVER answers from an id frozen in code.
+
+    ``report_failure`` is false only for a consumer that deliberately absorbs an
+    unfulfilled mandate and emits its own truthful durable finding.  That avoids
+    filing a second ``mandate_resolution_failed`` row which falsely says the run
+    was refused after the consumer completed it on its authored configuration.
     """
     if not mandate_key:
         raise MandateResolutionUnavailable("<none>", consumer, "no mandate_key was given")
@@ -288,7 +298,8 @@ async def resolve_mandate_by_key(mandate_key: str, *, consumer: str) -> MandateR
     try:
         resolution = await _MANDATE_RESOLVER(mandate_key)
     except Exception as exc:
-        await _report_resolution_failure(mandate_key=mandate_key, consumer=consumer, exc=exc)
+        if report_failure:
+            await _report_resolution_failure(mandate_key=mandate_key, consumer=consumer, exc=exc)
         raise MandateResolutionUnavailable(
             mandate_key,
             consumer,

{matrx_ai-0.5.330 → matrx_ai-0.5.332}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "matrx-ai"
-version = "0.5.330"
+version = "0.5.332"
 description = "Unified multi-provider AI client, orchestration, and tool system"
 readme = "README.md"
 license = { text = "MIT" }
@@ -65,22 +65,22 @@ dependencies = [
     "asyncpg>=0.31.0",
     # --- Matrx ecosystem ---
     # media/media_persistence.py imports VisibilityLiteral, first exported by 2.0.7.
-    "matrx-utils>=2.0.42",
-    "matrx-files>=0.2.170",
+    "matrx-utils>=2.0.43",
+    "matrx-files>=0.2.172",
     # 0.1.26+ exports the Masterwork* event models used here (renamed 2026-08-17;
     # the next matrx-connect release is the first tag that exports the new names).
-    "matrx-connect>=0.1.109",
+    "matrx-connect>=0.1.110",
     # actions.register_node is imported at module scope and first shipped in 0.1.22.
-    "matrx-graph>=0.2.169",
+    "matrx-graph>=0.2.170",
     # tools.implementations imports the browser implementation eagerly.
-    "matrx-scraper[browser]>=0.2.216",
+    "matrx-scraper[browser]>=0.2.218",
     # matrx-runtime (the Request Management Layer): the conversation executor
     # (orchestrator/conversation_runtime.py) is a CONSUMER of its ExecutionEngine —
     # one conversation = one global_execution. ai → runtime is the acyclic edge.
-    "matrx-runtime>=0.0.103",
+    "matrx-runtime>=0.0.104",
     # Payload-agnostic coordinated assignment planner/coordinator. The agent
     # workflow action consumes it; the assignment package never imports AI.
-    "matrx-assignment>=0.1.20",
+    "matrx-assignment>=0.1.21",
     # --- Virtual Filesystem (matrx_ai.tools.vfs) ---
     "fsspec>=2026.4.0",
     "wcmatch>=10.0",

{matrx_ai-0.5.330 → matrx_ai-0.5.332}/tests/test_control_token_persistence.py

@@ -20,6 +20,13 @@ from typing import Any
 from uuid import uuid4
 
 import pytest
+from aidream.services.ai_execution.ai_task_blocks import BlockStreamingEmitter
+from aidream.services.runtime.workflow_events import EventRecordingEmitter
+from matrx_connect.emitters.control_tokens import (
+    CONTROL_TOKEN_REGISTRY,
+    ControlTokenRegistry,
+    ControlTokenSpec,
+)
 
 import matrx_ai.orchestrator.executor as executor_mod
 from matrx_ai.config import MessageList, TextContent, UnifiedConfig, UnifiedMessage
@@ -31,11 +38,6 @@ from matrx_ai.db.control_tokens import (
 )
 from matrx_ai.orchestrator.execution_state import ExecutionState
 from matrx_ai.orchestrator.requests import AIMatrixRequest, CompletedRequest
-from matrx_connect.emitters.control_tokens import (
-    CONTROL_TOKEN_REGISTRY,
-    ControlTokenRegistry,
-    ControlTokenSpec,
-)
 
 CONVERSATION_ID = "11111111-1111-1111-1111-111111111111"
 USER_ID = "22222222-2222-2222-2222-222222222222"
@@ -317,6 +319,49 @@ async def test_completed_turn_persists_clean_text_plus_metadata(persist_harness,
     ], "the value must survive as structured metadata — cleaning is not discarding"
 
 
+@pytest.mark.asyncio
+async def test_event_recording_block_stream_replays_token_at_completed_persistence(
+    persist_harness, declared
+):
+    """The detached event recorder has no live token channel, but its explicit
+    terminal persistence path retains the value in the resulting row.
+    """
+
+    class _WorkflowBlockSink:
+        accepts_render_blocks = True
+
+        async def send_chunk(self, _text: str) -> None:
+            return None
+
+        async def send_render_block(self, _data: dict[str, Any]) -> None:
+            return None
+
+    persistence_mod, creates, _updates = persist_harness
+    raw = "We are nearly there.\nWRAP_RATING: 4\n"
+    event_recorder = EventRecordingEmitter(base=_WorkflowBlockSink(), run_id="run-1")
+    block_emitter = BlockStreamingEmitter(
+        event_recorder, terminal_control_token_replay=True
+    )
+
+    await block_emitter.send_chunk(raw)
+    await block_emitter.finalize_blocks()
+    assert "WRAP_RATING" not in block_emitter.get_turn_text()
+
+    await persistence_mod.persist_completed_request(
+        _completed_turn("how ready are we?", raw),
+        conversation_id=CONVERSATION_ID,
+        state=ExecutionState(),
+    )
+
+    assistant_rows = [c for c in creates if c.get("role") == "assistant"]
+    assert len(assistant_rows) == 1
+    row = assistant_rows[0]
+    assert "WRAP_RATING" not in _row_text(row)
+    assert row["metadata"][CONTROL_TOKEN_METADATA_KEY] == [
+        {"name": "WRAP_RATING", "value": "4", "declared_by": WRAP_RATING.declared_by}
+    ]
+
+
 @pytest.mark.asyncio
 async def test_a_persons_own_words_are_never_cleaned(persist_harness, declared):
     persistence_mod, creates, _updates = persist_harness

{matrx_ai-0.5.330 → matrx_ai-0.5.332}/tests/test_workflow_step_holder.py

@@ -149,6 +149,26 @@ async def test_resolver_failure_runs_and_screams(monkeypatch) -> None:
     assert "no Holder at any rung" in held.metadata[MANDATE_UNHELD_METADATA_KEY]["detail"]
 
 
+@pytest.mark.asyncio
+async def test_absorbed_resolution_failure_files_only_the_unheld_finding(monkeypatch) -> None:
+    """A seedless workflow step runs, so it must not also claim it refused."""
+    rows: list[dict[str, Any]] = []
+
+    def _record_error(error, **fields):
+        rows.append({"error": str(error), **fields})
+        return None
+
+    from matrx_ai import _ext
+
+    monkeypatch.setitem(_ext._registry, "record_error", _record_error)
+    _install(RuntimeError("no Holder at any rung"), monkeypatch)
+
+    held = await hold_step(dict(STEP), spec_type="ai.llm", consumer="ai.llm.chat")
+
+    assert held.config["model"] == "author-model"
+    assert [row["kind"] for row in rows] == [MANDATE_HOLDER_UNBOUND_KIND]
+
+
 @pytest.mark.asyncio
 async def test_step_resolves_the_mandate_and_stamps_the_holder(monkeypatch) -> None:
     asked = _install(MandateResolution(source=_Source()), monkeypatch)