Skip to content

Personal AI, On Personal Devices

Python
11.3 KB
Raw Blame
use openjarvis_cross_device_travel::{protocol::*, runtime::*};
use serde_json::{json, Value};
use std::{cell::RefCell, collections::VecDeque, rc::Rc};

enum Reply {
    Output(Value),
    TransportError(TaskError),
    DeviceError(TaskError),
    Corrupt(fn(&mut TaskResponse)),
}

struct MockTransport {
    devices: Vec<Device>,
    calls: Rc<RefCell<Vec<TaskRequest>>>,
    replies: VecDeque<Reply>,
}

impl DeviceTransport for MockTransport {
    fn discover(&self) -> Vec<Device> {
        self.devices.clone()
    }

    fn execute(&mut self, request: &TaskRequest) -> Result<TaskResponse, TaskError> {
        self.calls.borrow_mut().push(request.clone());
        let mut response = TaskResponse {
            version: request.version,
            workflow_id: request.workflow_id.clone(),
            task_id: request.task_id.clone(),
            attempt: request.attempt,
            device_id: request.to_device.clone(),
            outcome: Outcome::Succeeded {
                output: json!({"source": request.task_id}),
            },
        };
        match self.replies.pop_front() {
            Some(Reply::Output(output)) => response.outcome = Outcome::Succeeded { output },
            Some(Reply::TransportError(error)) => return Err(error),
            Some(Reply::DeviceError(error)) => response.outcome = Outcome::Failed { error },
            Some(Reply::Corrupt(corrupt)) => corrupt(&mut response),
            None => {}
        }
        Ok(response)
    }
}

fn device(id: &str, kind: DeviceKind, online: bool, capabilities: Vec<Capability>) -> Device {
    Device {
        id: id.into(),
        kind,
        online,
        capabilities,
    }
}

fn mock(replies: Vec<Reply>) -> MockTransport {
    MockTransport {
        devices: vec![device(
            "phone",
            DeviceKind::Phone,
            true,
            vec![Capability::MobileContext, Capability::SaveDraft],
        )],
        calls: Rc::new(RefCell::new(Vec::new())),
        replies: replies.into(),
    }
}

fn task(id: &str, depends_on: &[&str], optional: bool) -> TaskSpec {
    TaskSpec {
        id: id.into(),
        capability: Capability::MobileContext,
        device_kind: DeviceKind::Phone,
        depends_on: depends_on.iter().map(|id| (*id).into()).collect(),
        optional,
        input: json!({"requested": id}),
    }
}

fn error(code: ErrorCode, retryable: bool) -> TaskError {
    TaskError::new(code, "simulated failure", retryable)
}

fn failed(report: &RunReport, id: &str) -> ErrorCode {
    match &report.results[id] {
        Outcome::Failed { error } => error.code,
        other => panic!("expected failure for {id}, got {other:?}"),
    }
}

#[test]
fn routing_requires_placement_and_capability_and_distinguishes_offline() {
    let requested = task("context", &[], false);
    let wrong_kind = device(
        "laptop",
        DeviceKind::Laptop,
        true,
        vec![Capability::MobileContext],
    );
    let wrong_capability = device(
        "phone",
        DeviceKind::Phone,
        true,
        vec![Capability::SaveDraft],
    );
    let offline = device(
        "offline",
        DeviceKind::Phone,
        false,
        vec![Capability::MobileContext],
    );
    assert_eq!(
        route(&[wrong_kind.clone(), wrong_capability.clone()], &requested)
            .unwrap_err()
            .code,
        ErrorCode::NoCapability
    );
    assert_eq!(
        route(&[wrong_kind, wrong_capability, offline.clone()], &requested)
            .unwrap_err()
            .code,
        ErrorCode::DeviceUnavailable
    );
    let a = device(
        "a",
        DeviceKind::Phone,
        true,
        vec![Capability::MobileContext],
    );
    let z = device(
        "z",
        DeviceKind::Phone,
        true,
        vec![Capability::MobileContext],
    );
    for devices in [
        vec![z.clone(), offline.clone(), a.clone()],
        vec![a, offline, z],
    ] {
        assert_eq!(route(&devices, &requested).unwrap().id, "a");
    }
}

#[test]
fn invalid_plans_and_device_identities_fail_before_any_dispatch() {
    let cases = vec![
        ("", vec![task("a", &[], false)]),
        ("run", vec![]),
        ("run", vec![task("", &[], false)]),
        ("run", vec![task("a", &[], false), task("a", &[], false)]),
        ("run", vec![task("a", &["missing"], false)]),
        ("run", vec![task("a", &["a"], false)]),
        ("run", vec![task("a", &["b"], false), task("b", &[], false)]),
        (
            "run",
            vec![task("a", &["b"], false), task("b", &["a"], false)],
        ),
    ];
    for (workflow, plan) in cases {
        let transport = mock(vec![]);
        let calls = transport.calls.clone();
        let result = Orchestrator::new("laptop", transport).run(workflow, &plan);
        assert_eq!(result.unwrap_err().code, ErrorCode::ProtocolError);
        assert!(calls.borrow().is_empty());
    }
    for duplicate in [false, true] {
        let mut transport = mock(vec![]);
        if duplicate {
            transport.devices.push(transport.devices[0].clone());
        } else {
            transport.devices[0].id.clear();
        }
        let calls = transport.calls.clone();
        let result = Orchestrator::new("laptop", transport).run("run", &[task("a", &[], false)]);
        assert_eq!(result.unwrap_err().code, ErrorCode::ProtocolError);
        assert!(calls.borrow().is_empty());
    }
}

#[test]
fn context_contains_only_declared_successes_and_omits_optional_failure() {
    let transport = mock(vec![
        Reply::Output(json!({"private": "unrelated"})),
        Reply::Output(json!({"city": "Paris"})),
        Reply::DeviceError(error(ErrorCode::PermissionDenied, false)),
    ]);
    let calls = transport.calls.clone();
    let plan = [
        task("unrelated", &[], false),
        task("location", &[], false),
        task("photos", &[], true),
        task("plan", &["location", "photos"], false),
    ];
    let report = Orchestrator::new("laptop", transport)
        .run("run", &plan)
        .unwrap();
    assert!(!report.aborted);
    assert_eq!(failed(&report, "photos"), ErrorCode::PermissionDenied);
    let calls = calls.borrow();
    assert!(calls[..3].iter().all(|request| request.context.is_empty()));
    assert_eq!(
        calls[3].context,
        [("location".into(), json!({"city": "Paris"}))].into()
    );
    assert_eq!(calls[3].input, plan[3].input);
}

#[test]
fn correlation_rejects_every_mismatched_field_including_a_late_retry_response() {
    let corruptions: [fn(&mut TaskResponse); 5] = [
        |r| r.version += 1,
        |r| r.workflow_id.push('x'),
        |r| r.task_id.push('x'),
        |r| r.attempt += 1,
        |r| r.device_id.push('x'),
    ];
    for corrupt in corruptions {
        let transport = mock(vec![Reply::Corrupt(corrupt)]);
        let calls = transport.calls.clone();
        let report = Orchestrator::new("laptop", transport)
            .run("run", &[task("a", &[], false)])
            .unwrap();
        assert_eq!(failed(&report, "a"), ErrorCode::ProtocolError);
        assert_eq!(calls.borrow().len(), 1);
        assert!(!report
            .events
            .iter()
            .any(|event| matches!(event, TraceEvent::Response { .. })));
    }
    let transport = mock(vec![
        Reply::TransportError(error(ErrorCode::Timeout, true)),
        Reply::Corrupt(|r| r.attempt = 1),
    ]);
    let calls = transport.calls.clone();
    let report = Orchestrator::new("laptop", transport)
        .run("run", &[task("a", &[], false)])
        .unwrap();
    assert_eq!(failed(&report, "a"), ErrorCode::ProtocolError);
    assert_eq!(calls.borrow().len(), 2);
}

#[test]
fn read_retry_preserves_identity_payload_context_and_target() {
    for first in [
        Reply::TransportError(error(ErrorCode::Timeout, true)),
        Reply::DeviceError(error(ErrorCode::ExecutionFailed, true)),
    ] {
        let transport = mock(vec![Reply::Output(json!({"city": "Paris"})), first]);
        let calls = transport.calls.clone();
        let plan = [
            task("context", &[], false),
            task("read", &["context"], false),
        ];
        let report = Orchestrator::new("laptop", transport)
            .run("run", &plan)
            .unwrap();
        assert!(!report.aborted);
        assert!(matches!(report.results["read"], Outcome::Succeeded { .. }));
        let calls = calls.borrow();
        assert_eq!(calls.len(), 3);
        assert_eq!((calls[1].attempt, calls[2].attempt), (1, 2));
        let mut retried = calls[2].clone();
        retried.attempt = 1;
        assert_eq!(calls[1], retried);
        assert!(retried.timeout_ms > 0);
        assert_eq!(retried.context["context"], json!({"city": "Paris"}));
    }
}

#[test]
fn retries_are_bounded_and_require_both_transient_code_and_retryable_flag() {
    for (code, retryable, attempts) in [
        (ErrorCode::Timeout, true, 2),
        (ErrorCode::DeviceUnavailable, true, 2),
        (ErrorCode::ExecutionFailed, true, 2),
        (ErrorCode::Timeout, false, 1),
        (ErrorCode::PermissionDenied, true, 1),
        (ErrorCode::ProtocolError, true, 1),
    ] {
        let transport = mock(vec![
            Reply::DeviceError(error(code, retryable)),
            Reply::DeviceError(error(code, retryable)),
        ]);
        let calls = transport.calls.clone();
        let report = Orchestrator::new("laptop", transport)
            .run("run", &[task("a", &[], false)])
            .unwrap();
        assert_eq!(failed(&report, "a"), code);
        assert!(report.aborted);
        assert_eq!(
            calls.borrow().len(),
            attempts,
            "{code:?}, retryable={retryable}"
        );
    }
}

#[test]
fn uncertain_writes_are_never_replayed() {
    for reply in [
        Reply::TransportError(error(ErrorCode::Timeout, true)),
        Reply::DeviceError(error(ErrorCode::ExecutionFailed, true)),
    ] {
        let transport = mock(vec![reply]);
        let calls = transport.calls.clone();
        let mut action = task("save", &[], true);
        action.capability = Capability::SaveDraft;
        let report = Orchestrator::new("laptop", transport)
            .run("run", &[action])
            .unwrap();
        assert!(matches!(report.results["save"], Outcome::Failed { .. }));
        assert_eq!(calls.borrow().len(), 1);
    }
}

#[test]
fn required_failure_skips_dependent_actions_instead_of_using_partial_context() {
    for offline in [false, true] {
        let mut transport = mock(vec![Reply::DeviceError(error(
            ErrorCode::PermissionDenied,
            false,
        ))]);
        transport.devices[0].online = !offline;
        let calls = transport.calls.clone();
        let mut action = task("save", &["required"], true);
        action.capability = Capability::SaveDraft;
        let report = Orchestrator::new("laptop", transport)
            .run("run", &[task("required", &[], false), action])
            .unwrap();
        assert!(report.aborted);
        assert!(!report.results.contains_key("save"));
        assert!(report.events.iter().any(|event| matches!(event,
            TraceEvent::Skipped { task_id, .. } if task_id == "save")));
        assert_eq!(calls.borrow().len(), usize::from(!offline));
        if offline {
            assert_eq!(failed(&report, "required"), ErrorCode::DeviceUnavailable);
            assert!(matches!(
                report.events.first(),
                Some(TraceEvent::Failure { attempt: 0, .. })
            ));
        }
    }
}