#!/usr/bin/env python3 """Causally replay one materialized Morphosis root against a DSV4 endpoint.""" from __future__ import annotations import argparse import asyncio import hashlib import io import json import os import re import sys import tarfile import time import traceback from collections import Counter, defaultdict from dataclasses import dataclass from pathlib import Path, PurePosixPath from typing import Any, Awaitable, Callable TRIE_SRC = Path( os.environ.get( "MORPHOSIS_TRIE_SRC", str(Path(__file__).resolve().parents[1] / "trie" / "src"), ) ) sys.path.insert(0, str(TRIE_SRC)) from trie.client import Client from trie.results import StreamAccumulator from trie.types import Generate, ReplayTrace ROOT_ID_RE = re.compile(r"root-\d{3}-[A-Za-z0-9_.-]+") def atomic_json(path: Path, payload: Any) -> None: temp = path.with_suffix(path.suffix + ".tmp") temp.write_text( json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8", ) os.replace(temp, path) class EventWriter: def __init__(self, path: Path, run_id: str) -> None: self._handle = path.open("w", encoding="utf-8", buffering=1) self._run_id = run_id self._sequence = 0 def emit(self, event: str, **fields: Any) -> None: self._sequence += 1 row = { "schema_version": 1, "event": event, "event_sequence": self._sequence, "run_id": self._run_id, "wall_time_s": time.time(), "monotonic_time_s": time.monotonic(), **fields, } self._handle.write( json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n" ) def close(self) -> None: self._handle.close() @dataclass(frozen=True) class ChildEdge: parent_trace_id: str child_trace_id: str fork_generate_index: int join_generate_index: int child_final_generate_index: int batch_id: str dispatch_index: int join_policy: str @dataclass class RootProgram: root_id: str lead_trace_id: str traces: dict[str, ReplayTrace] edges: list[ChildEdge] manifest: dict[str, Any] profile: dict[str, Any] @dataclass class RequestOutcome: prompt_tokens: int completion_tokens: int cached_tokens: int cached_tokens_details: dict[str, Any] | None latency_s: float ttft_s: float RequestExecutor = Callable[ [ReplayTrace, int, Generate, str, str], Awaitable[RequestOutcome] ] def generate_events(trace: ReplayTrace) -> list[Generate]: return [event for event in trace.events if isinstance(event, Generate)] def _safe_member_name(name: str, root_id: str) -> bool: path = PurePosixPath(name) return ( not path.is_absolute() and ".." not in path.parts and len(path.parts) == 2 and path.parts[0] == root_id and path.parts[1] in {"actors.jsonl", "manifest.json"} ) def load_root_archive(path: Path) -> RootProgram: if not path.name.endswith(".tar.gz"): raise ValueError(f"archive does not end with .tar.gz: {path}") root_id = path.name[: -len(".tar.gz")] if ROOT_ID_RE.fullmatch(root_id) is None: raise ValueError(f"invalid root id: {root_id!r}") with tarfile.open(path, "r:gz") as archive: files = [member for member in archive.getmembers() if member.isfile()] if any(not _safe_member_name(member.name, root_id) for member in files): raise ValueError("archive contains an unexpected or unsafe file") by_name = {member.name: member for member in files} expected = { f"{root_id}/actors.jsonl", f"{root_id}/manifest.json", } if set(by_name) != expected: raise ValueError( f"archive file set differs: got={sorted(by_name)} expected={sorted(expected)}" ) manifest_stream = archive.extractfile(by_name[f"{root_id}/manifest.json"]) actors_stream = archive.extractfile(by_name[f"{root_id}/actors.jsonl"]) if manifest_stream is None or actors_stream is None: raise ValueError("archive member cannot be read") manifest = json.load(manifest_stream) traces: dict[str, ReplayTrace] = {} for line_number, raw in enumerate(io.TextIOWrapper(actors_stream), 1): if not raw.strip(): continue trace = ReplayTrace.from_jsonl_row(json.loads(raw)) if trace.trace_id in traces: raise ValueError(f"duplicate actor trace: {trace.trace_id}") traces[trace.trace_id] = trace if manifest.get("root_id") != root_id or manifest.get("actors") != len(traces): raise ValueError("root manifest identity/count mismatch") lead_ids = [ trace_id for trace_id, trace in traces.items() if trace.metadata["multiagent"].get("parent_trace_id") is None ] if len(lead_ids) != 1: raise ValueError(f"expected one lead actor, found {lead_ids}") lead_id = lead_ids[0] edges: list[ChildEdge] = [] child_to_edge: dict[str, ChildEdge] = {} for parent_id, parent in traces.items(): metadata = parent.metadata.get("multiagent") if not isinstance(metadata, dict) or metadata.get("root_task_id") != root_id: raise ValueError(f"{parent_id}: root metadata mismatch") parent_generates = generate_events(parent) for raw in metadata.get("children") or []: edge = ChildEdge( parent_trace_id=parent_id, child_trace_id=str(raw["child_trace_id"]), fork_generate_index=int(raw["parent_fork_generate_index"]), join_generate_index=int(raw["parent_join_generate_index"]), child_final_generate_index=int(raw["child_final_generate_index"]), batch_id=str(raw["batch_id"]), dispatch_index=int(raw["dispatch_index"]), join_policy=str(raw["join_policy"]), ) if edge.child_trace_id not in traces: raise ValueError(f"missing child actor: {edge.child_trace_id}") if edge.child_trace_id in child_to_edge: raise ValueError(f"child has multiple incoming edges: {edge.child_trace_id}") if ( edge.join_policy != "all_terminal" or not 0 <= edge.fork_generate_index < edge.join_generate_index or edge.join_generate_index >= len(parent_generates) ): raise ValueError(f"invalid fork/join edge: {edge}") child_generates = generate_events(traces[edge.child_trace_id]) if edge.child_final_generate_index != len(child_generates) - 1: raise ValueError(f"child final request mismatch: {edge.child_trace_id}") assistant = parent_generates[edge.fork_generate_index].recorded_assistant or {} function_names = { call.get("function", {}).get("name") for call in assistant.get("tool_calls") or [] if isinstance(call, dict) } if "run_subagents" not in function_names: raise ValueError(f"fork request lacks run_subagents: {edge}") child_parent = traces[edge.child_trace_id].metadata["multiagent"].get( "parent_trace_id" ) if child_parent != parent_id: raise ValueError(f"child parent metadata differs: {edge.child_trace_id}") child_to_edge[edge.child_trace_id] = edge edges.append(edge) expected_children = set(traces) - {lead_id} if set(child_to_edge) != expected_children: raise ValueError( f"edge inventory differs from actors: " f"missing={sorted(expected_children-set(child_to_edge))}" ) reachable = {lead_id} while True: new = { edge.child_trace_id for edge in edges if edge.parent_trace_id in reachable } if new <= reachable: break reachable |= new if reachable != set(traces): raise ValueError("actor DAG is disconnected or cyclic") request_count = sum(len(generate_events(trace)) for trace in traces.values()) if request_count != manifest.get("requests"): raise ValueError("request count differs from root manifest") profile = { "schema_version": 1, "task_id": root_id, "root_id": root_id, "actors": len(traces), "main_sessions": 1, "subagent_sessions": len(traces) - 1, "turns": request_count, "main_turns": len(generate_events(traces[lead_id])), "subagent_turns": request_count - len(generate_events(traces[lead_id])), "task_calls": len({(e.parent_trace_id, e.batch_id) for e in edges}), "task_children": len(edges), "max_task_fanout_per_main_turn": max( Counter( (edge.parent_trace_id, edge.fork_generate_index) for edge in edges ).values(), default=0, ), "expected_prompt_tokens": manifest["target_prompt_tokens"], "expected_output_tokens": manifest["target_output_tokens"], "session_names": sorted(traces), "supported_for_causal_smoke": True, } return RootProgram( root_id=root_id, lead_trace_id=lead_id, traces=traces, edges=edges, manifest=manifest, profile=profile, ) class CausalRootRunner: def __init__( self, program: RootProgram, request_executor: RequestExecutor, writer: EventWriter, *, tool_time_scale: float, run_id: str, ) -> None: self.program = program self.request_executor = request_executor self.writer = writer self.tool_time_scale = tool_time_scale self.run_id = run_id self.actor_tasks: dict[str, asyncio.Task[None]] = {} self.completed_actors: set[str] = set() self.request_rows: list[dict[str, Any]] = [] self.barrier_rows: list[dict[str, Any]] = [] self.active_llm = 0 self.peak_llm = 0 self._edges_by_parent: dict[str, list[ChildEdge]] = defaultdict(list) for edge in program.edges: self._edges_by_parent[edge.parent_trace_id].append(edge) def _identity(self, trace: ReplayTrace) -> tuple[str, str]: identity = f"morphosis:{self.run_id}:{trace.trace_id}" return identity, identity def _start_actor(self, trace_id: str) -> asyncio.Task[None]: if trace_id in self.actor_tasks: raise RuntimeError(f"actor started twice: {trace_id}") task = asyncio.create_task(self._run_actor(self.program.traces[trace_id])) self.actor_tasks[trace_id] = task return task async def _await_edges( self, parent: ReplayTrace, edges: list[ChildEdge], awaited: set[tuple[str, int, int]], ) -> None: groups: dict[tuple[str, int, int], list[ChildEdge]] = defaultdict(list) for edge in edges: groups[ (edge.batch_id, edge.fork_generate_index, edge.join_generate_index) ].append(edge) for key, group in groups.items(): if key in awaited: continue missing = [ edge.child_trace_id for edge in group if edge.child_trace_id not in self.actor_tasks ] if missing: raise RuntimeError(f"join reached before child launch: {missing}") started = time.perf_counter() self.writer.emit( "barrier_wait_started", parent_trace_id=parent.trace_id, batch_id=key[0], fork_generate_index=key[1], join_generate_index=key[2], child_trace_ids=[edge.child_trace_id for edge in group], ) await asyncio.gather( *(self.actor_tasks[edge.child_trace_id] for edge in group) ) row = { "parent_trace_id": parent.trace_id, "batch_id": key[0], "fork_generate_index": key[1], "join_generate_index": key[2], "child_trace_ids": [edge.child_trace_id for edge in group], "duration_s": time.perf_counter() - started, } self.barrier_rows.append(row) self.writer.emit("barrier_wait_completed", **row) awaited.add(key) async def _run_actor(self, trace: ReplayTrace) -> None: metadata = trace.metadata["multiagent"] category = "main" if trace.trace_id == self.program.lead_trace_id else "subagent" routing_key, cache_salt = self._identity(trace) edges = self._edges_by_parent.get(trace.trace_id, []) by_fork: dict[int, list[ChildEdge]] = defaultdict(list) by_join: dict[int, list[ChildEdge]] = defaultdict(list) for edge in edges: by_fork[edge.fork_generate_index].append(edge) by_join[edge.join_generate_index].append(edge) awaited: set[tuple[str, int, int]] = set() last_fork_edges: list[ChildEdge] = [] generate_index = 0 self.writer.emit( "session_started", session=trace.trace_id, category=category, actor_id=metadata.get("actor_id"), parent_trace_id=metadata.get("parent_trace_id"), source_start_offset_s=trace.start_offset_s, ) for event in trace.events: if isinstance(event, Generate): if by_join.get(generate_index): await self._await_edges( trace, by_join[generate_index], awaited ) self.active_llm += 1 self.peak_llm = max(self.peak_llm, self.active_llm) self.writer.emit( "llm_started", session=trace.trace_id, category=category, turn=generate_index, active_llm=self.active_llm, expected_prompt_tokens=len(event.recorded_prompt_token_ids or []), expected_output_tokens=len(event.recorded_output_token_ids or []), ) started = time.perf_counter() try: outcome = await self.request_executor( trace, generate_index, event, routing_key, cache_salt ) finally: self.active_llm -= 1 row = { "session": trace.trace_id, "category": category, "turn": generate_index, "expected_prompt_tokens": len( event.recorded_prompt_token_ids or [] ), "actual_prompt_tokens": outcome.prompt_tokens, "expected_output_tokens": len( event.recorded_output_token_ids or [] ), "actual_output_tokens": outcome.completion_tokens, "cached_tokens": outcome.cached_tokens, "cached_tokens_details": outcome.cached_tokens_details, "latency_s": outcome.latency_s, "ttft_s": outcome.ttft_s, "request_wall_s": time.perf_counter() - started, } self.request_rows.append(row) self.writer.emit("llm_completed", **row) last_fork_edges = by_fork.get(generate_index, []) for edge in sorted(last_fork_edges, key=lambda item: item.dispatch_index): self._start_actor(edge.child_trace_id) self.writer.emit( "child_started", parent_trace_id=trace.trace_id, child_trace_id=edge.child_trace_id, batch_id=edge.batch_id, fork_generate_index=edge.fork_generate_index, join_generate_index=edge.join_generate_index, dispatch_index=edge.dispatch_index, ) generate_index += 1 continue kind = type(event).__name__ if kind == "Wait": if last_fork_edges: await self._await_edges(trace, last_fork_edges, awaited) last_fork_edges = [] elif event.seconds > 0 and self.tool_time_scale > 0: await asyncio.sleep(event.seconds * self.tool_time_scale) continue # AppendMessage and ReplaceContext do not need runtime reconstruction: # every converted Generate already carries authoritative prompt IDs. if edges: await self._await_edges(trace, edges, awaited) self.completed_actors.add(trace.trace_id) self.writer.emit( "session_completed", session=trace.trace_id, category=category, turns=generate_index, ) async def run(self) -> dict[str, Any]: started = time.perf_counter() self.writer.emit( "root_started", task_id=self.program.root_id, actors=len(self.program.traces), requests=self.program.profile["turns"], ) lead = self._start_actor(self.program.lead_trace_id) await lead await asyncio.gather(*self.actor_tasks.values()) if set(self.actor_tasks) != set(self.program.traces): raise RuntimeError("not every actor was launched") if self.completed_actors != set(self.program.traces): raise RuntimeError("not every actor completed") elapsed = time.perf_counter() - started summary = { "schema_version": 1, "task_id": self.program.root_id, "success": True, "elapsed_s": elapsed, "requests": len(self.request_rows), "actual_prompt_tokens": sum( row["actual_prompt_tokens"] for row in self.request_rows ), "actual_output_tokens": sum( row["actual_output_tokens"] for row in self.request_rows ), "cached_tokens": sum(row["cached_tokens"] for row in self.request_rows), "peak_active_llm": self.peak_llm, "barriers": self.barrier_rows, "trace_profile": self.program.profile, } self.writer.emit("root_completed", **summary) return summary def request_rid(run_id: str, trace_id: str, generate_index: int) -> str: digest = hashlib.sha256( f"{run_id}|{trace_id}|{generate_index}".encode("utf-8") ).hexdigest()[:32] return f"rid_{digest}" def production_executor( client: Client, *, run_id: str, root_start: float, ) -> RequestExecutor: accumulators: dict[str, StreamAccumulator] = defaultdict(StreamAccumulator) async def execute( trace: ReplayTrace, generate_index: int, event: Generate, routing_key: str, cache_salt: str, ) -> RequestOutcome: prompt_ids = event.recorded_prompt_token_ids output_ids = event.recorded_output_token_ids if ( not isinstance(prompt_ids, list) or not prompt_ids or not isinstance(output_ids, list) or not output_ids or event.max_tokens != len(output_ids) ): raise ValueError( f"incomplete DSV4 token contract: {trace.trace_id}/{generate_index}" ) result = await client._execute_request( prompt_ids, len(output_ids), stream=True, trace_start=root_start, stream_acc=accumulators[trace.trace_id], cache_salt=cache_salt, routing_key=routing_key, return_token_ids=True, deterministic_sampling=True, forced_output_token_ids=output_ids, rid=request_rid(run_id, trace.trace_id, generate_index), strict_replay_deadline_audit=True, disconnect_abort_delay_seconds=0.0, connect_retry_limit=0, ) if result.prompt_token_ids != prompt_ids: raise ValueError( f"server prompt IDs differ: {trace.trace_id}/{generate_index}" ) if result.generated_token_ids != output_ids: raise ValueError( f"server output IDs differ: {trace.trace_id}/{generate_index}" ) if ( result.request_started_at_s is None or result.request_finished_at_s is None or result.first_token_at_s is None ): raise ValueError("server request timing is incomplete") return RequestOutcome( prompt_tokens=result.prompt_tokens, completion_tokens=result.completion_tokens, cached_tokens=result.cached_tokens, cached_tokens_details=result.cached_tokens_details, latency_s=result.request_finished_at_s - result.request_started_at_s, ttft_s=result.first_token_at_s - result.request_started_at_s, ) return execute def simulated_executor() -> RequestExecutor: async def execute( trace: ReplayTrace, generate_index: int, event: Generate, routing_key: str, cache_salt: str, ) -> RequestOutcome: await asyncio.sleep(0) return RequestOutcome( prompt_tokens=len(event.recorded_prompt_token_ids or []), completion_tokens=len(event.recorded_output_token_ids or []), cached_tokens=0, cached_tokens_details=None, latency_s=0.001, ttft_s=0.0005, ) return execute def parser() -> argparse.ArgumentParser: result = argparse.ArgumentParser() result.add_argument("--archive", type=Path, required=True) result.add_argument("--output-dir", type=Path, required=True) result.add_argument("--endpoint") result.add_argument("--model", default="deepseek-v4-flash") result.add_argument("--tool-time-scale", type=float, default=1.0) result.add_argument("--stream-interval", type=int, default=64) result.add_argument("--timeout-s", type=float, default=7200.0) result.add_argument("--run-id") result.add_argument("--strict-turns", type=Path) result.add_argument("--strict-compactions", type=Path) result.add_argument("--simulate", action="store_true") return result def main() -> None: args = parser().parse_args() if args.model != "deepseek-v4-flash": raise ValueError("materialized workload requires model=deepseek-v4-flash") if args.tool_time_scale != 1.0: raise ValueError("this campaign requires tool_time_scale=1") if args.stream_interval <= 0 or args.timeout_s <= 0: raise ValueError("stream interval and timeout must be positive") if not args.simulate and not args.endpoint: raise ValueError("--endpoint is required outside simulation") if args.endpoint and not args.endpoint.endswith("/v1"): raise ValueError("--endpoint must end with /v1") for path in (args.strict_turns, args.strict_compactions): if path is not None and not path.is_file(): raise FileNotFoundError(path) if not args.simulate: if args.strict_turns is None or args.strict_compactions is None: raise ValueError("production replay requires the materialization seal") if args.strict_turns.resolve() != args.strict_compactions.resolve(): raise ValueError("both strict-store arguments must bind the same seal") seal = json.loads(args.strict_turns.read_text(encoding="utf-8")) if ( seal.get("kind") != "morphosis-dsv4-materialization" or seal.get("roots") != 100 or seal.get("target", {}).get("model") != "deepseek-v4-flash" ): raise ValueError("materialization seal does not authorize this replay") program = load_root_archive(args.archive) args.output_dir.mkdir(parents=True, exist_ok=True) atomic_json(args.output_dir / "trace-profile.json", program.profile) run_id = args.run_id or f"morphosis-{time.time_ns()}" writer = EventWriter(args.output_dir / "replay-events.jsonl", run_id) root_start = time.perf_counter() client = None if args.simulate: executor = simulated_executor() else: client = Client( endpoint=args.endpoint, model=args.model, api_key="unused", seed=0, max_retries=0, timeout=args.timeout_s, strict_replay_connect_retries=0, stream_interval=args.stream_interval, ) executor = production_executor(client, run_id=run_id, root_start=root_start) summary_path = args.output_dir / "replay-summary.json" try: summary = asyncio.run( CausalRootRunner( program, executor, writer, tool_time_scale=args.tool_time_scale, run_id=run_id, ).run() ) except BaseException as error: atomic_json( summary_path, { "schema_version": 1, "task_id": program.root_id, "success": False, "error_type": type(error).__name__, "error": str(error), "traceback": traceback.format_exc(), "trace_profile": program.profile, }, ) raise finally: writer.close() atomic_json(summary_path, summary) print(json.dumps(summary, indent=2, sort_keys=True)) if __name__ == "__main__": main()