trace2mcp / tests /test_compiler.py
War Enterprise
Release Trace2MCP 0.2.2
1dc3b5a verified
Raw History Blame Contribute Delete
12 kB
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