lean-ctx 3.9.8

Context Runtime for AI Agents with CCP. 71 MCP tools, 10 read modes, 95+ compression patterns, cross-session memory (CCP), persistent AI knowledge with temporal facts + contradiction detection, multi-agent context sharing, LITM-aware positioning, AAAK compact format, adaptive compression with Thompson Sampling bandits. Supports 24+ AI tools. Reduces LLM token consumption by up to 99%.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! A2A-compatible envelope for handoff transfer bundles (GL#449).
//!
//! Wraps the proprietary `HandoffTransferBundleV1` in a spec-shaped A2A Task
//! object so a foreign agent can consume a lean-ctx handoff with a plain A2A
//! parser: `id` + `status` + one `data` artifact part carrying the bundle.
//! Deterministic: every field derives from the bundle itself (no wall clock).

use serde_json::Value;

use crate::core::handoff_transfer_bundle::HandoffTransferBundleV1;

/// Media type identifying the embedded bundle payload.
pub const BUNDLE_MIME_V1: &str = "application/vnd.leanctx.handoff-bundle.v1+json";

/// Wrap a transfer bundle in an A2A Task envelope.
///
/// The task id is derived from the embedded ledger's session id and content
/// hash, so re-exporting the same handoff yields the same task id.
pub fn wrap_bundle_as_a2a_task(bundle: &HandoffTransferBundleV1) -> Result<Value, String> {
    let bundle_json =
        serde_json::to_value(bundle).map_err(|e| format!("bundle serialization failed: {e}"))?;

    let session_id = &bundle.ledger.session.id;
    let task_id = format!(
        "handoff-{session_id}-{}",
        &bundle.ledger.content_md5[..bundle.ledger.content_md5.len().min(8)]
    );

    Ok(serde_json::json!({
        "id": task_id,
        "status": {
            "state": "completed",
            "timestamp": bundle.exported_at.to_rfc3339(),
        },
        "messages": [],
        "artifacts": [{
            "type": "data",
            "mimeType": BUNDLE_MIME_V1,
            "data": bundle_json,
        }],
        "history": [],
        "metadata": {
            "producer": "lean-ctx",
            "bundleSchemaVersion": bundle.schema_version,
            "privacy": bundle.privacy,
        },
    }))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::core::handoff_ledger::HandoffLedgerV1;
    use crate::core::handoff_transfer_bundle::{ArtifactsExcerptV1, ProjectIdentityV1};

    fn sample_bundle() -> HandoffTransferBundleV1 {
        let mut ledger = HandoffLedgerV1::default();
        ledger.session.id = "sess-42".to_string();
        ledger.content_md5 = "abcdef0123456789".to_string();
        HandoffTransferBundleV1 {
            schema_version: 1,
            exported_at: chrono::DateTime::parse_from_rfc3339("2026-06-01T12:00:00Z")
                .unwrap()
                .with_timezone(&chrono::Utc),
            privacy: "redacted".to_string(),
            project: ProjectIdentityV1 {
                project_root_hash: None,
                project_identity_hash: None,
            },
            ledger,
            artifacts: ArtifactsExcerptV1::default(),
            signature: None,
            signer_public_key: None,
            signer_agent_id: None,
        }
    }

    #[test]
    fn wraps_bundle_with_required_a2a_task_fields() {
        let task = wrap_bundle_as_a2a_task(&sample_bundle()).unwrap();
        assert_eq!(task["id"], "handoff-sess-42-abcdef01");
        assert_eq!(task["status"]["state"], "completed");
        assert_eq!(task["artifacts"][0]["type"], "data");
        assert_eq!(task["artifacts"][0]["mimeType"], BUNDLE_MIME_V1);
        assert_eq!(task["artifacts"][0]["data"]["schema_version"], 1);
        assert_eq!(task["metadata"]["producer"], "lean-ctx");
    }

    #[test]
    fn wrap_is_deterministic() {
        let a = wrap_bundle_as_a2a_task(&sample_bundle()).unwrap();
        let b = wrap_bundle_as_a2a_task(&sample_bundle()).unwrap();
        assert_eq!(a, b);
    }
}