import json import time from pathlib import Path import pytest from trace2mcp.codegen import generate_handlers_py, generate_project, generate_server_py from trace2mcp.compiler import compile_trace, topological_layers from trace2mcp.models import ( CycleError, Reference, Trace, TraceEvent, UnsafeTraceError, WorkflowNode, ) from trace2mcp.parsers import parse_sts_jsonl, parse_trace def event( event_id, tool, arguments, result, *, status="success", side_effect="read", idempotency="unknown", ): return TraceEvent( id=event_id, tool=tool, arguments=arguments, result=result, status=status, side_effect=side_effect, idempotency=idempotency, ) def test_compiler_infers_inputs_dependencies_and_ignores_failures(): trace = Trace( inputs={"company": "OpenAI", "options": {"limit": 3}}, events=[ event("failed", "search", {"q": "bad"}, None, status="error"), event("profile", "company", {"name": "OpenAI"}, {"company_id": 42}), event("news", "news", {"company_id": 42, "limit": 3}, ["launch"]), ], ) workflow = compile_trace(trace, name="company_report") assert [node.id for node in workflow.nodes] == ["profile", "news"] assert workflow.ignored_failed_events == ("failed",) assert workflow.nodes[0].arguments["name"] == Reference("input", ("company",)) assert workflow.nodes[1].arguments["limit"] == Reference("input", ("options", "limit")) assert workflow.nodes[1].arguments["company_id"] == Reference( "node", ("company_id",), node_id="profile" ) assert workflow.nodes[1].depends_on == ("profile",) assert topological_layers(workflow.nodes) == [["profile"], ["news"]] def test_compiler_deduplicates_only_identical_reads_and_redirects_edges(): trace = Trace( inputs={"query": "agents"}, events=[ event( "first", "search", {"q": "agents"}, {"result_id": 7}, idempotency="idempotent", ), event( "duplicate", "search", {"q": "agents"}, {"result_id": 7}, idempotency="idempotent", ), event("detail", "fetch", {"id": 7}, {"title": "A"}), ], ) workflow = compile_trace(trace) assert [node.id for node in workflow.nodes] == ["first", "detail"] assert workflow.deduplicated_events == {"duplicate": "first"} detail = workflow.nodes[-1] assert detail.depends_on == ("first",) assert detail.arguments["id"].node_id == "first" def test_mutable_reads_are_not_deduplicated_without_explicit_idempotency(): workflow = compile_trace( Trace( inputs={}, events=[ event("first", "clock", {}, "10:00"), event("second", "clock", {}, "10:01"), ], ) ) assert [node.id for node in workflow.nodes] == ["first", "second"] assert workflow.deduplicated_events == {} def test_explicit_dependencies_are_preserved_without_value_flow(): trace = Trace( inputs={}, events=[ TraceEvent("first", "prepare", {}, "ready", side_effect="read"), TraceEvent( "second", "consume", {"mode": "fixed"}, "done", side_effect="read", dependencies=("first",), ), ], ) workflow = compile_trace(trace) assert workflow.nodes[1].depends_on == ("first",) assert workflow.nodes[1].inference["dependencies"]["first"] == ("explicit trace dependency") def test_identical_values_from_multiple_producers_are_not_guessed(): workflow = compile_trace( Trace( inputs={}, events=[ event("a", "one", {}, {"value": 0}), event("b", "two", {}, {"value": 0}), event("c", "use", {"value": 0}, "done"), ], ) ) assert workflow.nodes[2].arguments["value"] == 0 assert workflow.nodes[2].depends_on == () def test_composite_results_create_dependency_on_the_whole_result(): profile = {"name": "OpenAI", "facts": ["AI lab"]} workflow = compile_trace( Trace( inputs={}, events=[ event("profile", "profile", {}, profile), event("report", "report", {"profile": profile}, "done"), ], ) ) report = workflow.nodes[1] assert report.arguments["profile"] == Reference("node", (), node_id="profile") assert report.depends_on == ("profile",) def test_writes_are_never_deduplicated_and_require_explicit_opt_in(): trace = Trace( inputs={}, events=[ event("w1", "send", {"body": "hello"}, {"ok": True}, side_effect="write"), event("w2", "send", {"body": "hello"}, {"ok": True}, side_effect="write"), ], ) with pytest.raises(UnsafeTraceError, match=r"w1\(write\)"): compile_trace(trace) workflow = compile_trace(trace, allow_side_effects=True) assert workflow.safety == "unsafe" assert [node.id for node in workflow.nodes] == ["w1", "w2"] assert workflow.deduplicated_events == {} def test_cycle_detection_is_explicit(): nodes = [ WorkflowNode("a", "one", {}, ("b",)), WorkflowNode("b", "two", {}, ("a",)), ] with pytest.raises(CycleError, match="cycle"): topological_layers(nodes) def test_workflow_serialization_round_trip_preserves_references(): workflow = compile_trace( Trace( inputs={"q": "hello"}, events=[event("a", "search", {"q": "hello"}, {"id": "r1"})], ) ) encoded = workflow.to_dict() assert encoded["nodes"][0]["arguments"]["q"] == {"$ref": "inputs.q"} assert type(workflow).from_dict(encoded).nodes[0].arguments["q"] == Reference("input", ("q",)) def test_reference_serialization_round_trips_dotted_keys(): reference = Reference("input", ("company.name", "items[0]")) assert reference.to_dict() == {"$ref": "inputs.company%2Ename.items%5B0%5D"} node = WorkflowNode("a", "echo", {"value": reference}) assert WorkflowNode.from_dict(node.to_dict()).arguments["value"] == reference def test_official_hugging_face_sts_envelope_is_detected(): content = "\n".join( [ json.dumps({"type": "session", "metadata": {"inputs": {"q": "weather"}}}), json.dumps( { "type": "message", "message": { "role": "assistant", "timestamp": "2026-08-24T00:00:00Z", "toolCalls": [ { "id": "call-1", "function": { "name": "search", "arguments": json.dumps({"q": "weather"}), }, "metadata": {"side_effect": "read"}, } ], }, } ), json.dumps( { "type": "message", "message": { "role": "tool", "toolCallId": "call-1", "content": json.dumps({"temperature": 20}), }, } ), ] ) trace = parse_sts_jsonl(content) assert trace.inputs == {"q": "weather"} assert len(trace.events) == 1 assert trace.events[0].tool == "search" assert trace.events[0].arguments == {"q": "weather"} assert trace.events[0].result == {"temperature": 20} assert trace.events[0].side_effect == "read" assert parse_trace(content).events[0].id == "call-1" def test_codegen_never_embeds_trace_values_as_executable_source(): workflow = compile_trace( Trace( inputs={}, events=[event("a", "search'); __import__('os').system('bad') #", {}, {})], ) ) generated = generate_handlers_py(workflow) compile(generated, "handlers.py", "exec") assert "async def search___import___os_system_bad" in generated assert "raise NotImplementedError" in generated def test_generated_server_targets_current_mcp_sdk_v2(): workflow = compile_trace(Trace(inputs={}, events=[event("a", "search", {}, {"ok": True})])) generated = generate_server_py(workflow) assert "from mcp.server import MCPServer" in generated assert "MCP = MCPServer(" in generated assert "mcp.server.fastmcp" not in generated workflow.name = 'workflow"""; raise RuntimeError("injected") #' compile(generate_server_py(workflow), "server.py", "exec") def test_codegen_writes_manifest_test_and_preserves_reviewed_handlers(tmp_path: Path): workflow = compile_trace( Trace( inputs={"customer_id": 7}, events=[event("a", "lookup", {"customer_id": 7}, {"name": "A"})], ), name="customer_report", ) generated = generate_project(workflow, tmp_path) assert {"contracts", "manifest", "provenance", "frozen_test"} <= set(generated) manifest = json.loads((tmp_path / "manifest.json").read_text(encoding="utf-8")) assert manifest["workflow_hash"] == workflow.workflow_hash assert manifest["contracts"] == "contracts.py" assert manifest["contract_review_required"] is True assert manifest["runtime_guard"] == { "default": "disabled", "provider": "hol_guard_cli", "enable_with": "TRACE2MCP_HOL_GUARD_EXECUTABLE", } server = (tmp_path / "server.py").read_text(encoding="utf-8") assert "customer_id: int" in server assert "return result.output" in server assert "require_contracts=True" in server assert "require_reviewed_contracts=True" in server contracts = (tmp_path / "contracts.py").read_text(encoding="utf-8") assert "reviewed=False" in contracts reviewed = "# reviewed handler\n" reviewed_contracts = "# reviewed contracts\n" (tmp_path / "handlers.py").write_text(reviewed, encoding="utf-8") (tmp_path / "contracts.py").write_text(reviewed_contracts, encoding="utf-8") generate_project(workflow, tmp_path) assert (tmp_path / "handlers.py").read_text(encoding="utf-8") == reviewed assert (tmp_path / "contracts.py").read_text(encoding="utf-8") == reviewed_contracts generate_project(workflow, tmp_path, force_handlers=True) assert "NotImplementedError" in (tmp_path / "handlers.py").read_text(encoding="utf-8") def test_python_compiler_matches_static_golden_graph(): root = Path(__file__).resolve().parents[1] trace = parse_trace((root / "examples" / "sample_trace.json").read_text(encoding="utf-8")) golden = json.loads( (root / "tests" / "golden" / "sample_graph.json").read_text(encoding="utf-8") ) workflow = compile_trace(trace) assert [node.id for node in workflow.nodes] == golden["nodes"] assert {node.id: list(node.depends_on) for node in workflow.nodes} == golden["dependencies"] assert topological_layers(workflow.nodes) == golden["layers"] assert workflow.output_schema == workflow.nodes[-1].output_schema def test_compiler_handles_one_thousand_independent_nodes_without_quadratic_regression(): trace = Trace( inputs={}, events=[event(str(index), "noop", {}, index, side_effect="pure") for index in range(1000)], ) started = time.perf_counter() workflow = compile_trace(trace) elapsed = time.perf_counter() - started assert len(workflow.nodes) == 1000 assert topological_layers(workflow.nodes) == [[str(index) for index in range(1000)]] assert elapsed < 5.0