reactifact 0.6.1__tar.gz → 0.7.0__tar.gz

{reactifact-0.6.1/reactifact.egg-info → reactifact-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.6.1
+Version: 0.7.0
 Summary: Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/bzdvdn/reactifact
@@ -8,7 +8,7 @@ Project-URL: Repository, https://github.com/bzdvdn/reactifact
 Project-URL: Documentation, https://github.com/bzdvdn/reactifact/tree/master/docs
 Project-URL: Changelog, https://github.com/bzdvdn/reactifact/blob/master/CHANGELOG.md
 Keywords: agents,llm,ai-agents,reactive,provenance,orchestration,agentic
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -36,14 +36,18 @@ Provides-Extra: mcp
 Requires-Dist: mcp>=2.2; extra == "mcp"
 Dynamic: license-file
 
-# reactifact
+<p align="center">
+  <img src="docs/img/reactifact-hero.png" alt="reactifact — Agents that react to artifacts, not graphs" width="800">
+</p>
 
 **Stop drawing the graph. Build agents as reactions to versioned, provable artifacts.**
 
 [![CI](https://github.com/bzdvdn/reactifact/actions/workflows/ci.yml/badge.svg)](https://github.com/bzdvdn/reactifact/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/bzdvdn/reactifact/graph/badge.svg)](https://codecov.io/gh/bzdvdn/reactifact)
 [![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12-blue)](https://github.com/bzdvdn/reactifact)
 [![PyPI version](https://img.shields.io/pypi/v/reactifact)](https://pypi.org/project/reactifact/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/bzdvdn/reactifact)
 
 Most agent frameworks make you **draw the graph**: connect nodes, wire memory,
 declare control flow. But a knowledge question — *"why did infra costs jump in
@@ -56,6 +60,11 @@ react to events — there is no graph, no node pipeline.
 
 ![Left: a hand-wired fetch → verify → answer pipeline. Right: reactifact — search_agent and answer_agent each declare only what they consume and produce, wired together by Context, never each other.](docs/img/wiring.svg)
 
+Two agents explore independently on their own forks and merge back automatically
+— and when they disagree, reactifact refuses to merge silently:
+
+![forklab demo: two strategies (depth/breadth) investigate on separate forks and merge cleanly; a second run edits the same artifact on both forks and reactifact raises MergeConflict instead of guessing, then re-merges under an explicit policy.](docs/img/forklab-demo.gif)
+
 ```bash
 pip install reactifact
 ```
@@ -157,12 +166,33 @@ actual state.
 | Retries/rollback are manual | Context is **git-like versioned** (diff, rollback, branch, merge) |
 | "Who produced this?" is lost | **Provenance** links every derived artifact to its inputs |
 | The model guesses the numbers | **Calculations are calculated** — the LLM is a reasoning component, not the source of truth |
+| Tracing needs a SaaS add-on | **Native trace store** (SQLite + dashboard), exportable to Langfuse/Postgres |
+| MCP via a framework adapter | **MCP both ways** built in — call any server, or expose your own `Context` as one |
+| Pulls in a framework's dependency tree | **3 core deps**: `pydantic`, `httpx`, `python-dotenv` |
 
 Reactive. Deterministic. Accountable.
 
 Full breakdown, including where reactifact is *not* the right choice:
 [docs/en/comparison.md](docs/en/comparison.md).
 
+**Proof, not a claim** — [`examples/ledger`](examples/ledger) is a 4-artifact
+billing calc (`LaborCost`, `Tax`, `Discount`, `Total`) with no LLM, fully
+offline. Edit *one* fact and see what actually reruns:
+
+```text
+>>> editing ONLY TaxRate (0.08 -> 0.12) — a fact nothing about
+>>> LaborCost or Discount ever consumed.
+
+  LaborCost    value=500.0      version=0   # untouched
+  Tax          value=60.0       version=1   # recomputed
+  Discount     value=25.0       version=0   # untouched
+  Total        value=535.0      version=1   # recomputed
+```
+
+2 of 4 artifacts recompute — the 2 that actually depend on `TaxRate` —
+because `Artifact.version` tracks real consumption, not a graph edge you drew
+by hand. Run it yourself: `uv run python -m examples.ledger.main`.
+
 ## Core primitives
 
 - **Context** — versioned working state, git-like commits, `diff`/`rollback`/`merge`.
@@ -170,7 +200,7 @@ Full breakdown, including where reactifact is *not* the right choice:
 - **Effects** — an agent states its change via `self.effects.create/update/link/ask`; the runtime compiles it.
 - **Patch** — the compiled, validated change-set applied as one atomic commit.
 - **Agent** — a thin container declaring `consumes`/`produces`; logic lives in a `Produce`.
-- **Source** — retrieval is a capability: vector search is *one* strategy; direct API, keyword, SQL, filesystem are equally first-class.
+- **Source** — retrieval is a capability: vector search is *one* strategy, not the only one; filesystem, CSV, and the web are equally first-class today (direct API, keyword, and SQL sources are on the [roadmap](docs/roadmap.md#next), not yet shipped).
 - **Provenance** — every derived artifact links to what produced it
   (`Answer —supported_by→ Claim —derived_from→ Evidence —extracted_from→ Doc`).
 - **HITL** — humans as `effects.ask(...)` → `PendingQuestion`, answered via `effects.resume(...)` like any agent.
@@ -211,7 +241,7 @@ uv run python ./examples/devops/web.py         # HITL ops assistant + trace dash
 ```
 
 Classic-pattern ports run as one-liners too:
-`python -m examples.{reflection,map_reduce,supervisor,summarize,time_travel,adaptive,ledger}.main`.
+`python -m examples.{reflection,map_reduce,supervisor,summarize,time_travel,plan_execute,adaptive,ledger}.main`.
 
 ## Examples (in-repo, not shipped)
 
@@ -224,7 +254,7 @@ Classic-pattern ports run as one-liners too:
 - `ledger` — offline proof of reactive recompute: edit one fact, only its real `Consume`rs re-run.
 - `llm_ladder` — the workflow from one LLM call to state-changing patches (3 levels).
 - `adaptive` — hybrid scheduler: rule filters + deterministic rank + LLM tie-break + `rank_limit`.
-- `{reflection,map_reduce,supervisor,summarize,time_travel}` — canonical ports (see [port-matrix](docs/en/port-matrix.md)).
+- `{reflection,map_reduce,supervisor,summarize,time_travel,plan_execute}` — canonical ports (see [port-matrix](docs/en/port-matrix.md)).
 
 ## Documentation
 
@@ -236,6 +266,7 @@ Classic-pattern ports run as one-liners too:
 - [Comparison](docs/en/comparison.md) — reactifact vs LangGraph/CrewAI, feature by feature, and when *not* to use reactifact.
 - [Tutorial · llm-ladder](docs/en/examples.md#tutorial-ladder) — learn the workflow.
 - [docs/constitution.md](docs/constitution.md) — the full design rationale and invariants.
+- [Roadmap](docs/roadmap.md) — what's next, and what's deliberately out of scope.
 
 ## Development
 

{reactifact-0.6.1 → reactifact-0.7.0}/README.md

@@ -1,11 +1,15 @@
-# reactifact
+<p align="center">
+  <img src="docs/img/reactifact-hero.png" alt="reactifact — Agents that react to artifacts, not graphs" width="800">
+</p>
 
 **Stop drawing the graph. Build agents as reactions to versioned, provable artifacts.**
 
 [![CI](https://github.com/bzdvdn/reactifact/actions/workflows/ci.yml/badge.svg)](https://github.com/bzdvdn/reactifact/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/bzdvdn/reactifact/graph/badge.svg)](https://codecov.io/gh/bzdvdn/reactifact)
 [![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12-blue)](https://github.com/bzdvdn/reactifact)
 [![PyPI version](https://img.shields.io/pypi/v/reactifact)](https://pypi.org/project/reactifact/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/bzdvdn/reactifact)
 
 Most agent frameworks make you **draw the graph**: connect nodes, wire memory,
 declare control flow. But a knowledge question — *"why did infra costs jump in
@@ -18,6 +22,11 @@ react to events — there is no graph, no node pipeline.
 
 ![Left: a hand-wired fetch → verify → answer pipeline. Right: reactifact — search_agent and answer_agent each declare only what they consume and produce, wired together by Context, never each other.](docs/img/wiring.svg)
 
+Two agents explore independently on their own forks and merge back automatically
+— and when they disagree, reactifact refuses to merge silently:
+
+![forklab demo: two strategies (depth/breadth) investigate on separate forks and merge cleanly; a second run edits the same artifact on both forks and reactifact raises MergeConflict instead of guessing, then re-merges under an explicit policy.](docs/img/forklab-demo.gif)
+
 ```bash
 pip install reactifact
 ```
@@ -119,12 +128,33 @@ actual state.
 | Retries/rollback are manual | Context is **git-like versioned** (diff, rollback, branch, merge) |
 | "Who produced this?" is lost | **Provenance** links every derived artifact to its inputs |
 | The model guesses the numbers | **Calculations are calculated** — the LLM is a reasoning component, not the source of truth |
+| Tracing needs a SaaS add-on | **Native trace store** (SQLite + dashboard), exportable to Langfuse/Postgres |
+| MCP via a framework adapter | **MCP both ways** built in — call any server, or expose your own `Context` as one |
+| Pulls in a framework's dependency tree | **3 core deps**: `pydantic`, `httpx`, `python-dotenv` |
 
 Reactive. Deterministic. Accountable.
 
 Full breakdown, including where reactifact is *not* the right choice:
 [docs/en/comparison.md](docs/en/comparison.md).
 
+**Proof, not a claim** — [`examples/ledger`](examples/ledger) is a 4-artifact
+billing calc (`LaborCost`, `Tax`, `Discount`, `Total`) with no LLM, fully
+offline. Edit *one* fact and see what actually reruns:
+
+```text
+>>> editing ONLY TaxRate (0.08 -> 0.12) — a fact nothing about
+>>> LaborCost or Discount ever consumed.
+
+  LaborCost    value=500.0      version=0   # untouched
+  Tax          value=60.0       version=1   # recomputed
+  Discount     value=25.0       version=0   # untouched
+  Total        value=535.0      version=1   # recomputed
+```
+
+2 of 4 artifacts recompute — the 2 that actually depend on `TaxRate` —
+because `Artifact.version` tracks real consumption, not a graph edge you drew
+by hand. Run it yourself: `uv run python -m examples.ledger.main`.
+
 ## Core primitives
 
 - **Context** — versioned working state, git-like commits, `diff`/`rollback`/`merge`.
@@ -132,7 +162,7 @@ Full breakdown, including where reactifact is *not* the right choice:
 - **Effects** — an agent states its change via `self.effects.create/update/link/ask`; the runtime compiles it.
 - **Patch** — the compiled, validated change-set applied as one atomic commit.
 - **Agent** — a thin container declaring `consumes`/`produces`; logic lives in a `Produce`.
-- **Source** — retrieval is a capability: vector search is *one* strategy; direct API, keyword, SQL, filesystem are equally first-class.
+- **Source** — retrieval is a capability: vector search is *one* strategy, not the only one; filesystem, CSV, and the web are equally first-class today (direct API, keyword, and SQL sources are on the [roadmap](docs/roadmap.md#next), not yet shipped).
 - **Provenance** — every derived artifact links to what produced it
   (`Answer —supported_by→ Claim —derived_from→ Evidence —extracted_from→ Doc`).
 - **HITL** — humans as `effects.ask(...)` → `PendingQuestion`, answered via `effects.resume(...)` like any agent.
@@ -173,7 +203,7 @@ uv run python ./examples/devops/web.py         # HITL ops assistant + trace dash
 ```
 
 Classic-pattern ports run as one-liners too:
-`python -m examples.{reflection,map_reduce,supervisor,summarize,time_travel,adaptive,ledger}.main`.
+`python -m examples.{reflection,map_reduce,supervisor,summarize,time_travel,plan_execute,adaptive,ledger}.main`.
 
 ## Examples (in-repo, not shipped)
 
@@ -186,7 +216,7 @@ Classic-pattern ports run as one-liners too:
 - `ledger` — offline proof of reactive recompute: edit one fact, only its real `Consume`rs re-run.
 - `llm_ladder` — the workflow from one LLM call to state-changing patches (3 levels).
 - `adaptive` — hybrid scheduler: rule filters + deterministic rank + LLM tie-break + `rank_limit`.
-- `{reflection,map_reduce,supervisor,summarize,time_travel}` — canonical ports (see [port-matrix](docs/en/port-matrix.md)).
+- `{reflection,map_reduce,supervisor,summarize,time_travel,plan_execute}` — canonical ports (see [port-matrix](docs/en/port-matrix.md)).
 
 ## Documentation
 
@@ -198,6 +228,7 @@ Classic-pattern ports run as one-liners too:
 - [Comparison](docs/en/comparison.md) — reactifact vs LangGraph/CrewAI, feature by feature, and when *not* to use reactifact.
 - [Tutorial · llm-ladder](docs/en/examples.md#tutorial-ladder) — learn the workflow.
 - [docs/constitution.md](docs/constitution.md) — the full design rationale and invariants.
+- [Roadmap](docs/roadmap.md) — what's next, and what's deliberately out of scope.
 
 ## Development
 

{reactifact-0.6.1 → reactifact-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactifact"
-version = "0.6.1"
+version = "0.7.0"
 description = "Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -12,7 +12,7 @@ license = "MIT"
 license-files = ["LICENSE"]
 keywords = ["agents", "llm", "ai-agents", "reactive", "provenance", "orchestration", "agentic"]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
@@ -93,6 +93,15 @@ reactifact = ["py.typed"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 
+# Enforced by CI's `pytest --cov=reactifact --cov-fail-under=85` (see
+# .github/workflows/ci.yml). Current coverage is ~90%; 85% leaves headroom
+# for `reactifact/tracing/postgres.py`, whose own test intentionally only
+# checks the graceful-ImportError path without `psycopg` installed (`pg` is
+# an opt-in extra with no external service in CI) rather than needing a
+# per-file carve-out.
+[tool.coverage.report]
+fail_under = 85
+
 [tool.ruff]
 target-version = "py311"
 line-length = 88

{reactifact-0.6.1 → reactifact-0.7.0}/reactifact/__init__.py

@@ -48,7 +48,7 @@ from .session import Session, SessionStore
 from .tools import FunctionTool, Tool, ToolOutput, tool
 from .triggers import Trigger
 
-__version__ = "0.6.1"
+__version__ = "0.7.0"
 
 __all__ = [
     "Agent",

{reactifact-0.6.1 → reactifact-0.7.0}/reactifact/branching.py

@@ -5,8 +5,12 @@
 git-like state operations `Context.clone()`/`.branch()`/`.merge_from()`/
 `.merge()` delegate to — moved here so the git-like algorithm lives next to
 the concept it implements, not folded into `Context`'s general CRUD/relations/
-HITL surface. `BranchStore` only *persists* named forks so they survive a
-restart:
+HITL surface. Application code should call the `Context` methods (see
+[docs/en/branching.md](../docs/en/branching.md)); these module-level
+functions are exported for building on `Context` without one already in
+hand (e.g. `BranchStore`'s own load/merge path below), not as an equally
+first-class alternative entry point. `BranchStore` only *persists* named
+forks so they survive a restart:
 
     store = BranchStore(SQLiteKVBackend("sessions.sqlite3"))
     await store.save_branch(ctx_branch, session_id="demo", name="hypothesis-a")
@@ -91,13 +95,8 @@ def merge_context_from(target: Context, other: Context) -> None:
                 operations.append(Update(other_id, new_data))
         else:
             new_data = other_artifact.data.model_copy(deep=True)
-            # NOTE: no `id=other_id` — matches the pre-extraction behavior of
-            # `Context.merge_from()` exactly (a merged-in artifact absent from
-            # `target` gets a freshly minted id, not `other_id`). Not fixed
-            # here — a real behavior change belongs in its own change, not a
-            # pure extraction.
-            target.create(new_data)
-            operations.append(Create(new_data))
+            target.create(new_data, id=other_id)
+            operations.append(Create(new_data, id=other_id))
     for rel in other.relations():
         if (rel.source_id, rel.relation, rel.target_id) not in target._relations:
             target.link(rel.source_id, rel.relation, rel.target_id)

{reactifact-0.6.1 → reactifact-0.7.0}/reactifact/effects.py

@@ -128,14 +128,24 @@ class Effects:
     def upsert(self, data: Any, *, id: str) -> Handle:
         """Explicit create-or-refresh: same effect as `create(data, id=id)`.
 
-        Prefer this over `create(..., id=...)` when the artifact may already
-        exist (e.g. a re-derived id like `f"answer:{qid}"`) — it says at the
-        call site that an update is an expected outcome, not a surprise.
+        Purely a call-site name: identical to `create(..., id=...)`, but says
+        at the call site that a refresh is an expected outcome, not a
+        surprise — reach for it when the artifact may already exist (e.g. a
+        re-derived id like `f"answer:{qid}"`).
         """
         return self.create(data, id=id)
 
     def update(self, artifact: Artifact[Any], **fields: Any) -> Effects:
-        """Bumps fields of an *existing* artifact (a new version)."""
+        """Bumps fields of an *existing* artifact (a new version).
+
+        Note the name means something different here than on `Patch.update`/
+        `Context.update`/`Artifact.update` (a full data replacement) — this is
+        the one intentional exception, matching `Patch.update_fields`
+        instead. `Effects` is the everyday authoring surface where "update
+        some fields" is the common case (§18 above), so it gets the short
+        name; the lower-level, less-used `Patch`/`Context`/`Artifact` surface
+        keeps `update` for the operation it's actually named after.
+        """
         new_data = artifact.data.model_copy(update=fields)
         self.operations.append(Update(artifact.id, new_data))
         return self

{reactifact-0.6.1 → reactifact-0.7.0}/reactifact/llm_agent.py

@@ -25,7 +25,7 @@ from .events import Event
 from .interrupt import PendingQuestion
 from .produce import Produce
 from .structured import SYSTEM_STRUCTURED, structured_llm
-from .tool_use import Observation, ToolAnswer, ToolUse, ToolUseHITL
+from .tool_use import DeferredToolGroup, Observation, ToolAnswer, ToolUse, ToolUseHITL
 from .tools import Tool
 
 
@@ -98,6 +98,7 @@ class LLMAgent(Agent):
     max_steps: int = 8
     temperature: float | None = None
     max_tokens: int | None = None
+    deferred_tool_groups: Sequence[DeferredToolGroup] = ()
 
     def __init__(self, *, name: str | None = None, **kwargs: Any):
         llm_name = name or self.name or self.__class__.__name__.lower()
@@ -116,6 +117,7 @@ class LLMAgent(Agent):
                 max_steps=self.max_steps,
                 temperature=self.temperature,
                 max_tokens=self.max_tokens,
+                deferred_tool_groups=self.deferred_tool_groups,
             ),
             Produce(ToolAnswer),
             *user_produces,

{reactifact-0.6.1 → reactifact-0.7.0}/reactifact/mcp/__init__.py

@@ -7,12 +7,15 @@ in the `mcp` SDK.
 from __future__ import annotations
 
 from .client import MCPTool, mcp_http_tools, mcp_stdio_tools, mcp_tools
+from .oauth import InMemoryTokenStorage, oauth_client_credentials
 from .server import create_mcp_server
 
 __all__ = [
+    "InMemoryTokenStorage",
     "MCPTool",
     "create_mcp_server",
     "mcp_http_tools",
     "mcp_stdio_tools",
     "mcp_tools",
+    "oauth_client_credentials",
 ]

{reactifact-0.6.1 → reactifact-0.7.0}/reactifact/mcp/client.py

@@ -7,7 +7,7 @@ the `mcp` extra.
 from __future__ import annotations
 
 from collections.abc import AsyncGenerator
-from contextlib import asynccontextmanager
+from contextlib import AsyncExitStack, asynccontextmanager
 from typing import Any
 
 from .._extras import require_extra
@@ -89,16 +89,45 @@ async def mcp_stdio_tools(
 
 
 @asynccontextmanager
-async def mcp_http_tools(url: str) -> AsyncGenerator[list[Tool], None]:
-    """Connects to an MCP server over streamable HTTP and yields its tools as `Tool`s."""
+async def mcp_http_tools(
+    url: str,
+    *,
+    headers: dict[str, str] | None = None,
+    auth: Any = None,
+) -> AsyncGenerator[list[Tool], None]:
+    """Connects to an MCP server over streamable HTTP and yields its tools as
+    `Tool`s.
+
+    Pass `headers` for servers that require a static credential (e.g.
+    `{"Authorization": "Bearer ..."}`), or `auth` (an `httpx2.Auth`) for a
+    server that requires OAuth — see `reactifact.mcp.oauth_client_credentials`
+    for the machine-to-machine case. The SDK's `streamable_http_client` has
+    no `headers=`/`auth=` kwarg of its own; the documented way is a
+    pre-configured client, which this builds (and owns/closes) with the same
+    recommended timeouts the SDK's own default client uses (30s
+    connect/write/pool, 300s read — a server may hold a response stream
+    open). Note this must be `httpx2.AsyncClient` (the MCP SDK's own httpx
+    fork/dependency, not plain `httpx` — `streamable_http_client` rejects
+    the wrong one at the type level), imported lazily here since it's only
+    guaranteed installed alongside the `mcp` extra.
+    """
     require_extra("mcp_http_tools", "mcp", "mcp")
+    import httpx2
     from mcp.client.streamable_http import streamable_http_client
 
     from mcp import ClientSession
 
-    async with (
-        streamable_http_client(url) as (read, write),
-        ClientSession(read, write) as session,
-    ):
+    async with AsyncExitStack() as stack:
+        http_client = None
+        if headers is not None or auth is not None:
+            http_client = await stack.enter_async_context(
+                httpx2.AsyncClient(
+                    headers=headers, auth=auth, timeout=httpx2.Timeout(30.0, read=300.0)
+                )
+            )
+        read, write = await stack.enter_async_context(
+            streamable_http_client(url, http_client=http_client)
+        )
+        session = await stack.enter_async_context(ClientSession(read, write))
         await session.initialize()
         yield await mcp_tools(session)

reactifact-0.7.0/reactifact/mcp/oauth.py

@@ -0,0 +1,94 @@
+"""OAuth 2.1 for the MCP client: machine-to-machine auth (client_credentials)
+for MCP servers that require it.
+
+Scoped to `client_credentials` only — the flow that needs no browser or
+human consent, which covers an agent authenticating to a server on its own
+behalf. The authorization-code flow (a person granting consent through a
+browser redirect) needs a `redirect_handler`/`callback_handler` wired to
+whatever hosts the app (CLI, a script, a web app), which is host-specific
+plumbing outside a headless library's scope; use
+`mcp.client.auth.OAuthClientProvider` directly if you need it.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from .._extras import require_extra
+
+
+class InMemoryTokenStorage:
+    """The MCP SDK's `TokenStorage` protocol, held in process memory only.
+
+    Tokens (and refreshes) live only as long as this object — nothing is
+    written to disk. Fine for a long-running process reusing one provider
+    across calls; pass your own `TokenStorage` implementation instead if you
+    need tokens to survive a restart.
+    """
+
+    def __init__(self) -> None:
+        self._tokens: Any = None
+        self._client_info: Any = None
+
+    async def get_tokens(self) -> Any:
+        return self._tokens
+
+    async def set_tokens(self, tokens: Any) -> None:
+        self._tokens = tokens
+
+    async def get_client_info(self) -> Any:
+        return self._client_info
+
+    async def set_client_info(self, client_info: Any) -> None:
+        self._client_info = client_info
+
+
+def oauth_client_credentials(
+    server_url: str,
+    *,
+    client_id: str,
+    client_secret: str,
+    issuer: str,
+    scope: str | None = None,
+    token_endpoint_auth_method: Literal[
+        "client_secret_basic", "client_secret_post"
+    ] = "client_secret_basic",
+    storage: Any = None,
+) -> Any:
+    """Builds an `httpx2.Auth` that authenticates to `server_url` via OAuth's
+    `client_credentials` grant — pass it as `auth=` to `mcp_http_tools`.
+
+    `issuer` names the authorization server `client_id`/`client_secret`
+    belong to: the token request is only ever built from that server's
+    discovered metadata, so a compromised or misconfigured MCP server can't
+    redirect the credential exchange elsewhere. Requires the `mcp` extra.
+
+        from reactifact.mcp import mcp_http_tools, oauth_client_credentials
+
+        auth = oauth_client_credentials(
+            "https://mcp.example.com",
+            client_id="...",
+            client_secret="...",
+            issuer="https://auth.example.com",
+        )
+        async with mcp_http_tools("https://mcp.example.com", auth=auth) as tools:
+            ...
+
+    `storage` defaults to a fresh `InMemoryTokenStorage()` (tokens live only
+    for this process) — pass your own `TokenStorage` to persist/reuse tokens
+    across runs.
+    """
+    require_extra("oauth_client_credentials", "mcp", "mcp")
+    from mcp.client.auth.extensions.client_credentials import (
+        ClientCredentialsOAuthProvider,
+    )
+
+    return ClientCredentialsOAuthProvider(
+        server_url,
+        storage=storage if storage is not None else InMemoryTokenStorage(),
+        client_id=client_id,
+        client_secret=client_secret,
+        token_endpoint_auth_method=token_endpoint_auth_method,
+        scope=scope,
+        issuer=issuer,
+    )

{reactifact-0.6.1 → reactifact-0.7.0}/reactifact/produce.py

@@ -13,14 +13,8 @@ for one of these first:
   decorator, both signatures recognized by parameter name — pick this for a
   short, one-off produce with no class ceremony.
 
-Two other things `Produce` accepts are *not* on that list on purpose:
-
-- `Produce(Model, factory=fn)` — a bare two-argument-factory constructor
-  kwarg, **deprecated** (raises `DeprecationWarning`). It predates the
-  `@produce` decorator, only supports `(context, inputs[, event]) -> Model |
-  list | Patch | None`, and can't see the effects slot at all — strictly
-  weaker than `@produce(Model)`, which covers the same signature plus
-  `effects`. Kept only so old code doesn't break; port it to `@produce`.
+One other thing `Produce`/`Agent` accepts is *not* on that list on purpose:
+
 - Overriding `Agent.run(self, event, context) -> Patch | None` directly,
   bypassing `Produce` entirely (though not necessarily `effects` — the
   runtime still merges whatever `current_effects()` collected during the
@@ -36,7 +30,6 @@ from __future__ import annotations
 
 import asyncio
 import inspect
-import warnings
 from collections.abc import Callable
 from typing import Any, Generic, TypeVar, get_args, get_origin
 
@@ -71,43 +64,13 @@ class Produce(Generic[TOut]):
                     return
 
     artifact_type: ArtifactType | None = None
-    factory: Callable[..., Any] | None = None
 
-    def __init__(
-        self,
-        artifact_type: ArtifactType | None = None,
-        factory: Callable[..., Any] | None = None,
-    ):
+    def __init__(self, artifact_type: ArtifactType | None = None):
         self.artifact_type = artifact_type or self.__class__.artifact_type
         if self.artifact_type is None:
             raise ValueError(
                 "artifact_type must be provided either as class attribute or constructor argument"
             )
-        self.factory = factory if factory is not None else self.__class__.factory
-        if self.factory is not None:
-            warnings.warn(
-                "Produce(..., factory=...) is deprecated: it only supports "
-                "(context, inputs[, event]) -> Model | list | Patch | None and "
-                "can't see the effects slot (no `effects` param support). Use "
-                "the @produce(Type) decorator instead — same return-style "
-                "signature, plus optional effects/event params when you need "
-                "them. See the reactifact.produce module docstring.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        self._accepts_event = False
-        if self.factory is not None:
-            try:
-                signature = inspect.signature(self.factory)
-            except (TypeError, ValueError):
-                signature = None
-            if signature is not None:
-                positional = [
-                    p
-                    for p in signature.parameters.values()
-                    if not p.kind & inspect.Parameter.VAR_POSITIONAL
-                ]
-                self._accepts_event = len(positional) >= 3
 
     @property
     def effects(self) -> Effects:
@@ -132,29 +95,22 @@ class Produce(Generic[TOut]):
         inputs: list[Artifact[Any]],
         event: Event | None = None,
     ) -> None:
-        """Runs the factory and writes its effect into the slot (§24).
+        """No-op by default (§24).
 
-        Subclass-style overrides write `self.effects.*` and return None;
-        a `None` return means "no work". (The progress nest the old
-        `Patch | None` return — the runtime compiles the slot now.)
+        Subclass-style overrides write `self.effects.*` and return None; a
+        `None` return means "no work". A bare `Produce(Model)` (no override)
+        is a valid, deliberate no-op — used e.g. to widen an agent's allowed
+        `Create` types when the actual write happens via `self.effects.ask(...)`
+        in another produce (see `examples/supervisor`).
         """
-        if self.factory is None:
-            return None
-
-        if self._accepts_event:
-            result = self.factory(context, inputs, event)
-        else:
-            result = self.factory(context, inputs)
-        if asyncio.iscoroutine(result):
-            result = await result
-
-        self._apply_result(result)
+        return None
 
     def _apply_result(self, result: Any) -> None:
-        """Writes a factory result into the effect slot (§24).
+        """Writes a `@produce`-decorated function's return-style result into
+        the effect slot (§24).
 
-        `None` — nothing; a model or a list of models — creates; a Patch — the
-        factory-level legacy escape (its operations are appended to the effects).
+        `None` — nothing; a model or a list of models — creates; a Patch — a
+        legacy escape (its operations are appended to the effects).
         """
         if result is None:
             return

{reactifact-0.6.1 → reactifact-0.7.0}/reactifact/resources.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from .providers import EmbeddingProvider, LLMProvider
 from .sources import Source
 
+if TYPE_CHECKING:
+    from .budget import Budget
+
 
 class RuntimeResources:
     def __init__(
@@ -18,6 +21,13 @@ class RuntimeResources:
         self.embedder = embedder
         self.sources = sources or {}
         self.additional = additional
+        # Set by Runtime per turn (not a constructor param — the runtime, not
+        # the caller, owns these): the active Budget and its wall-clock
+        # deadline, read back by ToolUse's own inner loop (§ tool_use.py) to
+        # enforce the tool-call/time budget between its own round-trips, not
+        # just at the top-level Runtime._budget_exhausted check.
+        self.budget: Budget | None = None
+        self.budget_deadline: float | None = None
 
     def get_source(self, source_id: str) -> Source | None:
         return self.sources.get(source_id)