reactifact 0.15.1__tar.gz → 0.15.2__tar.gz

{reactifact-0.15.1/reactifact.egg-info → reactifact-0.15.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.15.1
+Version: 0.15.2
 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
@@ -380,7 +380,7 @@ uv sync --extra dev --extra web
 
 ## Status & contributing
 
-Active, `0.14.x`, pre-1.0 — the API is stabilizing and `1.0` will freeze it
+Active, `0.15.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,

{reactifact-0.15.1 → reactifact-0.15.2}/README.md

@@ -334,7 +334,7 @@ uv sync --extra dev --extra web
 
 ## Status & contributing
 
-Active, `0.14.x`, pre-1.0 — the API is stabilizing and `1.0` will freeze it
+Active, `0.15.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,

{reactifact-0.15.1 → reactifact-0.15.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactifact"
-version = "0.15.1"
+version = "0.15.2"
 description = "Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context"
 readme = "README.md"
 requires-python = ">=3.11"

{reactifact-0.15.1 → reactifact-0.15.2}/reactifact/__init__.py

@@ -51,7 +51,7 @@ from .tools import FunctionTool, Tool, ToolOutput, tool
 from .triggers import Trigger
 from .types import register as register_type
 
-__version__ = "0.15.1"
+__version__ = "0.15.2"
 
 __all__ = [
     "Agent",

{reactifact-0.15.1 → reactifact-0.15.2}/reactifact/agents.py

@@ -1,17 +1,42 @@
 from __future__ import annotations
 
+import time
 from abc import ABC
 from collections.abc import Sequence
+from contextvars import ContextVar, Token
 from typing import Any
 
 from .artifacts import Artifact
 from .consume import Consume
 from .context import Context
+from .effects import current_effects
 from .events import Event, EventType
 from .patches import Patch
 from .produce import Produce, ProduceCall
 from .triggers import Trigger
 
+#: Per-task log of the produces that ran for the current agent execution:
+#: ``(produce_class_name, operations_authored, latency_ms)``. ``Runtime._execute``
+#: opens it (and later records the span), ``Agent.execute`` appends — a
+#: contextvar so concurrent executions sharing one ``Agent`` instance never race.
+_produce_runs: ContextVar[list[tuple[str, int, float]] | None] = ContextVar(
+    "reactifact_produce_runs", default=None
+)
+
+
+def begin_produce_runs() -> Token[Any]:
+    """Opens the per-task produce-run log (see ``_produce_runs``)."""
+    return _produce_runs.set([])
+
+
+def produce_runs() -> list[tuple[str, int, float]]:
+    """The produce runs recorded for the current task (empty if none)."""
+    return _produce_runs.get() or []
+
+
+def end_produce_runs(token: Token[Any]) -> None:
+    _produce_runs.reset(token)
+
 
 class Agent(ABC):  # noqa: B024 — interface without abstract methods, run() has a default
     """Base container: consumes some artifacts and produces others.
@@ -154,14 +179,30 @@ class Agent(ABC):  # noqa: B024 — interface without abstract methods, run() ha
         if not self.produces:
             return None
         inputs = self._collect_inputs(context)
+        slot = current_effects()
+        log = _produce_runs.get()
         for p in self.produces:
             runs, trigger = self._resolve_produce_call(p, event, context)
             if not runs:
                 continue
+            before = len(slot.operations) if slot is not None else 0
+            started = time.monotonic()
             call = ProduceCall(
                 context=context, inputs=inputs, event=event, trigger=trigger
             )
-            await p.produce(call)
+            try:
+                await p.produce(call)
+            finally:
+                # Record the produce even when it raises — a failing produce is
+                # exactly what a trace should show (the span is then the error
+                # span, with this produce's partial operations/latency).
+                if log is not None:
+                    operations = (
+                        len(slot.operations) if slot is not None else 0
+                    ) - before
+                    log.append(
+                        (p.name, operations, (time.monotonic() - started) * 1000)
+                    )
         return None
 
     @staticmethod

{reactifact-0.15.1 → reactifact-0.15.2}/reactifact/produce.py

@@ -266,6 +266,37 @@ class Produce(Generic[TOut]):
         """
         return None
 
+    #: Explicit display name (set by e.g. tool-use produces); when unset,
+    #: `name` derives a readable one from the class/function/artifact type.
+    _name: str | None = None
+
+    @property
+    def name(self) -> str:
+        """A human-readable name for traces/logs.
+
+        Subclass-style produces use their class name; an ``@produce``-decorated
+        function uses the wrapped function's name; a bare ``Produce(Model)``
+        (declared only to widen an agent's allowed ``Create`` types) falls back
+        to its output artifact type — otherwise every such no-op would show up
+        as a generic ``Produce``. An explicit ``name`` (e.g. a tool-use produce's)
+        always wins.
+        """
+        explicit = getattr(self, "_name", None)
+        if explicit:
+            return str(explicit)
+        cls = type(self).__name__
+        if cls not in ("Produce", "_FunctionProduce"):
+            return cls
+        func = getattr(self, "_func", None)
+        if func is not None:
+            return str(getattr(func, "__name__", cls))
+        artifact = getattr(self.artifact_type, "__name__", "")
+        return f"Produce[{artifact}]" if artifact else cls
+
+    @name.setter
+    def name(self, value: str) -> None:
+        self._name = value
+
     def _apply_result(self, result: Any) -> None:
         """Writes a `@produce`-decorated function's return-style result into
         the effect slot (§24).
@@ -319,6 +350,8 @@ def produce(
             )
 
         class _FunctionProduce(Produce[Any]):
+            _func: Callable[[ProduceCall], Any]
+
             async def produce(self, call: ProduceCall) -> None:
                 result = func(call)
                 if asyncio.iscoroutine(result):
@@ -329,6 +362,8 @@ def produce(
         instance = _FunctionProduce(
             artifact_type=artifact_type, also_creates=also_creates, reacts_to=reacts_to
         )
+        # Keep the function for `Produce.name` (a readable trace/log label).
+        instance._func = func
         return instance
 
     return decorator

{reactifact-0.15.1 → reactifact-0.15.2}/reactifact/runtime.py

@@ -7,7 +7,7 @@ from collections.abc import AsyncIterator, Awaitable, Callable, Mapping
 from dataclasses import dataclass
 from typing import Any, Literal, cast
 
-from .agents import Agent
+from .agents import Agent, begin_produce_runs, end_produce_runs, produce_runs
 from .artifacts import Artifact
 from .budget import Budget, BudgetLLM, BudgetTracker, RunOutcome, RunStats
 from .commit import Commit, Read, Write
@@ -31,9 +31,17 @@ logger = get_logger(__name__)
 #: A scheduled patch with its trigger reads and (optional) trace span.
 PatchWork = tuple[Patch, Agent, list[Read], AgentSpan | None]
 #: One agent execution result: patch (if any), the agent/event/reads that
-#: produced it, latency, and the exception if the produce raised and
-#: `isolate_errors` was set.
-AgentResult = tuple[Patch | None, Agent, Event, list[Read], float, BaseException | None]
+#: produced it, latency, the exception if the produce raised and
+#: `isolate_errors` was set, and the produces that ran (name/ops/latency).
+AgentResult = tuple[
+    Patch | None,
+    Agent,
+    Event,
+    list[Read],
+    float,
+    BaseException | None,
+    list[tuple[str, int, float]],
+]
 #: Performs one committed `PendingAction` (outbox). Called by the runtime after
 #: the intent is committed; the app performs the real I/O and returns (or
 #: raises). Must be idempotent on `idempotency_key` (§42).
@@ -650,18 +658,22 @@ class Runtime:
         """
         patches_to_apply: list[PatchWork] = []
         runs = 0
-        for patch, agent, event, reads, latency, error in results:
+        for patch, agent, event, reads, latency, error, produce_run_list in results:
             if self._budget_exhausted():
                 break
             runs += 1
             self._runs_used += 1
             if error is not None:
                 self._errors_used += 1
-                self._trace.record_span(agent, event, reads, latency, error=error)
+                self._trace.record_span(
+                    agent, event, reads, latency, error=error, produces=produce_run_list
+                )
                 continue
             if patch is None or patch.is_empty():
                 continue
-            span = self._trace.record_span(agent, event, reads, latency)
+            span = self._trace.record_span(
+                agent, event, reads, latency, produces=produce_run_list
+            )
             self._validate_patch_types(patch, agent)
             self._enforce_authorization(patch)
             patch = self._apply_guardrails(patch)
@@ -794,6 +806,7 @@ class Runtime:
         task = asyncio.current_task()
         self._trace.register_task(task, agent.name)
         effects_token = set_effects(Effects(self.context))
+        produce_runs_token = begin_produce_runs()
         slot: Effects | None = None
         patch: Patch | None = None
         error: BaseException | None = None
@@ -817,6 +830,8 @@ class Runtime:
                 if self.on_agent_error is not None:
                     self.on_agent_error(agent, event, exc)
         finally:
+            runs = produce_runs()
+            end_produce_runs(produce_runs_token)
             reset_effects(effects_token)
             self._trace.unregister_task(task)
         latency = (time.monotonic() - started) * 1000
@@ -829,7 +844,7 @@ class Runtime:
                     "error": repr(error),
                 },
             )
-            return None, agent, event, reads, latency, error
+            return None, agent, event, reads, latency, error, runs
         logger.debug(
             "agent finished",
             extra={"agent": agent.name, "latency_ms": round(latency, 2)},
@@ -843,7 +858,7 @@ class Runtime:
                 combined.merge(patch)
             combined.merge(slot.to_patch())
             patch = combined
-        return patch, agent, event, reads, latency, None
+        return patch, agent, event, reads, latency, None, runs
 
     async def arun(
         self,

{reactifact-0.15.1 → reactifact-0.15.2}/reactifact/tracing/__init__.py

@@ -11,6 +11,7 @@ from .models import (
     AgentSpan,
     ArtifactRef,
     LLMCall,
+    ProduceRun,
     RelationRef,
     RunTrace,
     Tag,
@@ -35,6 +36,7 @@ __all__ = [
     "LangfuseTracer",
     "OTLPTracer",
     "PostgresStore",
+    "ProduceRun",
     "RecordingLLM",
     "RelationRef",
     "RunTrace",

{reactifact-0.15.1 → reactifact-0.15.2}/reactifact/tracing/langfuse.py

@@ -96,6 +96,11 @@ class LangfuseTracer(Tracer):
             )
             span_start = span.started_at or run_start
             agent_span_id = _span_id(f"{trace_id}:span:{i}:{span.agent}")
+            spans.extend(
+                self._produce_spans(
+                    trace_id, agent_span_id, trace_attrs, run_start, i, span
+                )
+            )
             for j, call in enumerate(span.llm_calls):
                 spans.append(
                     self._llm_span(
@@ -145,8 +150,29 @@ class LangfuseTracer(Tracer):
                 _type_summary(span.writes),
             ),
         ]
+        if span.event_artifact_type:
+            attrs.append(
+                _attr(
+                    "langfuse.observation.metadata.event_artifact_type",
+                    span.event_artifact_type,
+                )
+            )
         if span.error:
             attrs.append(_attr("langfuse.observation.metadata.error", span.error))
+        if span.produces:
+            attrs.append(
+                _attr(
+                    "langfuse.observation.metadata.produces",
+                    [
+                        {
+                            "name": p.name,
+                            "operations": p.operations,
+                            "latency_ms": p.latency_ms,
+                        }
+                        for p in span.produces
+                    ],
+                )
+            )
         return {
             "traceId": trace_id,
             "spanId": _span_id(f"{trace_id}:span:{index}:{span.agent}"),
@@ -158,6 +184,53 @@ class LangfuseTracer(Tracer):
             "attributes": attrs,
         }
 
+    def _produce_spans(
+        self,
+        trace_id: str,
+        parent_span_id: str,
+        trace_attrs: list[dict[str, Any]],
+        run_start: datetime,
+        span_index: int,
+        span: AgentSpan,
+    ) -> list[dict[str, Any]]:
+        """One child observation per produce the agent ran, so Langfuse's
+        waterfall shows the ``Consume → Produce`` steps instead of a single
+        opaque agent span.
+
+        Produces run sequentially within an agent, so they are laid out
+        back-to-back from the span start by each one's measured latency.
+        """
+        if not span.produces:
+            return []
+        cursor = span.started_at or run_start
+        out: list[dict[str, Any]] = []
+        for k, produce in enumerate(span.produces):
+            end = cursor + timedelta(milliseconds=produce.latency_ms)
+            out.append(
+                {
+                    "traceId": trace_id,
+                    "spanId": _span_id(
+                        f"{trace_id}:produce:{span_index}:{k}:{produce.name}"
+                    ),
+                    "parentSpanId": parent_span_id,
+                    "name": produce.name,
+                    "kind": 1,
+                    "startTimeUnixNano": _unix_nanos(cursor),
+                    "endTimeUnixNano": _unix_nanos(end),
+                    "attributes": [
+                        *trace_attrs,
+                        _attr("langfuse.observation.type", "span"),
+                        _attr("langfuse.observation.metadata.agent", span.agent),
+                        _attr(
+                            "langfuse.observation.metadata.operations",
+                            produce.operations,
+                        ),
+                    ],
+                }
+            )
+            cursor = end
+        return out
+
     def _llm_span(
         self,
         trace_id: str,

{reactifact-0.15.1 → reactifact-0.15.2}/reactifact/tracing/models.py

@@ -88,11 +88,31 @@ class TagAssignment(BaseModel):
     updated_at: datetime | None = None
 
 
+class ProduceRun(BaseModel):
+    """One produce execution within an agent span (§54).
+
+    An agent runs one or more ``Produce``s per event; the span records which
+    ones actually ran and how much each contributed (``operations`` = authored
+    effect operations, so the produce that did the work is distinguishable from
+    one that merely matched the event).
+    """
+
+    name: str
+    operations: int = 0
+    latency_ms: float = 0.0
+
+
 class AgentSpan(BaseModel):
     """A single agent execution within a run (§54)."""
 
     agent: str
     event_type: str = ""
+    #: The artifact type whose change triggered this agent (its matched
+    #: ``Consume``) — e.g. ``DraftAnswer`` vs ``FinalResponse`` for an agent that
+    #: consumes both. ``event_type`` alone (created/updated) can't tell them apart.
+    event_artifact_type: str = ""
+    #: The produces that ran for this event, in execution order.
+    produces: list[ProduceRun] = Field(default_factory=list)
     reads: list[ArtifactRef] = Field(default_factory=list)
     writes: list[ArtifactRef] = Field(default_factory=list)
     relations: list[RelationRef] = Field(default_factory=list)

{reactifact-0.15.1 → reactifact-0.15.2}/reactifact/tracing/otlp.py

@@ -123,8 +123,19 @@ class OTLPTracer(Tracer):
             attr("reactifact.reads", type_summary(span.reads)),
             attr("reactifact.writes", type_summary(span.writes)),
         ]
+        if span.event_artifact_type:
+            attrs.append(
+                attr("reactifact.event_artifact_type", span.event_artifact_type)
+            )
         if span.error:
             attrs.append(attr("error.type", span.error))
+        if span.produces:
+            attrs.append(
+                attr(
+                    "reactifact.produces",
+                    ", ".join(f"{p.name}({p.operations})" for p in span.produces),
+                )
+            )
         return {
             "traceId": tid,
             "spanId": span_id(f"{tid}:span:{index}:{span.agent}"),

{reactifact-0.15.1 → reactifact-0.15.2}/reactifact/tracing/postgres.py

@@ -27,6 +27,7 @@ from .models import (
     AgentSpan,
     ArtifactRef,
     LLMCall,
+    ProduceRun,
     RelationRef,
     RunTrace,
     TagAssignment,
@@ -70,13 +71,15 @@ class PostgresStore:
                         run_id TEXT NOT NULL REFERENCES runs(id),
                         agent TEXT NOT NULL,
                         event_type TEXT NOT NULL DEFAULT '',
+                        event_artifact_type TEXT NOT NULL DEFAULT '',
                         latency_ms REAL NOT NULL DEFAULT 0,
                         error TEXT,
                         started_at TIMESTAMPTZ,
                         reads JSONB NOT NULL DEFAULT '[]',
                         writes JSONB NOT NULL DEFAULT '[]',
                         relations JSONB NOT NULL DEFAULT '[]',
-                        llm_calls JSONB NOT NULL DEFAULT '[]'
+                        llm_calls JSONB NOT NULL DEFAULT '[]',
+                        produces JSONB NOT NULL DEFAULT '[]'
                     )
                     """
                 )
@@ -122,6 +125,14 @@ class PostgresStore:
                 await cur.execute(
                     "ALTER TABLE spans ADD COLUMN IF NOT EXISTS started_at TIMESTAMPTZ"
                 )
+                await cur.execute(
+                    "ALTER TABLE spans ADD COLUMN IF NOT EXISTS "
+                    "produces JSONB NOT NULL DEFAULT '[]'"
+                )
+                await cur.execute(
+                    "ALTER TABLE spans ADD COLUMN IF NOT EXISTS "
+                    "event_artifact_type TEXT NOT NULL DEFAULT ''"
+                )
             await conn.commit()
         finally:
             await conn.close()
@@ -159,13 +170,15 @@ class PostgresStore:
                     if span_started is not None and span_started.tzinfo is None:
                         span_started = span_started.replace(tzinfo=UTC)
                     await cur.execute(
-                        "INSERT INTO spans (run_id, agent, event_type, latency_ms, error, "
-                        "started_at, reads, writes, relations, llm_calls) "
-                        "VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)",
+                        "INSERT INTO spans (run_id, agent, event_type, event_artifact_type, "
+                        "latency_ms, error, started_at, reads, writes, relations, llm_calls, "
+                        "produces) "
+                        "VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)",
                         (
                             trace.id,
                             span.agent,
                             span.event_type,
+                            span.event_artifact_type,
                             span.latency_ms,
                             span.error,
                             span_started,
@@ -181,6 +194,9 @@ class PostgresStore:
                             psycopg.types.json.Jsonb(
                                 [c.model_dump(mode="json") for c in span.llm_calls]
                             ),
+                            psycopg.types.json.Jsonb(
+                                [p.model_dump(mode="json") for p in span.produces]
+                            ),
                         ),
                     )
             await conn.commit()
@@ -387,8 +403,8 @@ class PostgresStore:
                 if row is None:
                     return None
                 await cur.execute(
-                    "SELECT agent, event_type, latency_ms, error, started_at, "
-                    "reads, writes, relations, llm_calls "
+                    "SELECT agent, event_type, event_artifact_type, latency_ms, error, "
+                    "started_at, reads, writes, relations, llm_calls, produces "
                     "FROM spans WHERE run_id = %s ORDER BY id",
                     (trace_id,),
                 )
@@ -408,13 +424,15 @@ class PostgresStore:
             AgentSpan(
                 agent=r[0],
                 event_type=r[1],
-                latency_ms=r[2],
-                error=r[3],
-                started_at=r[4],
-                reads=[ArtifactRef(**d) for d in r[5]],
-                writes=[ArtifactRef(**d) for d in r[6]],
-                relations=[RelationRef(**d) for d in r[7]],
-                llm_calls=[LLMCall(**d) for d in r[8]],
+                event_artifact_type=r[2],
+                latency_ms=r[3],
+                error=r[4],
+                started_at=r[5],
+                reads=[ArtifactRef(**d) for d in r[6]],
+                writes=[ArtifactRef(**d) for d in r[7]],
+                relations=[RelationRef(**d) for d in r[8]],
+                llm_calls=[LLMCall(**d) for d in r[9]],
+                produces=[ProduceRun(**d) for d in r[10]],
             )
             for r in span_rows
         ]

{reactifact-0.15.1 → reactifact-0.15.2}/reactifact/tracing/store.py

@@ -30,6 +30,7 @@ from .models import (
     AgentSpan,
     ArtifactRef,
     LLMCall,
+    ProduceRun,
     RelationRef,
     RunTrace,
     TagAssignment,
@@ -174,13 +175,15 @@ class TraceStore:
                 run_id TEXT NOT NULL REFERENCES runs(id),
                 agent TEXT NOT NULL,
                 event_type TEXT NOT NULL DEFAULT '',
+                event_artifact_type TEXT NOT NULL DEFAULT '',
                 latency_ms REAL NOT NULL DEFAULT 0,
                 error TEXT,
                 started_at REAL,
                 reads TEXT NOT NULL DEFAULT '[]',
                 writes TEXT NOT NULL DEFAULT '[]',
                 relations TEXT NOT NULL DEFAULT '[]',
-                llm_calls TEXT NOT NULL DEFAULT '[]'
+                llm_calls TEXT NOT NULL DEFAULT '[]',
+                produces TEXT NOT NULL DEFAULT '[]'
             );
             CREATE TABLE IF NOT EXISTS tags (
                 name TEXT PRIMARY KEY,
@@ -218,6 +221,14 @@ class TraceStore:
             )
         if "started_at" not in cols:
             self._conn.execute("ALTER TABLE spans ADD COLUMN started_at REAL")
+        if "produces" not in cols:
+            self._conn.execute(
+                "ALTER TABLE spans ADD COLUMN produces TEXT NOT NULL DEFAULT '[]'"
+            )
+        if "event_artifact_type" not in cols:
+            self._conn.execute(
+                "ALTER TABLE spans ADD COLUMN event_artifact_type TEXT NOT NULL DEFAULT ''"
+            )
         run_cols = {row[1] for row in self._conn.execute("PRAGMA table_info(runs)")}
         if "prompt_tokens" not in run_cols:
             self._conn.execute(
@@ -328,13 +339,15 @@ class TraceStore:
         )
         for span in trace.spans:
             self._conn.execute(
-                "INSERT INTO spans (run_id, agent, event_type, latency_ms, error, "
-                "started_at, reads, writes, relations, llm_calls) "
-                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                "INSERT INTO spans (run_id, agent, event_type, event_artifact_type, "
+                "latency_ms, error, started_at, reads, writes, relations, llm_calls, "
+                "produces) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
                 (
                     trace.id,
                     span.agent,
                     span.event_type,
+                    span.event_artifact_type,
                     span.latency_ms,
                     span.error,
                     span.started_at.timestamp() if span.started_at else None,
@@ -342,6 +355,7 @@ class TraceStore:
                     json.dumps([w.model_dump(mode="json") for w in span.writes]),
                     json.dumps([r.model_dump(mode="json") for r in span.relations]),
                     json.dumps([c.model_dump(mode="json") for c in span.llm_calls]),
+                    json.dumps([p.model_dump(mode="json") for p in span.produces]),
                 ),
             )
         self._conn.commit()
@@ -595,8 +609,8 @@ class TraceStore:
         if row is None:
             return None
         span_rows = self._conn.execute(
-            "SELECT agent, event_type, latency_ms, error, started_at, "
-            "reads, writes, relations, llm_calls "
+            "SELECT agent, event_type, event_artifact_type, latency_ms, error, started_at, "
+            "reads, writes, relations, llm_calls, produces "
             "FROM spans WHERE run_id = ? ORDER BY id",
             (trace_id,),
         ).fetchall()
@@ -604,15 +618,17 @@ class TraceStore:
             AgentSpan(
                 agent=r[0],
                 event_type=r[1],
-                latency_ms=r[2],
-                error=r[3],
+                event_artifact_type=r[2],
+                latency_ms=r[3],
+                error=r[4],
                 started_at=(
-                    datetime.fromtimestamp(r[4], tz=UTC) if r[4] is not None else None
+                    datetime.fromtimestamp(r[5], tz=UTC) if r[5] is not None else None
                 ),
-                reads=[ArtifactRef(**d) for d in json.loads(r[5])],
-                writes=[ArtifactRef(**d) for d in json.loads(r[6])],
-                relations=[RelationRef(**d) for d in json.loads(r[7])],
-                llm_calls=[LLMCall(**d) for d in json.loads(r[8])],
+                reads=[ArtifactRef(**d) for d in json.loads(r[6])],
+                writes=[ArtifactRef(**d) for d in json.loads(r[7])],
+                relations=[RelationRef(**d) for d in json.loads(r[8])],
+                llm_calls=[LLMCall(**d) for d in json.loads(r[9])],
+                produces=[ProduceRun(**d) for d in json.loads(r[10])],
             )
             for r in span_rows
         ]

{reactifact-0.15.1 → reactifact-0.15.2}/reactifact/tracing/templates/app.css

@@ -258,11 +258,22 @@ tbody tr.row.selected td{background:var(--accent-soft);}
 details.agent{border:1px solid var(--border);border-radius:var(--r-md);background:var(--panel);overflow:hidden;}
 details.agent>summary{display:flex;align-items:center;gap:12px;padding:12px 16px;cursor:pointer;font-size:14px;}
 details.agent>summary:hover{background:var(--hover);}
-.caret{color:var(--muted);transition:transform .15s;} details[open]>.caret,.caret.open{transform:rotate(90deg);}
+.caret{color:var(--muted);transition:transform .15s;} details[open]>summary .caret,.caret.open{transform:rotate(90deg);}
 .agent .muted,.spans-stat{color:var(--muted);font-size:12.5px;font-variant-numeric:tabular-nums;}
 .agent-body{padding:6px 16px 16px;border-top:1px solid var(--border);background:var(--panel-alt);}
 .chips{display:flex;flex-wrap:wrap;gap:6px;margin:10px 0;}
 .chip{display:inline-flex;align-items:center;gap:6px;background:var(--accent-soft);color:var(--accent);border-radius:12px;padding:2px 9px;font-family:var(--mono);font-size:11.5px;}
+.flow{display:inline-flex;align-items:center;gap:7px;min-width:0;flex-wrap:wrap;}
+.flow .c-side{display:inline-flex;align-items:center;gap:5px;min-width:0;}
+.flow .consume{font-family:var(--mono);font-size:11.5px;color:var(--chip-text);background:var(--chip);border-radius:6px;padding:1px 7px;white-space:nowrap;}
+.flow .consume.muted{color:var(--muted);background:transparent;border:1px dashed var(--border-strong);}
+.flow .ev{font-family:var(--mono);font-size:10.5px;color:var(--faint);white-space:nowrap;}
+.flow .arrow{color:var(--muted);font-family:var(--mono);}
+.produces{display:inline-flex;flex-wrap:wrap;gap:5px;min-width:0;}
+.chip.produce{display:inline-flex;align-items:center;gap:6px;font-family:var(--mono);font-size:11.5px;background:var(--ok-soft);color:var(--ok);border-radius:8px;padding:1px 4px 1px 8px;white-space:nowrap;}
+.chip.produce.noop{background:var(--panel-alt);color:var(--muted);border:1px solid var(--border);}
+.chip.produce .ops{background:rgba(21,128,61,.16);color:var(--ok);border-radius:7px;padding:0 6px;font-size:10px;font-variant-numeric:tabular-nums;}
+.chip.produce.noop .ops.zero{background:var(--border);color:var(--faint);}
 .spans{display:flex;flex-direction:column;gap:8px;}
 details.node{border:1px solid var(--border);border-left:3px solid var(--accent);border-radius:var(--r-sm);background:var(--panel);overflow:hidden;}
 details.node summary{display:flex;align-items:center;gap:10px;padding:9px 14px;cursor:pointer;font-size:13px;}