reactifact 0.12.0__tar.gz → 0.14.0__tar.gz

{reactifact-0.12.0/reactifact.egg-info → reactifact-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.12.0
+Version: 0.14.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
@@ -36,6 +36,8 @@ Provides-Extra: pg
 Requires-Dist: psycopg[binary]>=3.2; extra == "pg"
 Provides-Extra: mcp
 Requires-Dist: mcp>=2.2; extra == "mcp"
+Provides-Extra: a2a
+Requires-Dist: a2a-sdk>=1.0; extra == "a2a"
 Provides-Extra: docs
 Requires-Dist: mkdocs>=1.6; extra == "docs"
 Requires-Dist: mkdocs-material>=9.5; extra == "docs"
@@ -46,7 +48,7 @@ Dynamic: license-file
   <img src="docs/img/reactifact-hero.png" alt="reactifact — Agents that react to artifacts, not graphs" width="800">
 </p>
 
-**Event-driven agents for Python developers — tasks wake on typed artifacts, like Celery tasks wake on messages. No graph to draw.**
+**Auditable agents for Python.** Build **knowledge assistants** over docs, spreadsheets and the web — where the path per question isn't a graph you can draw. Every answer is computed, versioned and reproducible — not a string you have to trust.
 
 [![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)
@@ -56,29 +58,15 @@ Dynamic: license-file
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/bzdvdn/reactifact)
 [![Docs](https://img.shields.io/badge/docs-bzdvdn.github.io%2Freactifact-blue)](https://bzdvdn.github.io/reactifact/)
 
-Python developers already know this model from Celery: define a **task**,
-declare what triggers it, let the runtime run it. reactifact applies it to agents — a task
-reacts to a **typed, versioned artifact** appearing in the context, not to a
-queue message you push or a graph edge you draw. The runtime derives what runs
-next from state.
+> **Is:** a Python library (3 core deps) · single-process · typed, versioned artifacts with provenance · deterministic replay · runs offline, no API key
+> **Isn't:** a managed platform · a distributed task queue · a pre-built agent/tool marketplace
 
-| Celery | reactifact |
-| --- | --- |
-| a task | `@produce(Model)` — a unit of work that writes an artifact |
-| `delay()` / `apply_async()` | you don't call it: creating the input artifact **is** the trigger |
-| routing key / queue | `Consume(Type)` — which artifact type wakes the task |
-| chain / group / chord | several `consumes` / `produces`; the runtime derives the order |
-| retries, `acks_late` | guards + `Budget`, an honest `None` instead of a wrong result |
-| result backend | the `Context` — typed, versioned artifacts |
-| worker | `Runtime` |
+A question like *"why did infra costs jump in Q2?"* needs a spreadsheet, a policy doc and a page off the web — and the *next* question needs a different subset. That is not one graph you can draw up front. You declare what artifacts exist and what agents can do with them; the runtime derives the order from state.
 
-Single process today (no broker, no worker pool) — the *model* is Celery-shaped,
-not its distributed runtime.
-
-On top of that model you get something a task queue doesn't: every artifact is
-**versioned with provenance**, so a run is reproducible (`context_hash`) and
-auditable (`audit.report`) for free. The model reasons; the arithmetic stays
-deterministic; every claim carries provenance.
+Every derived artifact then links to what produced it
+(`Answer —supported_by→ Evidence —extracted_from→ Doc`), so *"why did it say
+that?"* is a query, not a guess — and the run is reproducible (`context_hash`)
+and verifiable (`reactifact replay --verify`).
 
 ## On top: a provable answer
 
@@ -130,6 +118,14 @@ print(report_to_markdown(build_report(ctx, answer)))  # hash per artifact + edge
 print(context_hash(ctx))                              # reproducible fingerprint
 ```
 
+## Knowledge assistants, live
+
+The same shape over many sources, not a fixed path — the
+[`knowledge`](examples/knowledge) CLI answers a harder, multi-source question
+(docs + a CSV) with a real computed number and its sources, no LLM key required:
+
+![CLI demo: asking "how much does gpu cost in total?" — the runtime searches docs and a spreadsheet, computes the sum, verifies it, and answers with sources.](docs/img/knowledge-cli-demo.gif)
+
 ![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
@@ -137,6 +133,31 @@ Two agents explore independently on their own forks and merge back automatically
 
 ![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)
 
+<details>
+<summary><strong>If you know Celery…</strong> — the programming model, not its distributed runtime</summary>
+
+Python developers already know this model from Celery: define a **task**,
+declare what triggers it, let the runtime run it. reactifact applies it to
+agents — a task reacts to a **typed, versioned artifact** appearing in the
+context, not to a queue message you push or a graph edge you draw. The runtime
+derives what runs next from state.
+
+| Celery | reactifact |
+| --- | --- |
+| a task | `@produce(Model)` — a unit of work that writes an artifact |
+| `delay()` / `apply_async()` | you don't call it: creating the input artifact **is** the trigger |
+| routing key / queue | `Consume(Type)` — which artifact type wakes the task |
+| chain / group / chord | several `consumes` / `produces`; the runtime derives the order |
+| result backend | the `Context` — typed, versioned artifacts |
+| worker | `Runtime` |
+
+**Not inherited:** a broker, a worker pool, `acks_late`/redelivery, cross-process
+exactly-once. reactifact is a library with an in-process runtime — the *model* is
+Celery-shaped, the deployment is not. (Session-backed runs do survive a restart;
+see [Durability & resume](docs/en/durability.md).)
+
+</details>
+
 ```bash
 pip install reactifact
 ```
@@ -203,12 +224,6 @@ print(answer.data.text)                     # "Refunds are available within 14 d
 print("supported_by:", evidence.data.text)  # provenance you can trace, not just a string in a log
 ```
 
-The same idea, live — the [`knowledge`](examples/knowledge) example's CLI answering a
-harder, multi-source question (docs + a CSV) with a real computed number and
-its sources, no LLM key required:
-
-![CLI demo: asking "how much does gpu cost in total?" — the runtime searches docs and a spreadsheet, computes the sum, verifies it, and answers with sources.](docs/img/knowledge-cli-demo.gif)
-
 ## How it works
 
 ```text
@@ -276,13 +291,19 @@ by hand. Run it yourself: `uv run python -m examples.ledger.main`.
 - **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.
+- **Outbox** — outbound side effects as `effects.act(...)` → `PendingAction`, performed once *after* the commit by `Runtime(dispatcher=...)`; safe across replay, retries and merged branches.
 
 ## In the box
 
 - **Deterministic by design** — calculations over structured data, honest `None`
   fallbacks instead of hallucinated answers; the model reasons, never "knows".
 - **Observability** — every run traces agent spans, reads/writes, LLM calls,
-  tokens: SQLite store + web dashboard, exportable to Langfuse/Postgres (async sinks).
+  tokens: SQLite store + web dashboard, exportable to Langfuse/Postgres (async sinks);
+  **correlated logs** (`configure_logging()`, silent until called) carry
+  `run_id`/`session_id`/`agent` on every line.
+- **Lifecycle** — `Budget.max_seconds` is a hard deadline (a hung LLM call is
+  cancelled); `request_stop()`/`ashutdown()` stop at a generation boundary
+  (`RunOutcome.STOPPED`); `active_runs()`/`in_flight` give a readiness view.
 - **MCP, both ways** — call any MCP server's tools as a `Tool`
   (`mcp_stdio_tools`/`mcp_http_tools`), or expose your own `Tool`s and a live
   `Context` as an MCP server (`create_mcp_server`) for Claude Desktop, Claude
@@ -313,7 +334,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,plan_execute,adaptive,ledger}.main`.
+`python -m examples.{reflection,map_reduce,supervisor,summarize,time_travel,plan_execute,adaptive,ledger,outbox}.main`.
 
 Prefer a notebook? [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/bzdvdn/reactifact/blob/master/examples/quickstart.ipynb)
 — `examples/quickstart.ipynb` covers the four `quick` cases (`agent`/`rag`/`tools_agent`/`chat_agent`), offline by default.
@@ -325,8 +346,10 @@ Prefer a notebook? [![Open in Colab](https://colab.research.google.com/assets/co
 - `medic-lab` — hypothesis laboratory: competing hypotheses scored, HITL steering, honest report.
 - `devops` — HITL tool agents + LLM tool router + trace dashboard.
 - `repair` — budget-aware replanning (chat/data in Russian by design).
+- `chat` — minimal offline single-model multi-turn conversation (`Conversation` + bounded `ChatMemory`).
 - `forklab` — deterministic branch & merge: two strategies on their own forks, three-way merge.
 - `ledger` — offline proof of reactive recompute: edit one fact, only its real `Consume`rs re-run.
+- `outbox` — one intent, one send: `effects.act(...)` + `Runtime(dispatcher=...)`, safe across replays, retries and merged branches (§42).
 - `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,plan_execute}` — canonical ports (see [port-matrix](docs/en/port-matrix.md)).
@@ -355,6 +378,14 @@ uv sync --extra dev --extra web
 .venv/bin/ruff check
 ```
 
+## Status & contributing
+
+Active, `0.14.x`, pre-1.0 — the API is stabilizing and `1.0` will freeze it
+(see the [roadmap](docs/roadmap.md)); releases follow
+[Keep a Changelog](CHANGELOG.md). Questions and design discussion live in
+[GitHub Discussions](https://github.com/bzdvdn/reactifact/discussions); a star,
+or a `good first issue`, helps more than you'd think.
+
 ## License
 
 MIT — see [LICENSE](LICENSE).

{reactifact-0.12.0 → reactifact-0.14.0}/README.md

@@ -2,7 +2,7 @@
   <img src="docs/img/reactifact-hero.png" alt="reactifact — Agents that react to artifacts, not graphs" width="800">
 </p>
 
-**Event-driven agents for Python developers — tasks wake on typed artifacts, like Celery tasks wake on messages. No graph to draw.**
+**Auditable agents for Python.** Build **knowledge assistants** over docs, spreadsheets and the web — where the path per question isn't a graph you can draw. Every answer is computed, versioned and reproducible — not a string you have to trust.
 
 [![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)
@@ -12,29 +12,15 @@
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/bzdvdn/reactifact)
 [![Docs](https://img.shields.io/badge/docs-bzdvdn.github.io%2Freactifact-blue)](https://bzdvdn.github.io/reactifact/)
 
-Python developers already know this model from Celery: define a **task**,
-declare what triggers it, let the runtime run it. reactifact applies it to agents — a task
-reacts to a **typed, versioned artifact** appearing in the context, not to a
-queue message you push or a graph edge you draw. The runtime derives what runs
-next from state.
+> **Is:** a Python library (3 core deps) · single-process · typed, versioned artifacts with provenance · deterministic replay · runs offline, no API key
+> **Isn't:** a managed platform · a distributed task queue · a pre-built agent/tool marketplace
 
-| Celery | reactifact |
-| --- | --- |
-| a task | `@produce(Model)` — a unit of work that writes an artifact |
-| `delay()` / `apply_async()` | you don't call it: creating the input artifact **is** the trigger |
-| routing key / queue | `Consume(Type)` — which artifact type wakes the task |
-| chain / group / chord | several `consumes` / `produces`; the runtime derives the order |
-| retries, `acks_late` | guards + `Budget`, an honest `None` instead of a wrong result |
-| result backend | the `Context` — typed, versioned artifacts |
-| worker | `Runtime` |
+A question like *"why did infra costs jump in Q2?"* needs a spreadsheet, a policy doc and a page off the web — and the *next* question needs a different subset. That is not one graph you can draw up front. You declare what artifacts exist and what agents can do with them; the runtime derives the order from state.
 
-Single process today (no broker, no worker pool) — the *model* is Celery-shaped,
-not its distributed runtime.
-
-On top of that model you get something a task queue doesn't: every artifact is
-**versioned with provenance**, so a run is reproducible (`context_hash`) and
-auditable (`audit.report`) for free. The model reasons; the arithmetic stays
-deterministic; every claim carries provenance.
+Every derived artifact then links to what produced it
+(`Answer —supported_by→ Evidence —extracted_from→ Doc`), so *"why did it say
+that?"* is a query, not a guess — and the run is reproducible (`context_hash`)
+and verifiable (`reactifact replay --verify`).
 
 ## On top: a provable answer
 
@@ -86,6 +72,14 @@ print(report_to_markdown(build_report(ctx, answer)))  # hash per artifact + edge
 print(context_hash(ctx))                              # reproducible fingerprint
 ```
 
+## Knowledge assistants, live
+
+The same shape over many sources, not a fixed path — the
+[`knowledge`](examples/knowledge) CLI answers a harder, multi-source question
+(docs + a CSV) with a real computed number and its sources, no LLM key required:
+
+![CLI demo: asking "how much does gpu cost in total?" — the runtime searches docs and a spreadsheet, computes the sum, verifies it, and answers with sources.](docs/img/knowledge-cli-demo.gif)
+
 ![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
@@ -93,6 +87,31 @@ Two agents explore independently on their own forks and merge back automatically
 
 ![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)
 
+<details>
+<summary><strong>If you know Celery…</strong> — the programming model, not its distributed runtime</summary>
+
+Python developers already know this model from Celery: define a **task**,
+declare what triggers it, let the runtime run it. reactifact applies it to
+agents — a task reacts to a **typed, versioned artifact** appearing in the
+context, not to a queue message you push or a graph edge you draw. The runtime
+derives what runs next from state.
+
+| Celery | reactifact |
+| --- | --- |
+| a task | `@produce(Model)` — a unit of work that writes an artifact |
+| `delay()` / `apply_async()` | you don't call it: creating the input artifact **is** the trigger |
+| routing key / queue | `Consume(Type)` — which artifact type wakes the task |
+| chain / group / chord | several `consumes` / `produces`; the runtime derives the order |
+| result backend | the `Context` — typed, versioned artifacts |
+| worker | `Runtime` |
+
+**Not inherited:** a broker, a worker pool, `acks_late`/redelivery, cross-process
+exactly-once. reactifact is a library with an in-process runtime — the *model* is
+Celery-shaped, the deployment is not. (Session-backed runs do survive a restart;
+see [Durability & resume](docs/en/durability.md).)
+
+</details>
+
 ```bash
 pip install reactifact
 ```
@@ -159,12 +178,6 @@ print(answer.data.text)                     # "Refunds are available within 14 d
 print("supported_by:", evidence.data.text)  # provenance you can trace, not just a string in a log
 ```
 
-The same idea, live — the [`knowledge`](examples/knowledge) example's CLI answering a
-harder, multi-source question (docs + a CSV) with a real computed number and
-its sources, no LLM key required:
-
-![CLI demo: asking "how much does gpu cost in total?" — the runtime searches docs and a spreadsheet, computes the sum, verifies it, and answers with sources.](docs/img/knowledge-cli-demo.gif)
-
 ## How it works
 
 ```text
@@ -232,13 +245,19 @@ by hand. Run it yourself: `uv run python -m examples.ledger.main`.
 - **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.
+- **Outbox** — outbound side effects as `effects.act(...)` → `PendingAction`, performed once *after* the commit by `Runtime(dispatcher=...)`; safe across replay, retries and merged branches.
 
 ## In the box
 
 - **Deterministic by design** — calculations over structured data, honest `None`
   fallbacks instead of hallucinated answers; the model reasons, never "knows".
 - **Observability** — every run traces agent spans, reads/writes, LLM calls,
-  tokens: SQLite store + web dashboard, exportable to Langfuse/Postgres (async sinks).
+  tokens: SQLite store + web dashboard, exportable to Langfuse/Postgres (async sinks);
+  **correlated logs** (`configure_logging()`, silent until called) carry
+  `run_id`/`session_id`/`agent` on every line.
+- **Lifecycle** — `Budget.max_seconds` is a hard deadline (a hung LLM call is
+  cancelled); `request_stop()`/`ashutdown()` stop at a generation boundary
+  (`RunOutcome.STOPPED`); `active_runs()`/`in_flight` give a readiness view.
 - **MCP, both ways** — call any MCP server's tools as a `Tool`
   (`mcp_stdio_tools`/`mcp_http_tools`), or expose your own `Tool`s and a live
   `Context` as an MCP server (`create_mcp_server`) for Claude Desktop, Claude
@@ -269,7 +288,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,plan_execute,adaptive,ledger}.main`.
+`python -m examples.{reflection,map_reduce,supervisor,summarize,time_travel,plan_execute,adaptive,ledger,outbox}.main`.
 
 Prefer a notebook? [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/bzdvdn/reactifact/blob/master/examples/quickstart.ipynb)
 — `examples/quickstart.ipynb` covers the four `quick` cases (`agent`/`rag`/`tools_agent`/`chat_agent`), offline by default.
@@ -281,8 +300,10 @@ Prefer a notebook? [![Open in Colab](https://colab.research.google.com/assets/co
 - `medic-lab` — hypothesis laboratory: competing hypotheses scored, HITL steering, honest report.
 - `devops` — HITL tool agents + LLM tool router + trace dashboard.
 - `repair` — budget-aware replanning (chat/data in Russian by design).
+- `chat` — minimal offline single-model multi-turn conversation (`Conversation` + bounded `ChatMemory`).
 - `forklab` — deterministic branch & merge: two strategies on their own forks, three-way merge.
 - `ledger` — offline proof of reactive recompute: edit one fact, only its real `Consume`rs re-run.
+- `outbox` — one intent, one send: `effects.act(...)` + `Runtime(dispatcher=...)`, safe across replays, retries and merged branches (§42).
 - `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,plan_execute}` — canonical ports (see [port-matrix](docs/en/port-matrix.md)).
@@ -311,6 +332,14 @@ uv sync --extra dev --extra web
 .venv/bin/ruff check
 ```
 
+## Status & contributing
+
+Active, `0.14.x`, pre-1.0 — the API is stabilizing and `1.0` will freeze it
+(see the [roadmap](docs/roadmap.md)); releases follow
+[Keep a Changelog](CHANGELOG.md). Questions and design discussion live in
+[GitHub Discussions](https://github.com/bzdvdn/reactifact/discussions); a star,
+or a `good first issue`, helps more than you'd think.
+
 ## License
 
 MIT — see [LICENSE](LICENSE).

{reactifact-0.12.0 → reactifact-0.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactifact"
-version = "0.12.0"
+version = "0.14.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"
@@ -52,6 +52,9 @@ pg = [
 mcp = [
     "mcp>=2.2",
 ]
+a2a = [
+    "a2a-sdk>=1.0",
+]
 docs = [
     "mkdocs>=1.6",
     "mkdocs-material>=9.5",
@@ -81,6 +84,9 @@ pg = [
 mcp = [
     "mcp>=2.2",
 ]
+a2a = [
+    "a2a-sdk>=1.0",
+]
 docs = [
     "mkdocs>=1.6",
     "mkdocs-material>=9.5",
@@ -99,7 +105,7 @@ reactifact = "reactifact.__main__:main"
 packages = { find = { where = ["."], include = ["reactifact*"], exclude = ["examples*", "tests*"] } }
 
 [tool.setuptools.package-data]
-reactifact = ["py.typed"]
+reactifact = ["py.typed", "skills/*/SKILL.md", "skills/*/references/*.md"]
 "reactifact.tracing" = ["templates/*.html", "templates/*.css"]
 
 [tool.pytest.ini_options]
@@ -152,3 +158,9 @@ python_version = "3.11"
 packages = ["reactifact", "examples"]
 strict = true
 warn_unused_ignores = true
+
+# pyright defaults its target to the interpreter it finds, which can resolve
+# below the 3.11 floor this package requires — making `StrEnum`/`datetime.UTC`
+# "unknown import symbol" and cascading into false positives on `RunOutcome`.
+[tool.pyright]
+pythonVersion = "3.11"

{reactifact-0.12.0 → reactifact-0.14.0}/reactifact/__init__.py

@@ -24,12 +24,13 @@ of the names you see by default even though they were always cheap to import
 from .agents import Agent, create_agent
 from .artifacts import Artifact
 from .branching import MergeConflict
-from .budget import Budget, RunOutcome, RunStats
+from .budget import Budget, BudgetTracker, RunOutcome, RunStats
 from .consume import Consume, consume
 from .context import Context, View
 from .effects import Effects, Handle
 from .events import Event, EventType
-from .interrupt import PendingQuestion
+from .interrupt import PendingAction, PendingQuestion
+from .logging import bind, configure_logging, get_logger
 from .patches import Create, Delete, Link, Patch, Relation, Unlink, Update
 from .produce import Produce, ProduceCall, produce
 from .providers import (
@@ -48,13 +49,15 @@ from .runtime import Runtime
 from .session import Session, SessionStore
 from .tools import FunctionTool, Tool, ToolOutput, tool
 from .triggers import Trigger
+from .types import register as register_type
 
-__version__ = "0.12.0"
+__version__ = "0.14.0"
 
 __all__ = [
     "Agent",
     "Artifact",
     "Budget",
+    "BudgetTracker",
     "Consume",
     "Context",
     "Create",
@@ -71,6 +74,7 @@ __all__ = [
     "Message",
     "MergeConflict",
     "Patch",
+    "PendingAction",
     "PendingQuestion",
     "Produce",
     "ProduceCall",
@@ -93,9 +97,13 @@ __all__ = [
     "Unlink",
     "Update",
     "View",
+    "bind",
+    "configure_logging",
     "consume",
     "create_agent",
     "current_request",
+    "get_logger",
     "produce",
+    "register_type",
     "tool",
 ]

reactifact-0.14.0/reactifact/a2a/__init__.py

@@ -0,0 +1,77 @@
+"""A2A (Agent2Agent) integration: call remote agents, or serve reactifact ones.
+
+No extra dependency: the client uses `httpx` (core), the server uses FastAPI
+from the existing `web` extra and imports it lazily — so importing this package
+never needs FastAPI.
+
+- Client (`reactifact.a2a.client`): `A2AClient` (Agent Card + `message/send`,
+  `message/stream`, `tasks/get`, `tasks/cancel`) and `A2AAgentTool`/`a2a_tool`,
+  a reactifact `Tool` that delegates to a remote agent.
+- Server (`reactifact.a2a.server`): `create_a2a_router(agents, ...)` — an Agent
+  Card plus a JSON-RPC endpoint where a `Task` is a conversation and a HITL
+  `PendingQuestion` maps to `input-required`.
+
+The JSON-RPC binding implements the A2A `0.3` wire shape (camelCase fields,
+`kind`-discriminated parts).
+"""
+
+from __future__ import annotations
+
+from .client import (
+    AGENT_CARD_PATH,
+    LEGACY_AGENT_CARD_PATH,
+    A2AAgentTool,
+    A2AClient,
+    A2AError,
+    a2a_tool,
+)
+from .models import (
+    AgentCapabilities,
+    AgentCard,
+    AgentProvider,
+    AgentSkill,
+    Artifact,
+    ErrorCode,
+    JSONRPCError,
+    JSONRPCRequest,
+    JSONRPCResponse,
+    Message,
+    MessageSendParams,
+    Part,
+    Task,
+    TaskState,
+    TaskStatus,
+    UserMessage,
+)
+from .remote import A2ARemoteProduce, remote_agent
+from .server import create_a2a_router, default_create_message, default_reply
+
+__all__ = [
+    "AGENT_CARD_PATH",
+    "LEGACY_AGENT_CARD_PATH",
+    "A2AAgentTool",
+    "A2AClient",
+    "A2AError",
+    "A2ARemoteProduce",
+    "AgentCapabilities",
+    "AgentCard",
+    "AgentProvider",
+    "AgentSkill",
+    "Artifact",
+    "ErrorCode",
+    "JSONRPCError",
+    "JSONRPCRequest",
+    "JSONRPCResponse",
+    "Message",
+    "MessageSendParams",
+    "Part",
+    "Task",
+    "TaskState",
+    "TaskStatus",
+    "UserMessage",
+    "a2a_tool",
+    "create_a2a_router",
+    "default_create_message",
+    "default_reply",
+    "remote_agent",
+]