Skip to content

Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.

36.4 KB
Raw Blame
use std::collections::BTreeSet;

use hiroute_domain::{
    ConversationContentDirectionV2, ConversationContentPhaseV2, OBSERVATION_ACK_SCHEMA_V2,
    OBSERVATION_NACK_SCHEMA_V1, ObservationAckV2, ObservationBlobAcknowledgementV1,
    ObservationContentAcknowledgementV1, ObservationDigestSubjectV1, ObservationFeedback,
    ObservationFeedbackIdentityV1, ObservationNackDetailV1, ObservationNackV1,
    ObservationSequenceRangeV1,
};
use hiroute_gateway::server::core_runtime::observation::{
    CONVERSATION_CONTENT_PORT_DIGEST, CONVERSATION_CONTENT_SCHEMA, EXECUTION_FACT_PORT_DIGEST,
    EXECUTION_FACT_SCHEMA, LIFECYCLE_FACT_PORT_DIGEST, LIFECYCLE_FACT_SCHEMA,
};
use serde_json::{Value, json};

use super::*;

const DIGEST: &str = "sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";

fn producer(component: &str) -> Value {
    json!({
        "component": component,
        "revision": "gateway-observation/1",
        "producer_id": "producer-main",
        "producer_epoch": "epoch-main",
        "stream_id": "stream-main"
    })
}

fn correlation() -> Value {
    json!({
        "workspace_id": "personal/default",
        "conversation_id": "conversation-main",
        "session_scope": "conversation",
        "correlation_provenance": "agent_supplied",
        "turn_id": "turn-main",
        "request_id": "request-main"
    })
}

#[test]
fn fixed_publication_digest_matches_the_actual_gateway_binding() {
    use hiroute_domain as domain;
    let fixture: Value = serde_json::from_slice::<serde_json::Value>(include_bytes!(
        "../../../../e2e/product/fixtures/routing/current-publication.v3.json"
    ))
    .unwrap();
    let plan =
        serde_json::from_value::<hiroute_domain::CompiledAgentPlanV1>(fixture["plans"][0].clone())
            .unwrap();
    let plan = plan.into_current().unwrap();
    let binding = plan.body.materialized.attempt_owned.groups[0].candidates[0].clone();
    let grant = domain::AgentModelGrantV2::seal(
        domain::AgentIngressProtocolV1::Responses,
        [(
            "Native.Model/v1".into(),
            domain::AgentModelRouteV2::Fixed {
                candidate: domain::CandidateSelectionV1 {
                    binding_id: binding.binding_id.clone(),
                    reasoning: None,
                },
                binding: Box::new(binding.clone()),
            },
        )]
        .into(),
    )
    .unwrap();
    let publication = domain::GatewayPublicationV1::new(
        domain::WorkspaceId::default(),
        domain::GatewayPublicationRevision::new(1).unwrap(),
        domain::AliasRegistryV1::default(),
        Vec::new(),
    )
    .unwrap()
    .next_with_access_grant(
        domain::GatewayPublicationRevision::new(2).unwrap(),
        domain::GatewayAccessGrantV1::new(
            "fixed-adapter-grant",
            1,
            domain::CanonicalDigest::of_bytes(b"fixed-adapter-token"),
            domain::AgentIngressProtocolV1::Responses,
            grant,
        )
        .unwrap(),
    )
    .unwrap();
    let product = publication.gateway_snapshot().unwrap();
    let gateway = project_publication(&product).unwrap();
    assert!(gateway.aliases.is_empty());
    let hiroute_gateway::server::publication::ModelRouteV2::Fixed {
        binding: projected,
        binding_digest,
        ..
    } = &gateway.grants[0].routes["Native.Model/v1"]
    else {
        panic!("expected fixed route");
    };
    assert_eq!(
        *binding_digest,
        domain::CanonicalDigest::of(projected.as_ref()).unwrap()
    );
    assert_eq!(projected.credential_refs, binding.credential_refs);
    assert_eq!(projected.upstream_model_id, binding.upstream_model_id);
    assert_eq!(
        projected
            .pricing_identity
            .as_ref()
            .unwrap()
            .source_identity_digest,
        binding.source_identity_digest
    );
    let mut changed = product;
    let domain::GatewayModelRouteV2::Fixed { binding_digest, .. } =
        changed.grants[0].routes.values_mut().next().unwrap()
    else {
        panic!("expected fixed route");
    };
    *binding_digest = domain::CanonicalDigest::of(&binding).unwrap();
    changed.payload_digest = changed.canonical_digest().unwrap().to_string();
    assert!(project_publication(&changed).is_err());
}

#[test]
fn gateway_adapter_projects_lifecycle_exactly_and_rejects_unknown_field() {
    let payload = json!({
        "schema_version": LIFECYCLE_FACT_SCHEMA,
        "schema_digest": LIFECYCLE_FACT_PORT_DIGEST,
        "channel": "lifecycle",
        "producer": producer("gateway-lifecycle"),
        "sequence": 1,
        "event_id": "lifecycle-event-1",
        "correlation": correlation(),
        "occurred_at_unix_nanos": 1,
        "fact": {"kind": "request_accepted", "ingress_protocol": "responses"},
        "loss_watermark": null,
        "completeness_delta": null
    });
    let encoded = serde_json::to_vec(&payload).unwrap();
    let projected = project_lifecycle_payload(&encoded).unwrap();
    assert_eq!(serde_json::to_value(projected).unwrap(), payload);

    let mut unknown = payload;
    unknown["adapter_cache"] = json!(true);
    assert_eq!(
        project_lifecycle_payload(&serde_json::to_vec(&unknown).unwrap()),
        Err(GatewayProjectionError::InvalidInput)
    );
}

#[test]
fn gateway_adapter_preserves_zero_byte_lifecycle_end_stream_frame() {
    let payload = json!({
        "schema_version": LIFECYCLE_FACT_SCHEMA,
        "schema_digest": LIFECYCLE_FACT_PORT_DIGEST,
        "channel": "lifecycle",
        "producer": producer("gateway-lifecycle"),
        "sequence": 5,
        "event_id": "lifecycle-end-stream-5",
        "correlation": correlation(),
        "occurred_at_unix_nanos": 1,
        "fact": {
            "kind": "response_frame_accepted",
            "frame_id": "frame-empty-end-stream",
            "byte_count": 0,
            "downstream_delivery": "full_frame_transport_accepted"
        },
        "loss_watermark": null,
        "completeness_delta": null
    });
    // ReplayBodySession reports an accepted empty EOF write through the same
    // lifecycle DTO as a nonempty body frame; its actual byte count stays zero.
    let gateway: hiroute_gateway::server::core_runtime::observation::LifecycleFactEnvelopeV1 =
        serde_json::from_value(payload.clone()).unwrap();
    let projected = project_lifecycle_payload(&serde_json::to_vec(&gateway).unwrap()).unwrap();
    assert_eq!(serde_json::to_value(projected).unwrap(), payload);

    for field in ["frame_id", "downstream_delivery"] {
        let mut invalid = payload.clone();
        invalid["fact"][field] = json!("");
        assert_eq!(
            project_lifecycle_payload(&serde_json::to_vec(&invalid).unwrap()),
            Err(GatewayProjectionError::InvalidOutput)
        );
    }
    let mut unknown = payload;
    unknown["fact"]["content"] = json!("not a lifecycle field");
    assert_eq!(
        project_lifecycle_payload(&serde_json::to_vec(&unknown).unwrap()),
        Err(GatewayProjectionError::InvalidInput)
    );
}

#[test]
fn gateway_adapter_projects_flat_execution_receipt_into_frozen_trust() {
    let payload = execution_payload(
        json!({
            "kind": "request_finished",
            "outcome": "accepted",
            "attempts_started": 1,
            "attempts_finished": 1,
            "accepted_attempt_ordinal": 1,
            "facts_completeness": "complete"
        }),
        9,
        false,
    );
    let projected = project_execution_payload(&serde_json::to_vec(&payload).unwrap()).unwrap();
    let projected = serde_json::to_value(projected).unwrap();
    assert_eq!(
        projected["schema_version"],
        hiroute_domain::EXECUTION_FACT_SCHEMA_V2
    );
    assert!(projected["pricing"].is_null());
    assert_eq!(projected["trust"]["authority_id"], "authority-main");
    assert_eq!(projected["trust"]["plan_display_name"], "Coding route");
    assert_eq!(
        projected["producer"]["stream"]["producer_id"],
        "producer-main"
    );
    assert!(projected.get("authority_id").is_none());
    assert!(projected["producer"].get("producer_id").is_none());
    assert_eq!(projected["fact"], payload["fact"]);
    assert_eq!(projected["sequence"], 9);

    let mut legacy = payload.clone();
    legacy.as_object_mut().unwrap().remove("plan_display_name");
    let legacy = project_execution_payload(&serde_json::to_vec(&legacy).unwrap()).unwrap();
    assert!(legacy.trust.plan_display_name.is_none());

    let mut wrong_digest = payload;
    wrong_digest["schema_digest"] = json!(DIGEST);
    assert_eq!(
        project_execution_payload(&serde_json::to_vec(&wrong_digest).unwrap()),
        Err(GatewayProjectionError::UnsupportedSchema)
    );
}

#[test]
fn fixed_gateway_projection_preserves_binding_without_plan_provenance() {
    let mut payload = execution_payload(complete_execution_facts().remove(0), 1, false);
    let route = json!({"kind": "fixed", "binding_digest": DIGEST});
    payload["agent_plan_id"] = Value::Null;
    payload.as_object_mut().unwrap().remove("plan_display_name");
    payload["route"] = route.clone();
    payload["fact"]["plan_id"] = Value::Null;
    payload["fact"]["route"] = route.clone();
    let projected = project_execution_payload(&serde_json::to_vec(&payload).unwrap()).unwrap();
    assert!(projected.trust.agent_plan_id.is_none());
    assert!(projected.trust.plan_display_name.is_none());
    assert_eq!(serde_json::to_value(&projected.trust.route).unwrap(), route);
    assert_eq!(
        serde_json::to_value(&projected.fact).unwrap()["route"],
        route
    );

    payload["agent_plan_id"] = json!("plan/coding");
    assert_eq!(
        project_execution_payload(&serde_json::to_vec(&payload).unwrap()),
        Err(GatewayProjectionError::InvalidOutput)
    );
    payload["agent_plan_id"] = Value::Null;
    payload["plan_display_name"] = json!("False plan");
    assert_eq!(
        project_execution_payload(&serde_json::to_vec(&payload).unwrap()),
        Err(GatewayProjectionError::InvalidOutput)
    );
}

#[test]
fn priced_and_unpriced_gateway_facts_project_to_one_product_contract() {
    let fact = complete_execution_facts()
        .into_iter()
        .find(|fact| fact["kind"] == "attempt_started")
        .unwrap();
    let mut priced = execution_payload(fact, 1, true);
    priced["pricing"] = json!({
        "schema_version": "hiroute.observation.execution-pricing/v1",
        "request_generation": null,
        "captured_at_ms": 0,
        "attempt_execution_at_ms": 0,
        "quote": null,
        "reference_quote": null,
        "unknown_reason": "snapshot_unavailable"
    });
    let priced = project_execution_payload(&serde_json::to_vec(&priced).unwrap()).unwrap();
    assert_eq!(
        priced.schema_version,
        hiroute_domain::EXECUTION_FACT_SCHEMA_V2
    );
    assert!(priced.pricing.is_some());

    let unpriced = execution_payload(
        json!({
            "kind": "request_finished",
            "outcome": "accepted",
            "attempts_started": 1,
            "attempts_finished": 1,
            "accepted_attempt_ordinal": 1,
            "facts_completeness": "complete"
        }),
        2,
        false,
    );
    let unpriced = project_execution_payload(&serde_json::to_vec(&unpriced).unwrap()).unwrap();
    assert_eq!(
        unpriced.schema_version,
        hiroute_domain::EXECUTION_FACT_SCHEMA_V2
    );
    assert!(unpriced.pricing.is_none());
}

#[test]
fn gateway_adapter_tags_provider_native_reasoning_for_product_receipts() {
    let payload = execution_payload(
        json!({
            "kind": "route_decision",
            "planner_version": "hiroute-deterministic-planner/v1",
            "plan_id": "plan/coding",
            "route": {"kind": "plan", "revision": 7, "semantic_digest": DIGEST},
            "input_digest": DIGEST,
            "policy_digest": DIGEST,
            "output_digest": DIGEST,
            "branch": "smart_saving_complex",
            "complexity": null,
            "groups": [],
            "reason_ledger": [],
            "requirements": {
                "text": true,
                "image_url": false,
                "image_base64": false,
                "image_media_types": [],
                "function_tools": false,
                "strict_tools": false,
                "parallel_tools": false,
                "tool_choice": {"kind": "auto"},
                "tool_result_text": false,
                "tool_result_json": false,
                "tool_roundtrip": false,
                "logical_tool_id_mapping": false,
                "provider_state": false,
                "initial_instructions": false,
                "mid_conversation_instructions": false,
                "streaming": true,
                "stream_text": true,
                "stream_reasoning": true,
                "stream_tool_arguments": false,
                "stream_usage": true,
                "ingress_protocol": "messages"
            },
            "requested_reasoning_disposition": "overridden_by_agent_plan",
            "requested_reasoning_value": {
                "thinking": {"type": "enabled", "budget_tokens": 1024},
                "output_config": null
            },
            "requested_max_output_tokens": 2048,
            "stream": true,
            "outcome": "ready",
            "outcome_code": null,
            "max_attempts": 2
        }),
        1,
        false,
    );
    let projected = project_execution_payload(&serde_json::to_vec(&payload).unwrap()).unwrap();
    let projected = serde_json::to_value(projected).unwrap();
    assert_eq!(
        projected["fact"]["requested_reasoning_value"]["kind"],
        "object"
    );
    assert_eq!(
        projected["fact"]["requested_reasoning_value"]["value"]["thinking"]["value"]["budget_tokens"]
            ["value"],
        1024
    );
}

#[test]
fn gateway_adapter_preserves_every_tool_choice_identity() {
    use hiroute_gateway::server::core_runtime::model_ir::{ToolChoice, ToolKindV1};

    for (choice, expected) in [
        (ToolChoice::None, json!({"kind": "none"})),
        (ToolChoice::Auto, json!({"kind": "auto"})),
        (ToolChoice::RequiredAny, json!({"kind": "required_any"})),
        (
            ToolChoice::RequiredNamed {
                tool_kind: ToolKindV1::Function,
                name: "read_number".into(),
            },
            // Product's canonical Function form preserves released fact/receipt digests.
            json!({"kind": "required_named", "name": "read_number"}),
        ),
        (
            ToolChoice::RequiredNamed {
                tool_kind: ToolKindV1::Custom,
                name: "read_number".into(),
            },
            json!({"kind": "required_named", "tool_kind": "custom", "name": "read_number"}),
        ),
    ] {
        let mut fact = complete_execution_facts().remove(0);
        fact["requirements"]["tool_choice"] = serde_json::to_value(&choice).unwrap();
        let payload = execution_payload(fact, 1, false);
        let projected = project_execution_payload(&serde_json::to_vec(&payload).unwrap())
            .unwrap_or_else(|error| panic!("{choice:?} was rejected: {error:?}"));
        assert_eq!(
            serde_json::to_value(projected.fact).unwrap()["requirements"]["tool_choice"],
            expected,
            "{choice:?} lost its callable identity"
        );
    }
}

#[test]
fn gateway_adapter_rejects_incomplete_or_unknown_named_tool_identity() {
    for choice in [
        json!({"kind": "required_named", "name": "read_number"}),
        json!({"kind": "required_named", "tool_kind": "unknown", "name": "read_number"}),
        json!({"kind": "required_named", "tool_kind": "function", "name": "read_number", "extra": true}),
    ] {
        let mut fact = complete_execution_facts().remove(0);
        fact["requirements"]["tool_choice"] = choice;
        let payload = execution_payload(fact, 1, false);
        assert_eq!(
            project_execution_payload(&serde_json::to_vec(&payload).unwrap()),
            Err(GatewayProjectionError::InvalidInput),
        );
    }
}

#[test]
fn gateway_adapter_projects_every_execution_fact_variant_without_loss() {
    let facts = complete_execution_facts();
    assert_eq!(facts.len(), 9);
    let mut projected_kinds = BTreeSet::new();

    for (index, fact) in facts.into_iter().enumerate() {
        let sequence = u64::try_from(index).unwrap() + 1;
        let kind = fact["kind"].as_str().unwrap().to_owned();
        let attempt_scoped = matches!(
            kind.as_str(),
            "attempt_started" | "attempt_finished" | "semantic_commit" | "usage_and_cache"
        );
        let payload = execution_payload(fact.clone(), sequence, attempt_scoped);
        let projected = project_execution_payload(&serde_json::to_vec(&payload).unwrap()).unwrap();
        let projected = serde_json::to_value(projected).unwrap();

        assert_eq!(projected["fact"], fact, "{kind} changed in projection");
        assert_eq!(projected["sequence"], sequence);
        assert_eq!(projected["attempt_id"].is_null(), !attempt_scoped);
        projected_kinds.insert(kind);
    }

    assert_eq!(
        projected_kinds,
        BTreeSet::from([
            "attempt_finished".to_owned(),
            "attempt_started".to_owned(),
            "candidate_decision".to_owned(),
            "credential_lease".to_owned(),
            "request_finished".to_owned(),
            "route_decision".to_owned(),
            "runtime_state".to_owned(),
            "semantic_commit".to_owned(),
            "usage_and_cache".to_owned(),
        ])
    );
}

#[test]
fn gateway_adapter_projects_context_hold_reasons_without_loss() {
    for (sequence, code) in ["CONTEXT_HOLD_APPLIED", "CONTEXT_HOLD_INVALIDATED"]
        .into_iter()
        .enumerate()
    {
        let mut route = complete_execution_facts().remove(0);
        route["reason_ledger"] = json!([{
            "ordinal": 0,
            "code": code,
            "group_id": null
        }]);
        let sequence = u64::try_from(sequence).unwrap() + 1;
        let payload = execution_payload(route.clone(), sequence, false);
        let projected = project_execution_payload(&serde_json::to_vec(&payload).unwrap()).unwrap();
        assert_eq!(serde_json::to_value(projected).unwrap()["fact"], route);
    }

    let mut candidate = complete_execution_facts().remove(1);
    candidate["ranking_reasons"] = json!(["CONTEXT_MODEL_HOLD", "PUBLISHED_MANUAL_ORDER"]);
    let payload = execution_payload(candidate.clone(), 3, false);
    let projected = project_execution_payload(&serde_json::to_vec(&payload).unwrap()).unwrap();
    assert_eq!(serde_json::to_value(projected).unwrap()["fact"], candidate);
}

#[test]
fn gateway_adapter_projects_previous_success_fallback_without_loss() {
    let mut route = complete_execution_facts().remove(0);
    route["reason_ledger"] = json!([{
        "ordinal": 0,
        "code": "PREVIOUS_SUCCESS_FALLBACK",
        "group_id": "primary"
    }]);
    let payload = execution_payload(route.clone(), 1, false);
    let projected = project_execution_payload(&serde_json::to_vec(&payload).unwrap()).unwrap();
    assert_eq!(serde_json::to_value(projected).unwrap()["fact"], route);

    let mut candidate = complete_execution_facts().remove(1);
    candidate["ranking_reasons"] = json!(["PREVIOUS_SUCCESS_FALLBACK"]);
    let payload = execution_payload(candidate.clone(), 2, false);
    let projected = project_execution_payload(&serde_json::to_vec(&payload).unwrap()).unwrap();
    assert_eq!(serde_json::to_value(projected).unwrap()["fact"], candidate);
}

#[test]
fn gateway_adapter_requires_plan_identity_for_branch_assessment() {
    let fact = json!({
        "kind": "branch_assessment_recorded",
        "segment_id": "segment-main",
        "plan_id": "plan/coding",
        "plan_revision": 7,
        "model_configuration_id": "model-config-main",
        "profile_digest": DIGEST,
        "trigger_request_id": "request-main",
        "target_from_turn_id": "turn-main",
        "target_through_turn_id": "turn-main",
        "target_from_ordinal": 1,
        "target_through_ordinal": 1,
        "assessed_at_ms": 1,
        "score": 0.5,
        "partial": false,
        "reason": null
    });
    let payload = execution_payload(fact.clone(), 3, false);
    let projected = project_execution_payload(&serde_json::to_vec(&payload).unwrap()).unwrap();
    assert_eq!(serde_json::to_value(projected).unwrap()["fact"], fact);

    let mut before_planner = payload;
    before_planner["agent_plan_id"] = Value::Null;
    assert_eq!(
        project_execution_payload(&serde_json::to_vec(&before_planner).unwrap()),
        Err(GatewayProjectionError::InvalidOutput)
    );
}

#[test]
fn gateway_adapter_content_event_and_rich_feedback_round_trip_without_loss() {
    let mut sequence = 1;
    for direction in ["request_input", "response_delivered"] {
        for phase in ["begin", "append", "finish", "abort"] {
            let payload = content_payload(direction, phase, sequence);
            let projected =
                project_content_payload(&serde_json::to_vec(&payload).unwrap()).unwrap();
            assert_eq!(serde_json::to_value(projected).unwrap(), payload);
            sequence += 1;
        }
    }

    let identity = ObservationFeedbackIdentityV1 {
        channel: "conversation_content".into(),
        producer_id: "producer-main".into(),
        producer_epoch: "epoch-main".into(),
        stream_id: "stream-main".into(),
    };
    let ack = ObservationAckV2 {
        schema_version: OBSERVATION_ACK_SCHEMA_V2.into(),
        identity: identity.clone(),
        highest_contiguous_sequence: 4,
        highest_accounted_sequence: 7,
        content_acknowledgement: Some(ObservationContentAcknowledgementV1 {
            request_id: "request-main".into(),
            direction: ConversationContentDirectionV2::RequestInput,
            fork_id: "fork-main".into(),
            next_chunk_ordinal: 3,
            transcript_root: Some("transcript-current".into()),
            delta_parent_transcript_root: Some("transcript-parent".into()),
            acknowledged_blobs: vec![ObservationBlobAcknowledgementV1 {
                content_id: "content-main".into(),
                digest: "blob-main".into(),
            }],
        }),
    };
    let projected_ack = project_feedback(ObservationFeedback::Ack(ack.clone()))
        .unwrap()
        .unwrap();
    assert_eq!(
        serde_json::to_value(projected_ack).unwrap(),
        serde_json::to_value(ack).unwrap()
    );

    let details = vec![
        ObservationNackDetailV1::MissingSequenceRanges {
            ranges: vec![ObservationSequenceRangeV1 {
                first_sequence: 5,
                last_sequence: 7,
            }],
        },
        ObservationNackDetailV1::UnknownTranscriptRoot {
            request_id: "request-main".into(),
            direction: ConversationContentDirectionV2::RequestInput,
            fork_id: "fork-main".into(),
            transcript_root: format!("transcript-{}", "33".repeat(32)),
        },
        ObservationNackDetailV1::MissingBlob {
            request_id: "request-main".into(),
            direction: ConversationContentDirectionV2::ResponseDelivered,
            fork_id: "fork-main".into(),
            blobs: vec![ObservationBlobAcknowledgementV1 {
                content_id: "content-main".into(),
                digest: format!("blob-{}", "22".repeat(32)),
            }],
        },
        ObservationNackDetailV1::ChunkOrdinalConflict {
            request_id: "request-main".into(),
            direction: ConversationContentDirectionV2::RequestInput,
            fork_id: "fork-main".into(),
            expected_chunk_ordinal: 3,
            rejected_chunk_ordinal: 5,
        },
        ObservationNackDetailV1::ContentStateConflict {
            request_id: "request-main".into(),
            direction: ConversationContentDirectionV2::RequestInput,
            fork_id: "fork-main".into(),
            expected_phase: ConversationContentPhaseV2::Append,
            rejected_phase: ConversationContentPhaseV2::Finish,
        },
        ObservationNackDetailV1::DigestMismatch {
            subject: ObservationDigestSubjectV1::Transcript,
            subject_id: "request-main/fork-main".into(),
            expected_digest: format!("transcript-{}", "33".repeat(32)),
            rejected_digest: format!("transcript-{}", "44".repeat(32)),
        },
    ];
    for detail in details {
        let nack = ObservationNackV1 {
            schema_version: OBSERVATION_NACK_SCHEMA_V1.into(),
            identity: identity.clone(),
            rejected_sequence: 8,
            expected_sequence: 5,
            retryable: true,
            detail,
        };
        let projected_nack = project_feedback(ObservationFeedback::Nack(nack.clone()))
            .unwrap()
            .unwrap_err();
        assert_eq!(
            serde_json::to_value(projected_nack).unwrap(),
            serde_json::to_value(nack).unwrap()
        );
    }
}

fn content_payload(direction: &str, phase: &str, sequence: u64) -> Value {
    let mut payload = json!({
        "schema_version": CONVERSATION_CONTENT_SCHEMA,
        "schema_digest": CONVERSATION_CONTENT_PORT_DIGEST,
        "channel": "conversation_content",
        "producer": producer("gateway-content"),
        "sequence": sequence,
        "event_id": format!("content-event-{sequence}"),
        "correlation": correlation(),
        "direction": direction,
        "phase": phase,
        "attempt_id": null,
        "fork_id": format!("fork-{direction}"),
        "parent_transcript_root": null,
        "result_transcript_root": null,
        "message_instance_id": null,
        "message_role": null,
        "content_kind": null,
        "content_id": null,
        "content_blob_digest": null,
        "message_ordinal": null,
        "part_ordinal": null,
        "chunk_ordinal": null,
        "transport_frame_id": null,
        "canonical_media_type": null,
        "canonical_bytes_base64": null,
        "content_ref": null,
        "downstream_delivery": null,
        "abort_reason": null,
        "occurred_at_unix_nanos": sequence,
        "loss_watermark": null,
        "completeness_delta": null
    });
    let response = direction == "response_delivered";
    if response {
        payload["attempt_id"] = json!("attempt-main");
        payload["parent_transcript_root"] = json!(format!("transcript-{}", "11".repeat(32)));
    }
    match phase {
        "begin" => {}
        "append" => {
            let digest = format!("blob-{}", "22".repeat(32));
            payload["message_instance_id"] = json!(format!("message-{direction}"));
            payload["message_role"] = json!(if response { "assistant" } else { "user" });
            payload["content_kind"] = json!("text");
            payload["content_id"] = json!(format!("content-{direction}"));
            payload["content_blob_digest"] = json!(digest);
            payload["message_ordinal"] = json!(0);
            payload["part_ordinal"] = json!(0);
            payload["chunk_ordinal"] = json!(0);
            payload["canonical_bytes_base64"] = json!("e30=");
            if response {
                payload["transport_frame_id"] = json!("frame-main");
                payload["canonical_media_type"] =
                    json!("application/vnd.hiroute.model-stream-event+json;version=1");
                payload["content_ref"] = json!({
                    "content_id": format!("content-{direction}"),
                    "digest": format!("blob-{}", "22".repeat(32)),
                    "byte_count": 2,
                    "media_type": "application/vnd.hiroute.model-stream-event+json;version=1"
                });
                payload["downstream_delivery"] = json!("full_frame_transport_accepted");
            } else {
                payload["canonical_media_type"] = json!("application/json");
            }
        }
        "finish" | "abort" => {
            payload["result_transcript_root"] = json!(format!("transcript-{}", "33".repeat(32)));
            payload["completeness_delta"] = json!(if phase == "finish" {
                "complete"
            } else {
                "partial"
            });
            if response {
                payload["downstream_delivery"] = json!("full_frame_transport_accepted");
            }
            if phase == "abort" {
                payload["abort_reason"] = json!("producer_aborted");
            }
        }
        _ => unreachable!(),
    }
    payload
}

fn execution_payload(fact: Value, sequence: u64, attempt_scoped: bool) -> Value {
    json!({
        "schema_version": EXECUTION_FACT_SCHEMA,
        "schema_digest": EXECUTION_FACT_PORT_DIGEST,
        "channel": "execution_fact",
        "producer": producer("gateway-execution"),
        "sequence": sequence,
        "event_id": format!("execution-event-{sequence}"),
        "correlation": correlation(),
        "attempt_id": attempt_scoped.then_some("attempt-main"),
        "authority_id": "authority-main",
        "authority_epoch": 3,
        "served_model_id": "hiroute/coding",
        "selector_source": "trusted_model_alias",
        "agent_plan_id": "plan/coding",
        "route": {"kind": "plan", "revision": 7, "semantic_digest": DIGEST},
        "plan_display_name": "Coding route",
        "gateway_publication_revision": "11",
        "gateway_publication_digest": DIGEST,
        "grant_id": "grant-main",
        "grant_generation": 2,
        "ingress_protocol": "responses",
        "occurred_at_unix_nanos": sequence,
        "fact": fact,
        "loss_watermark": null,
        "completeness_delta": null
    })
}

fn complete_execution_facts() -> Vec<Value> {
    vec![
        json!({
            "kind": "route_decision",
            "planner_version": "hiroute-deterministic-planner/v1",
            "plan_id": "plan/coding",
            "route": {"kind": "plan", "revision": 7, "semantic_digest": DIGEST},
            "input_digest": DIGEST,
            "policy_digest": DIGEST,
            "output_digest": DIGEST,
            "branch": "custom_exact_order",
            "complexity": null,
            "groups": [],
            "reason_ledger": [],
            "requirements": {
                "text": true,
                "image_url": false,
                "image_base64": false,
                "image_media_types": [],
                "function_tools": false,
                "strict_tools": false,
                "parallel_tools": false,
                "tool_choice": {"kind": "auto"},
                "tool_result_text": false,
                "tool_result_json": false,
                "tool_roundtrip": false,
                "logical_tool_id_mapping": false,
                "provider_state": false,
                "initial_instructions": false,
                "mid_conversation_instructions": false,
                "streaming": false,
                "stream_text": false,
                "stream_reasoning": false,
                "stream_tool_arguments": false,
                "stream_usage": false,
                "ingress_protocol": "responses"
            },
            "requested_reasoning_disposition": "absent",
            "requested_reasoning_value": null,
            "requested_max_output_tokens": null,
            "stream": false,
            "outcome": "ready",
            "outcome_code": null,
            "max_attempts": 1
        }),
        json!({
            "kind": "candidate_decision",
            "candidate_id": "candidate-main",
            "stable_binding_id": "binding-main",
            "group_id": "authorized",
            "declared_order": 0,
            "profile_digest": DIGEST,
            "ingress_protocol": "responses",
            "upstream_protocol": "responses",
            "path_id": "responses-to-responses",
            "provider_id": "provider-main",
            "endpoint_id": "endpoint-main",
            "entitlement_id": "entitlement-main",
            "connector_id": "connector-main",
            "connector_revision": "1",
            "capability_id": "exact-responses-to-responses",
            "capability_revision": "1",
            "model_configuration_id": "model-config-main",
            "native_model": "native-model-main",
            "adapter_revision": "protocol-adapter/v1",
            "serializer_revision": "target-json/v1",
            "decoder_revision": "native-response/v1",
            "target_serialized_bytes": 1,
            "eligible": true,
            "exclusion_reason": null,
            "reasoning_profile_id": "fixed",
            "overall_score_tenths": null,
            "effective_cost_micros": null,
            "api_equivalent_cost_micros": null,
            "cost_class": "free",
            "cache_cost": {"kind": "none"},
            "cache_affinity": false,
            "compute_scope_order": 0,
            "ranking_reasons": ["PUBLISHED_MANUAL_ORDER"]
        }),
        json!({
            "kind": "credential_lease",
            "stable_binding_id": "binding-main",
            "credential_ref": "credential-main",
            "key_id": "key-main",
            "credential_generation": 1,
            "excluded_key_count": 0,
            "outcome": "leased"
        }),
        json!({
            "kind": "runtime_state",
            "operation": "read_exact",
            "key_scope": "binding",
            "stable_binding_id": "binding-main",
            "credential_ref": null,
            "key_id": null,
            "expected_generation": null,
            "observed_generation": 0,
            "health": "active",
            "cooldown_remaining_millis": null,
            "probe_lease_remaining_millis": null,
            "transient_backoff_step": 0,
            "outcome": "ok"
        }),
        json!({
            "kind": "attempt_started",
            "ordinal": 1,
            "candidate_id": "candidate-main",
            "stable_binding_id": "binding-main",
            "profile_digest": DIGEST,
            "credential_ref": "credential-main",
            "key_id": "key-main",
            "provider_name": "provider-main",
            "request_model": "native-model-main",
            "upstream_protocol": "responses",
            "model_configuration_id": "model-config-main",
            "adapter_revision": "protocol-adapter/v1",
            "start_reason": "initial_candidate",
            "previous_attempt_id": null
        }),
        json!({
            "kind": "attempt_finished",
            "ordinal": 1,
            "stable_binding_id": "binding-main",
            "outcome": "accepted",
            "error_class": null,
            "retryable": null,
            "duration_micros": 1,
            "disposition": "accept",
            "provider_http_status": 200,
            "provider_code": null,
            "provider_request_id": null,
            "retry_after_millis": null,
            "reset_after_millis": null,
            "provider_readiness": "semantic_response",
            "provider_model_event": "semantic_response",
            "time_to_first_model_event_micros": null,
            "provider_ended_micros_from_start": 1,
            "transport": {
                "connect_micros": 1,
                "request_write_micros": 1,
                "upstream_ttfb_micros": 1,
                "last_upstream_progress_micros_from_start": 1,
                "local_read_suppressed_micros": 0,
                "upstream_body_bytes": 1,
                "timeout_kind": null
            },
            "commits": {
                "upstream_request": "write_confirmed",
                "downstream_headers": "write_confirmed",
                "downstream_semantic": "write_confirmed"
            },
            "stream_outcome": "completed_eos",
            "downstream_outcome": "completed",
            "cleanup_outcome": "completed",
            "termination_reason": "accepted_eos"
        }),
        json!({
            "kind": "semantic_commit",
            "ordinal": 1,
            "boundary": "full_frame_transport_accepted",
            "frame_id": "frame-main"
        }),
        json!({
            "kind": "usage_and_cache",
            "ordinal": 1,
            "source": "accepted_canonical_model_event",
            "input_tokens": 3,
            "output_tokens": 2,
            "billable_tokens": null,
            "cache_read_tokens": null,
            "cache_write_tokens": null,
            "reasoning_tokens": null,
            "input_provenance": "reported",
            "output_provenance": "reported",
            "billable_provenance": "unknown",
            "cache_read_provenance": "unknown",
            "cache_write_provenance": "unknown",
            "reasoning_provenance": "unknown",
            "effective_cost_micros": null,
            "cost_class": "free",
            "cache_status": "unknown"
        }),
        json!({
            "kind": "request_finished",
            "outcome": "accepted",
            "attempts_started": 1,
            "attempts_finished": 1,
            "accepted_attempt_ordinal": 1,
            "facts_completeness": "complete"
        }),
    ]
}