xynthe 0.1.0

A unified orchestration framework for autonomous intelligence with temporal continuity
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
96
97
98
99
100

//! Execution Engine example - demonstrates G-TEL execution loop
//!
//! Run with: cargo run --example execution_engine

use xynthe::prelude::*;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<()> {
    println!("=== Xynthe Execution Engine Example ===\n");

    // 1. Initialize the execution engine
    println!("1. Initializing Execution Engine components...");

    let thought_stream = Arc::new(ThoughtStream::new("main"));
    let capability_registry = Arc::new(CapabilityRegistry::new());
    let context_fabric = Arc::new(ContextFabric::new());

    println!("   ✓ Thought stream created");
    println!("   ✓ Capability registry initialized");
    println!("   ✓ Context fabric ready\n");

    // 2. Create an execution intent
    println!("2. Creating execution intent...");
    let intent = ExecutionIntent::new(
        "Process weather data for San Francisco",
        StructuredContent::json(serde_json::json!({
            "location": "San Francisco, CA",
            "data_type": "weather_forecast",
            "timeframe": "next_7_days"
        })),
    )
    .with_priority(75);

    println!("   Intent: {}", intent.description);
    println!("   Priority: {}", intent.priority);
    println!("   ✓ Intent created with ID: {}\n", intent.id);

    // 3. Set up the execution engine
    println!("3. Constructing execution engine...");
    let engine = ExecutionEngine::new(
        thought_stream.clone(),
        capability_registry.clone(),
        context_fabric.clone(),
    );

    let initial_state = engine.state().await;
    println!("   Initial state: {}", initial_state.as_str());
    println!("   ✓ Execution engine ready\n");

    // 4. Execute the intent
    println!("4. Executing intent through G-TEL loop...");
    match engine.execute(intent).await {
        Ok(result) => {
            println!("   ✓ Execution completed successfully!");
            println!("   Steps executed: {}", result.steps_executed);
            println!("   Trace ID: {}", result.trace_id);
            println!("   Result: {:?}\n", result.data.as_text());
        }
        Err(e) => {
            println!("   ✗ Execution failed: {}\n", e);
        }
    }

    // 5. Inspect execution state and statistics
    println!("5. Inspecting execution metrics...");
    let final_state = engine.state().await;
    println!("   Final state: {}", final_state.as_str());

    let stats = engine.stats().await;
    println!("   Total steps: {}", stats.total_steps);
    println!("   Completed steps: {}", stats.completed_steps);
    println!("   Failed steps: {}", stats.failed_steps);
    println!("   Total duration: {} ms\n", stats.total_duration_ms);

    // 6. Retrieve execution trace
    println!("6. Retrieving execution trace...");
    let trace_recorder = engine.trace_recorder();
    let trace = trace_recorder.current_trace().await;

    println!("   Trace events: {}", trace.events.len());
    println!("   Agent ID: {}", trace.agent_id);
    println!("   Successful execution: {}\n", trace.is_successful());

    // 7. List all traces in archive
    println!("7. Querying trace archive...");
    let archive = trace_recorder.archive().await;
    println!("   Traces in archive: {}\n", archive.len());

    println!("=== Execution Engine Example Completed ===\n");
    println!("G-TEL phases demonstrated:");
    println!("  ✓ Perceive: Intent ingestion");
    println!("  ✓ Reason: Goal decomposition");
    println!("  ✓ Assign: Layer routing");
    println!("  ✓ Act: Execution (simulated)");
    println!("  ✓ Reflect: Outcome evaluation");
    println!("  ✓ Trace: Immutable recording");

    Ok(())
}