#!/usr/bin/env python3 """Retokenize Morphosis logical-order traces for strict DSV4 replay. The input actor rows remain byte-preserved in the sealed source artifact. This materializer creates one tar.gz bundle per root program, replacing only the GLM prompt/output token IDs and output length with values produced by the frozen DeepSeek-V4 serving encoder and tokenizer. """ from __future__ import annotations import argparse import copy import hashlib import importlib.util import json import lzma import os import re import shutil import tarfile import tempfile import time from collections import Counter from pathlib import Path from types import ModuleType from typing import Any, Iterable from transformers import AutoTokenizer ROOT_ID_RE = re.compile(r"root-\d{3}-[A-Za-z0-9_.-]+") def sha256_file(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: while chunk := handle.read(8 << 20): digest.update(chunk) return digest.hexdigest() def sha256_json(value: Any) -> str: return hashlib.sha256( json.dumps(value, ensure_ascii=False, separators=(",", ":")).encode("utf-8") ).hexdigest() def load_encoder(path: Path) -> ModuleType: spec = importlib.util.spec_from_file_location("frozen_encoding_dsv4", path) if spec is None or spec.loader is None: raise ValueError(f"cannot load DSV4 encoder: {path}") module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) if not hasattr(module, "encode_messages"): raise ValueError(f"DSV4 encoder lacks encode_messages: {path}") return module def flatten_content(content: Any, *, location: str, audit: Counter[str]) -> str: if content is None: return "" if isinstance(content, str): return content if not isinstance(content, list): raise TypeError(f"{location}: unsupported content type {type(content).__name__}") parts: list[str] = [] for index, part in enumerate(content): if isinstance(part, str): audit["content_part:string"] += 1 parts.append(part) continue if not isinstance(part, dict): raise TypeError(f"{location}[{index}]: invalid content part") kind = str(part.get("type") or "") if kind in {"text", "input_text"} and isinstance(part.get("text"), str): audit[f"content_part:{kind}"] += 1 parts.append(part["text"]) continue raise ValueError(f"{location}[{index}]: unsupported content part {kind!r}") return " ".join(parts) def prepare_messages( messages: list[dict[str, Any]], *, tools: list[dict[str, Any]], location: str, audit: Counter[str], ) -> list[dict[str, Any]]: prepared = copy.deepcopy(messages) for index, message in enumerate(prepared): if not isinstance(message, dict): raise TypeError(f"{location}.messages[{index}] is not an object") role = message.get("role") if not isinstance(role, str) or not role: raise ValueError(f"{location}.messages[{index}] has invalid role") if "content" in message: message["content"] = flatten_content( message["content"], location=f"{location}.messages[{index}].content", audit=audit, ) elif role == "assistant": message["content"] = "" for call_index, tool_call in enumerate(message.get("tool_calls") or []): function = tool_call.get("function") if isinstance(tool_call, dict) else None if not isinstance(function, dict): raise TypeError( f"{location}.messages[{index}].tool_calls[{call_index}] is invalid" ) arguments = function.get("arguments") if isinstance(arguments, str): arguments = json.loads(arguments) function["arguments"] = arguments if arguments is not None and not isinstance(arguments, dict): raise TypeError( f"{location}.messages[{index}].tool_calls[{call_index}] " "arguments must be an object" ) if not prepared or prepared[0].get("role") != "system": prepared.insert(0, {"role": "system", "content": ""}) prepared[0]["tools"] = copy.deepcopy(tools) return prepared def converted_actor( row: dict[str, Any], *, tokenizer: Any, encoder: ModuleType, vocab_size: int, context_limit: int, audit: Counter[str], ) -> tuple[dict[str, Any], dict[str, int], list[dict[str, Any]]]: trace_id = row.get("trace_id") if row.get("schema_version") != 2 or not isinstance(trace_id, str): raise ValueError("input is not a schema-v2 ReplayTrace") metadata = row.get("metadata") if not isinstance(metadata, dict) or not isinstance(metadata.get("multiagent"), dict): raise ValueError(f"{trace_id}: missing multiagent metadata") output = copy.deepcopy(row) messages = copy.deepcopy(row.get("initial_messages") or []) tools = copy.deepcopy(row.get("tools") or []) source_requests: list[dict[str, Any]] = [] totals: Counter[str] = Counter() generate_index = 0 for event_index, event in enumerate(output["events"]): kind = event.get("type") if kind == "append_message": messages.append(copy.deepcopy(event["message"])) continue if kind == "replace_context": messages = copy.deepcopy(event["messages"]) continue if kind == "wait": continue if kind != "generate": raise ValueError(f"{trace_id}: unknown event type {kind!r}") assistant = event.get("recorded_assistant") source_prompt_ids = event.get("recorded_prompt_token_ids") source_output_ids = event.get("recorded_output_token_ids") if ( not isinstance(assistant, dict) or not isinstance(source_prompt_ids, list) or not source_prompt_ids or not isinstance(source_output_ids, list) or not source_output_ids ): raise ValueError( f"{trace_id}: request {generate_index} lacks complete source contract" ) location = f"{trace_id}/request-{generate_index}" prompt_messages = prepare_messages( messages, tools=tools, location=location, audit=audit, ) completed_messages = prepare_messages( messages + [assistant], tools=tools, location=location, audit=audit, ) prompt_text = encoder.encode_messages( prompt_messages, thinking_mode="thinking", reasoning_effort="high", reasoning_effort_profile="preview", ) completed_text = encoder.encode_messages( completed_messages, thinking_mode="thinking", reasoning_effort="high", reasoning_effort_profile="preview", ) if not completed_text.startswith(prompt_text): raise ValueError(f"{location}: assistant is not a text continuation") prompt_ids = tokenizer.encode(prompt_text) completed_ids = tokenizer.encode(completed_text) if completed_ids[: len(prompt_ids)] != prompt_ids: raise ValueError(f"{location}: completed tokens do not extend prompt tokens") output_ids = completed_ids[len(prompt_ids) :] if not prompt_ids or prompt_ids[0] != tokenizer.bos_token_id: raise ValueError(f"{location}: converted prompt lacks DSV4 BOS") if not output_ids or output_ids[-1] != tokenizer.eos_token_id: raise ValueError(f"{location}: converted output lacks DSV4 EOS") if max(prompt_ids) >= vocab_size or max(output_ids) >= vocab_size: raise ValueError(f"{location}: converted token exceeds vocab size") if len(prompt_ids) + len(output_ids) > context_limit: raise ValueError( f"{location}: context {len(prompt_ids) + len(output_ids)} " f"exceeds {context_limit}" ) target_prompt_sha256 = sha256_json(prompt_ids) target_output_sha256 = sha256_json(output_ids) source_requests.append( { "event_index": event_index, "generate_index": generate_index, "source_model": event.get("source_model"), "source_prompt_tokens": len(source_prompt_ids), "source_output_tokens": len(source_output_ids), "source_prompt_sha256": sha256_json(source_prompt_ids), "source_output_sha256": sha256_json(source_output_ids), "target_prompt_tokens": len(prompt_ids), "target_output_tokens": len(output_ids), "target_prompt_sha256": target_prompt_sha256, "target_output_sha256": target_output_sha256, } ) event["recorded_prompt_token_ids"] = prompt_ids event["recorded_prompt_token_count"] = len(prompt_ids) event["recorded_prompt_token_ids_sha256"] = target_prompt_sha256 event["recorded_output_token_ids"] = output_ids event["max_tokens"] = len(output_ids) totals["requests"] += 1 totals["source_prompt_tokens"] += len(source_prompt_ids) totals["source_output_tokens"] += len(source_output_ids) totals["target_prompt_tokens"] += len(prompt_ids) totals["target_output_tokens"] += len(output_ids) totals["target_max_prompt_tokens"] = max( totals["target_max_prompt_tokens"], len(prompt_ids) ) totals["target_max_output_tokens"] = max( totals["target_max_output_tokens"], len(output_ids) ) messages.append(copy.deepcopy(assistant)) generate_index += 1 return output, dict(totals), source_requests def write_root_bundle( *, output_dir: Path, root_id: str, actor_rows: list[dict[str, Any]], actor_totals: list[dict[str, int]], ) -> dict[str, Any]: if ROOT_ID_RE.fullmatch(root_id) is None: raise ValueError(f"unsafe root id: {root_id!r}") archive_path = output_dir / f"{root_id}.tar.gz" if archive_path.exists(): raise FileExistsError(archive_path) totals: Counter[str] = Counter() for row in actor_totals: for key, value in row.items(): if key.startswith("target_max_"): totals[key] = max(totals[key], value) else: totals[key] += value manifest = { "schema_version": 1, "root_id": root_id, "actors": len(actor_rows), "lead_actors": sum( row["metadata"]["multiagent"].get("parent_trace_id") is None for row in actor_rows ), **dict(totals), } with tempfile.TemporaryDirectory(prefix=f"{root_id}-", dir=output_dir) as temp: root = Path(temp) / root_id root.mkdir() actors_path = root / "actors.jsonl" with actors_path.open("w", encoding="utf-8") as handle: for row in actor_rows: handle.write( json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n" ) (root / "manifest.json").write_text( json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8", ) temp_archive = archive_path.with_suffix(archive_path.suffix + ".tmp") with tarfile.open(temp_archive, "w:gz", compresslevel=1) as archive: archive.add(root, arcname=root_id) os.replace(temp_archive, archive_path) manifest["archive"] = archive_path.name manifest["archive_bytes"] = archive_path.stat().st_size manifest["archive_sha256"] = sha256_file(archive_path) return manifest def rows(path: Path) -> Iterable[dict[str, Any]]: with lzma.open(path, "rt", encoding="utf-8") as handle: for line_number, line in enumerate(handle, 1): try: yield json.loads(line) except json.JSONDecodeError as error: raise ValueError(f"invalid JSONL row {line_number}") from error def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--input-xz", type=Path, required=True) parser.add_argument("--output-dir", type=Path, required=True) parser.add_argument("--target-model", type=Path, required=True) parser.add_argument("--dsv4-encoder", type=Path, required=True) parser.add_argument("--source-artifact-sha256", required=True) parser.add_argument("--max-roots", type=int) parser.add_argument("--shard-count", type=int, default=1) parser.add_argument("--shard-index", type=int, default=0) args = parser.parse_args() if args.output_dir.exists(): raise FileExistsError(args.output_dir) if args.max_roots is not None and args.max_roots <= 0: raise ValueError("--max-roots must be positive") if args.shard_count <= 0 or not 0 <= args.shard_index < args.shard_count: raise ValueError("shard index must be in [0, shard count)") args.output_dir.mkdir(parents=True) tokenizer = AutoTokenizer.from_pretrained( args.target_model, trust_remote_code=True, local_files_only=True, ) encoder = load_encoder(args.dsv4_encoder) model_config = json.loads((args.target_model / "config.json").read_text()) vocab_size = int(model_config["vocab_size"]) context_limit = int(model_config["max_position_embeddings"]) if not isinstance(tokenizer.eos_token_id, int): raise TypeError("target tokenizer lacks EOS token") audit: Counter[str] = Counter() archives: list[dict[str, Any]] = [] current_root: str | None = None actor_rows: list[dict[str, Any]] = [] actor_totals: list[dict[str, int]] = [] seen_roots: set[str] = set() seen_input_roots: set[str] = set() input_root: str | None = None input_root_index = -1 selected = False request_audit_rows = 0 def flush() -> bool: nonlocal actor_rows, actor_totals, current_root if current_root is None: return False archives.append( write_root_bundle( output_dir=args.output_dir, root_id=current_root, actor_rows=actor_rows, actor_totals=actor_totals, ) ) print(json.dumps(archives[-1], sort_keys=True), flush=True) seen_roots.add(current_root) actor_rows = [] actor_totals = [] current_root = None return args.max_roots is not None and len(archives) >= args.max_roots started = time.time() request_audit_path = args.output_dir / "request-token-audit.jsonl.xz" with lzma.open( request_audit_path, "wt", encoding="utf-8", preset=1, ) as request_audit: for source_row in rows(args.input_xz): root_id = source_row["metadata"]["multiagent"]["root_task_id"] if root_id != input_root: if current_root is not None and flush(): break if root_id in seen_input_roots: raise ValueError(f"non-contiguous root block: {root_id}") seen_input_roots.add(root_id) input_root = root_id input_root_index += 1 selected = input_root_index % args.shard_count == args.shard_index if selected: if root_id in seen_roots: raise ValueError(f"selected root repeated: {root_id}") current_root = root_id if not selected: continue output_row, totals, request_rows = converted_actor( source_row, tokenizer=tokenizer, encoder=encoder, vocab_size=vocab_size, context_limit=context_limit, audit=audit, ) actor_rows.append(output_row) actor_totals.append(totals) for request_row in request_rows: request_audit.write( json.dumps( { "root_id": root_id, "trace_id": output_row["trace_id"], **request_row, }, separators=(",", ":"), sort_keys=True, ) + "\n" ) request_audit_rows += 1 if current_root is not None and ( args.max_roots is None or len(archives) < args.max_roots ): flush() global_totals: Counter[str] = Counter() for item in archives: for key in ( "actors", "lead_actors", "requests", "source_prompt_tokens", "source_output_tokens", "target_prompt_tokens", "target_output_tokens", ): global_totals[key] += int(item[key]) for key in ("target_max_prompt_tokens", "target_max_output_tokens"): global_totals[key] = max(global_totals[key], int(item[key])) seal = { "schema_version": 1, "kind": "morphosis-dsv4-materialization", "created_at_s": time.time(), "elapsed_s": time.time() - started, "source": { "artifact_sha256": args.source_artifact_sha256, "logical_order_xz": str(args.input_xz), "logical_order_xz_sha256": sha256_file(args.input_xz), }, "target": { "model": "deepseek-v4-flash", "model_path": str(args.target_model), "vocab_size": vocab_size, "context_limit": context_limit, "eos_token_id": tokenizer.eos_token_id, "tokenizer_sha256": sha256_file(args.target_model / "tokenizer.json"), "tokenizer_config_sha256": sha256_file( args.target_model / "tokenizer_config.json" ), "dsv4_encoder": str(args.dsv4_encoder), "dsv4_encoder_sha256": sha256_file(args.dsv4_encoder), "thinking_mode": "thinking", "reasoning_effort": "high", "reasoning_effort_profile": "preview", }, "shard": { "count": args.shard_count, "index": args.shard_index, "input_roots_seen": len(seen_input_roots), }, "roots": len(archives), "totals": dict(global_totals), "content_audit": dict(sorted(audit.items())), "request_token_audit": { "path": request_audit_path.name, "rows": request_audit_rows, "sha256": sha256_file(request_audit_path), }, "archives": archives, } (args.output_dir / "materialization-seal.json").write_text( json.dumps(seal, indent=2, sort_keys=True) + "\n", encoding="utf-8", ) with (args.output_dir / "archives.sha256").open("w") as handle: for item in archives: handle.write(f"{item['archive_sha256']} {item['archive']}\n") print(json.dumps({"seal": seal}, sort_keys=True), flush=True) if __name__ == "__main__": main()