OpenJarvis 1.0.4.dev1122__tar.gz → 1.0.4.dev1124__tar.gz

{openjarvis-1.0.4.dev1122 → openjarvis-1.0.4.dev1124}/.github/workflows/ci.yml

@@ -179,3 +179,10 @@ jobs:
 
       - name: Test
         run: cargo test --workspace
+
+      # Standalone handoff example: intentionally not a runtime workspace member.
+      - name: Cross-device travel example
+        run: |
+          cargo fmt --manifest-path ../examples/cross_device_travel/Cargo.toml --check
+          cargo clippy --locked --manifest-path ../examples/cross_device_travel/Cargo.toml --all-targets -- -D warnings
+          cargo test --locked --manifest-path ../examples/cross_device_travel/Cargo.toml

{openjarvis-1.0.4.dev1122 → openjarvis-1.0.4.dev1124}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: OpenJarvis
-Version: 1.0.4.dev1122
+Version: 1.0.4.dev1124
 Summary: OpenJarvis — modular AI assistant backend with composable intelligence primitives
 Project-URL: Homepage, https://github.com/open-jarvis/OpenJarvis
 Project-URL: Documentation, https://open-jarvis.github.io/OpenJarvis/

openjarvis-1.0.4.dev1124/examples/cross_device_travel/Cargo.lock

@@ -0,0 +1,107 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "openjarvis-cross-device-travel"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.151"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

openjarvis-1.0.4.dev1124/examples/cross_device_travel/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "openjarvis-cross-device-travel"
+version = "0.1.0"
+edition = "2021"
+rust-version = "1.88"
+publish = false
+
+# An isolated handoff example: no changes to the OpenJarvis runtime or workspace.
+[workspace]
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"

openjarvis-1.0.4.dev1124/examples/cross_device_travel/README.md

@@ -0,0 +1,213 @@
+# Cross-device travel planning handoff
+
+A standalone Rust template for a laptop coordinating work with a phone for
+**“Make travel plans for me.”** It demonstrates device ownership, task messages,
+routing, and failure behavior before building real infrastructure.
+
+Everything is deterministic and synthetic. Both devices run in one process;
+requests and responses cross an in-memory JSON serialization boundary. There is
+no network connection, mobile integration, real model inference, live travel research,
+calendar write, or booking. Saving a draft only changes synthetic in-memory state.
+
+## Run it
+
+Requires Rust 1.88 or later. Run these commands from the repository root:
+
+```sh
+cargo run --manifest-path examples/cross_device_travel/Cargo.toml -- happy
+cargo test --manifest-path examples/cross_device_travel/Cargo.toml
+```
+
+CI also runs this crate's formatting, Clippy, and tests independently.
+
+The executable prints JSON. `report.events` contains the full task request and
+response messages; `final_output` contains the assembled result. The checked-in
+[happy-path trace](traces/happy.json) is generated by the same executable:
+
+```sh
+cargo run --quiet --manifest-path examples/cross_device_travel/Cargo.toml -- happy > examples/cross_device_travel/traces/happy.json
+```
+
+Pass one scenario name after `--` (default: `happy`; `--help` lists options).
+An aborted workflow still prints its report and exits with status 1.
+
+| Scenario | Demonstrates |
+| --- | --- |
+| `happy` | Phone context, laptop research and planning, then a phone draft. |
+| `phone-offline` | Optional phone work is unavailable; laptop planning proceeds with explicit gaps. |
+| `photos-denied` | Photo access fails; other context still contributes to the plan. |
+| `research-retry` | A transient research failure is retried within a fixed limit. |
+| `save-timeout` | A phone draft times out; the action is not retried automatically. |
+| `laptop-offline` | Required laptop work cannot run; the workflow aborts. |
+
+This crate builds independently of the main Rust workspace.
+
+## Walkthrough
+
+The laptop creates a fixed, topologically ordered task list for this exact request
+and synthetic trip assumptions. A future general natural-language planner can
+produce the same task structures. The happy path plans three days in Montreal
+from Boston, using phone-provided dates and interests.
+
+The happy trace executes these six steps sequentially, one successful attempt each:
+
+| Task / executor | Input and dependency outputs | Synthetic output |
+| --- | --- | --- |
+| `mobile_context` / phone | Fixed travel request. | Origin: Boston; timezone: `America/New_York`. |
+| `photo_interests` / phone | Fixed travel request. | Interest summary: architecture and parks. |
+| `calendar` / phone | Fixed travel request. | Available dates: October 16–18, 2026. |
+| `research` / laptop | Destination: Montreal; `mobile_context` + `photo_interests`. | Air/rail candidates and a central-area stay, all synthetic and unverified. |
+| `plan` / laptop | Model profile: `large_local`; `mobile_context` + `calendar` + `research`. | Oct 16 arrival, Oct 17 architecture, Oct 18 parks/return; selects the air/stay fixtures; execution backend: `mock`. |
+| `save_draft` / phone | Completed `plan`. | Draft `travel-demo-001:save_draft` in demo memory; no bookings. |
+
+Dependency flow: `mobile_context + photo_interests → research`;
+`mobile_context + calendar + research → plan`; `plan → save_draft`.
+Research and planning are required; their failure aborts the remaining workflow.
+Phone tasks are optional; failures produce explicit gaps or an unsuccessful draft.
+The assembled `final_output` has `status: "completed"`, the plan, no warnings,
+and `draft_status: "saved_in_demo_memory"` on this happy path.
+
+The phone returns summaries and availability rather than its raw photo library.
+The laptop owns research and larger planning steps. Routing requires the requested
+capability, device kind, and online status, with a stable device-ID tie break. An
+unavailable phone capability does not silently migrate to the laptop. Discovery
+assumes one user's single paired phone; it does not authenticate device ownership.
+
+Only successful outputs from explicitly declared dependencies enter a task's
+`context`. Failed optional dependencies are omitted; their failures remain visible
+in the trace. The final report preserves missing inputs and unsuccessful actions
+so a partial plan cannot be mistaken for a confirmed booking or calendar update.
+Missing calendar context produces unconfirmed dates. Supplied `available_dates` must
+contain exactly three nonempty strings; invalid payload shapes are rejected.
+
+## Code and interfaces
+
+| File | Responsibility and replacement point |
+| --- | --- |
+| [`src/protocol.rs`](src/protocol.rs) | Serde request/response types and independent protocol version 1. |
+| [`src/runtime.rs`](src/runtime.rs) | `DeviceTransport`, discovery, routing, dependency context, retries, and failure handling. |
+| [`src/travel.rs`](src/travel.rs) | Laptop decomposition, phone fixtures, mock device dispatch, and final output assembly. |
+| [`src/laptop.rs`](src/laptop.rs) | `research_travel` option records and the `LaptopPlanner` inference boundary; validates scheduling context and consumes research options. |
+| [`src/main.rs`](src/main.rs) | Scenario selection and JSON report output. |
+
+The same workflow can be invoked from Rust:
+
+```rust
+use openjarvis_cross_device_travel::runtime::Orchestrator;
+use openjarvis_cross_device_travel::travel::{decompose, DemoTransport, Scenario};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let tasks = decompose("Make travel plans for me.")?;
+    let transport = DemoTransport::new(Scenario::Happy);
+    let report = Orchestrator::new("laptop", transport).run("travel-demo-001", &tasks)?;
+    assert!(!report.aborted);
+    Ok(())
+}
+```
+
+The laptop handlers expose concrete research and heavier-model replacement points:
+
+```rust
+use std::collections::BTreeMap;
+use serde_json::Value;
+use openjarvis_cross_device_travel::protocol::TaskError;
+use openjarvis_cross_device_travel::laptop::{
+    research_travel, LaptopPlanner, MockLaptopPlanner, PlannerRequest,
+};
+
+fn run_laptop_steps(
+    research_context: &BTreeMap<String, Value>,
+    planning_context: &mut BTreeMap<String, Value>,
+) -> Result<Value, TaskError> {
+    let findings = research_travel("Montreal", research_context)?;
+    planning_context.insert("research".into(), findings);
+    MockLaptopPlanner.plan(PlannerRequest {
+        model_profile: "large_local", context: planning_context,
+    })
+}
+```
+
+Here research context contains successful `mobile_context` and `photo_interests`
+outputs; planning context starts with successful `mobile_context` and `calendar`
+outputs. `large_local` describes intended laptop placement; `MockLaptopPlanner`
+returns deterministic fixtures without loading a model. Replace its `LaptopPlanner`
+implementation with local inference, retaining the request/result boundary.
+
+`DeviceTransport::discover` supplies device advertisements to the laptop.
+The runtime selects a device by capability and device kind, then calls
+`DeviceTransport::execute` with an addressed task request. The mock adapter
+decodes that request, calls the corresponding phone or laptop fixture handler,
+and returns a typed response. Replace the transport to cross a real process or
+device boundary; replace fixture handlers to call mobile APIs or laptop tools.
+
+The protocol is a demo contract, not an implementation of the A2A specification.
+The trace is an executable example of the following envelopes:
+
+| Request field | Meaning |
+| --- | --- |
+| `version` | Demo protocol version. |
+| `workflow_id`, `task_id` | Correlate the workflow and stable logical task. |
+| `attempt` | Distinguish attempts of that same task. |
+| `from_device`, `to_device` | Identify sender and selected executor. |
+| `capability` | Name the requested device function. |
+| `input` | Task-specific arguments. |
+| `context` | Successful outputs from declared dependencies. |
+| `timeout_ms` | Execution timeout budget for the transport to enforce. |
+
+Responses carry `version`, `workflow_id`, `task_id`, `attempt`, and `device_id`,
+plus an `outcome` tagged with `status: "succeeded"` or `status: "failed"`. The runtime
+validates every response correlation field before accepting an output. It also
+rejects empty or duplicate task IDs and invalid dependency order before dispatch.
+
+Read capabilities get at most two attempts, and actions get one. Retries require
+a retryable timeout, unavailable-device error, or execution failure. Routing
+failures do not dispatch or retry; rediscovery requires another workflow run.
+A write timeout can mean the action happened but its reply was lost; `save_draft`
+is therefore never automatically retried. Any failed dispatched draft is
+conservatively reported as uncertain, including a disconnect or invalid reply;
+`not_saved` is reserved for routing failures that prevented dispatch.
+Stable task IDs support future
+idempotency work but do not provide durable deduplication or exactly-once delivery.
+
+Timeout enforcement belongs to the transport. The mock explicitly simulates
+timeouts; it does not start a real timer or interrupt running work.
+
+## OpenJarvis integration map
+
+These future integration points are outside the demo's runtime and dependencies.
+
+| Existing interface | Proposed adapter |
+| --- | --- |
+| `rust/crates/openjarvis-agents/src/traits.rs`: `OjAgent::run` | Wrap the laptop workflow as an agent; map `AgentContext` and `AgentResult` metadata to workflow context and results. |
+| `rust/crates/openjarvis-tools/src/traits.rs`: `BaseTool` | Expose device dispatch with a `ToolSpec` argument schema and a `ToolResult` response. |
+| `src/openjarvis/a2a/client.py`: `A2AClient` | Adapt discovery to agent cards and dispatch to the existing `tasks/send` endpoint. |
+| `src/openjarvis/a2a/tool.py`: `A2AAgentTool` | Follow the existing remote-agent-as-tool pattern for Python orchestration. |
+| `rust/crates/openjarvis-core/src/hardware.rs`: `detect_hardware` | Populate laptop compute advertisements; peer discovery still needs its own adapter. |
+| `rust/crates/openjarvis-core/src/types.rs`: `Trace`, `TraceStep` | Record routing, tool calls, and responses in OpenJarvis tracing. |
+
+Integration needs explicit adaptation. Rust A2A currently uses
+`pending/active/cancelled`, whereas Python uses `submitted/working/canceled`;
+their agent-card and task fields also differ. Do not forward these demo messages
+directly into either implementation and assume compatibility. A production
+adapter should check JSON-RPC errors and task completion explicitly.
+
+The Rust `OrchestratorAgent` currently performs a single model chat and leaves
+multi-turn tool dispatch for future work. Its `ToolExecutor` registers a closed
+`BuiltinTool` enum, so adding an arbitrary remote `BaseTool` also requires an
+integration change. Those changes are outside this example's scope.
+
+## Productionization decisions
+
+- Replace static advertisements with authenticated discovery, capability versions,
+  permission state, and reachability/expiry handling. Bind private data to its
+  specific owning device and user, beyond the demo's device-kind constraint.
+- Add an actual transport with enforced deadlines, device identity, reconnect
+  behavior, and payload limits; retain the runtime's response correlation checks.
+- Add persistent task state, action idempotency, timeout reconciliation, and
+  cancellation semantics before retrying actions across device disconnects.
+- Replace fixtures with phone permission-aware data adapters, real research tools,
+  and a laptop planner that asks for missing trip constraints.
+- Define consent and data-minimization rules for real phone context; keep raw
+  private data on its owning device where possible.
+- Extend static dependency validation to generated plans, and add concurrent
+  scheduling and durable trace storage when the execution model needs them.

openjarvis-1.0.4.dev1124/examples/cross_device_travel/src/laptop.rs

@@ -0,0 +1,237 @@
+//! Laptop research and heavy-model replacement points. Everything here is a fixture;
+//! no model, search provider, transport timetable, or booking service is invoked.
+use crate::protocol::{ErrorCode, TaskError};
+use serde_json::{json, Value};
+use std::collections::BTreeMap;
+
+fn invalid(message: impl Into<String>) -> TaskError {
+    TaskError::new(ErrorCode::ProtocolError, message, false)
+}
+
+fn text<'a>(value: &'a Value, field: &str) -> Result<&'a str, TaskError> {
+    value
+        .get(field)
+        .and_then(Value::as_str)
+        .filter(|s| !s.trim().is_empty())
+        .ok_or_else(|| invalid(format!("{field} must be a nonempty string")))
+}
+
+fn strings(value: &Value, field: &str) -> Result<Vec<String>, TaskError> {
+    let values: Vec<String> = serde_json::from_value(value[field].clone())
+        .map_err(|_| invalid(format!("{field} must be an array of strings")))?;
+    if values.is_empty() || values.iter().any(|s| s.trim().is_empty()) {
+        return Err(invalid(format!("{field} must contain nonempty strings")));
+    }
+    Ok(values)
+}
+
+fn origin(context: &BTreeMap<String, Value>) -> Result<&str, TaskError> {
+    match context.get("mobile_context") {
+        Some(value) => text(value, "origin"),
+        None => Ok("unconfirmed"),
+    }
+}
+
+/// Replace the fixture records with search-provider results behind this interface.
+/// The records illustrate candidates, not verified routes or available inventory.
+pub fn research_travel(
+    destination: &str,
+    context: &BTreeMap<String, Value>,
+) -> Result<Value, TaskError> {
+    if destination.trim().is_empty() {
+        return Err(invalid("destination must be a nonempty string"));
+    }
+    let origin = origin(context)?;
+    let (interests, source) = match context.get("photo_interests") {
+        Some(value) => (strings(value, "interests")?, "synthetic_phone_summary"),
+        None => (
+            vec!["city walks".into(), "neighborhood food".into()],
+            "assumed_generic_preferences",
+        ),
+    };
+    let transport_options: Vec<_> = ["air", "rail"]
+        .into_iter()
+        .map(|mode| {
+            json!({
+                "id": format!("fixture-{mode}"), "mode": mode,
+                "origin": origin, "destination": destination,
+                "verification": "unverified", "synthetic": true
+            })
+        })
+        .collect();
+    Ok(json!({
+        "destination": destination, "departure_origin": origin,
+        "interests": interests, "interest_source": source,
+        "transport_research": format!("Compare transport from {origin} to {destination}; schedules and fares unverified"),
+        "lodging_research": "Compare central accommodation; availability and prices unverified",
+        "transport_options": transport_options,
+        "lodging_options": [{"id": "fixture-central-stay", "area": "Central area",
+            "destination": destination, "verification": "unverified", "synthetic": true}],
+        "evidence": "Hypothetical fixture; no live research or cited sources"
+    }))
+}
+
+pub struct PlannerRequest<'a> {
+    pub model_profile: &'a str,
+    pub context: &'a BTreeMap<String, Value>,
+}
+
+/// A production adapter can invoke a larger local model here, retaining schema
+/// validation and caller-provided context. Device routing stays in the orchestrator.
+pub trait LaptopPlanner {
+    fn plan(&self, request: PlannerRequest<'_>) -> Result<Value, TaskError>;
+}
+
+pub struct MockLaptopPlanner;
+
+fn options<'a>(
+    research: &'a Value,
+    field: &str,
+    required: &[&str],
+) -> Result<&'a [Value], TaskError> {
+    let records = research[field]
+        .as_array()
+        .filter(|v| !v.is_empty())
+        .ok_or_else(|| invalid(format!("{field} must contain candidate records")))?;
+    for record in records {
+        for key in required {
+            text(record, key)?;
+        }
+        if text(record, "destination")? != text(research, "destination")?
+            || text(record, "verification")? != "unverified"
+            || record["synthetic"] != true
+        {
+            return Err(invalid(format!(
+                "{field} must contain matching unverified fixtures"
+            )));
+        }
+    }
+    Ok(records)
+}
+
+impl LaptopPlanner for MockLaptopPlanner {
+    fn plan(&self, request: PlannerRequest<'_>) -> Result<Value, TaskError> {
+        if request.model_profile != "large_local" {
+            return Err(invalid(
+                "The mock laptop planner supports model_profile=large_local only",
+            ));
+        }
+        let context = request.context;
+        let research = context
+            .get("research")
+            .ok_or_else(|| invalid("Research output required"))?;
+        let destination = text(research, "destination")?;
+        let origin = origin(context)?;
+        if text(research, "departure_origin")? != origin {
+            return Err(invalid(
+                "Research departure_origin must match mobile context or its fallback",
+            ));
+        }
+        let interests = strings(research, "interests")?;
+        for field in [
+            "interest_source",
+            "transport_research",
+            "lodging_research",
+            "evidence",
+        ] {
+            text(research, field)?;
+        }
+        let transport = options(research, "transport_options", &["id", "mode", "origin"])?;
+        if transport.iter().any(|record| record["origin"] != origin) {
+            return Err(invalid("Transport candidates must match departure_origin"));
+        }
+        let lodging = options(research, "lodging_options", &["id", "area"])?;
+        // Missing optional context permits a labeled fallback. Supplied malformed
+        // context is a protocol failure, never evidence of calendar availability.
+        let dates: [String; 3] = match context.get("calendar") {
+            None => std::array::from_fn(|_| "unconfirmed".into()),
+            Some(calendar) => {
+                serde_json::from_value(calendar["available_dates"].clone()).map_err(|_| {
+                    invalid("Calendar available_dates must contain exactly three strings")
+                })?
+            }
+        };
+        if dates.iter().any(|date| date.trim().is_empty()) {
+            return Err(invalid("Calendar dates must be nonempty strings"));
+        }
+        let itinerary: Vec<_> = dates.iter().enumerate().map(|(day, date)| json!({
+            "day": day + 1, "date": date,
+            "activity": match day {
+                0 => "Arrival and orientation".to_string(),
+                1 => format!("Explore {} in {destination}", interests[0]),
+                _ => format!("Explore {}; return travel", interests.get(1).map(String::as_str).unwrap_or("local neighborhoods"))
+            }
+        })).collect();
+        Ok(json!({
+            "title": format!("Hypothetical three-day {destination} trip"),
+            "origin": origin, "research": research, "itinerary": itinerary,
+            "selected_options": {"transport": transport[0], "lodging": lodging[0]},
+            "execution": {"model_profile": request.model_profile, "backend": "mock"},
+            "scheduling": {
+                "dates": dates,
+                "dates_status": if context.contains_key("calendar") {
+                    "supported_by_synthetic_phone_availability"
+                } else { "unconfirmed" },
+                "requires_user_confirmation": true,
+                "next_steps": ["Confirm origin, dates, and interests", "Verify transport, lodging, and opening hours"]
+            },
+            "assumptions": [format!("{destination} is an illustrative destination"), "No budget provided"],
+            "synthetic": true
+        }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn planner_consumes_research_candidates_and_destination() {
+        let mut context = BTreeMap::from([
+            ("mobile_context".into(), json!({"origin": "Boston"})),
+            (
+                "photo_interests".into(),
+                json!({"interests": ["museums", "gardens"]}),
+            ),
+        ]);
+        let mut research = research_travel("Quebec City", &context).unwrap();
+        research["lodging_options"][0]["area"] = json!("Museum quarter");
+        context.insert("research".into(), research);
+        let plan = MockLaptopPlanner
+            .plan(PlannerRequest {
+                model_profile: "large_local",
+                context: &context,
+            })
+            .unwrap();
+        assert_eq!(plan["title"], "Hypothetical three-day Quebec City trip");
+        assert_eq!(
+            plan["itinerary"][1]["activity"],
+            "Explore museums in Quebec City"
+        );
+        assert_eq!(
+            plan["selected_options"]["lodging"]["area"],
+            "Museum quarter"
+        );
+        assert_eq!(plan["selected_options"]["transport"]["origin"], "Boston");
+        assert_eq!(
+            plan["selected_options"]["transport"]["destination"],
+            "Quebec City"
+        );
+        assert_eq!(
+            plan["execution"],
+            json!({"model_profile": "large_local", "backend": "mock"})
+        );
+    }
+
+    #[test]
+    fn unsupported_model_profile_is_a_nonretryable_protocol_error() {
+        let error = MockLaptopPlanner
+            .plan(PlannerRequest {
+                model_profile: "cloud",
+                context: &BTreeMap::new(),
+            })
+            .unwrap_err();
+        assert_eq!(error.code, ErrorCode::ProtocolError);
+        assert!(!error.retryable);
+    }
+}

openjarvis-1.0.4.dev1124/examples/cross_device_travel/src/lib.rs

@@ -0,0 +1,7 @@
+//! Illustrative cross-device execution; all demo data and device actions are synthetic.
+#![doc = include_str!("../README.md")]
+
+pub mod laptop;
+pub mod protocol;
+pub mod runtime;
+pub mod travel;

openjarvis-1.0.4.dev1124/examples/cross_device_travel/src/main.rs

@@ -0,0 +1,41 @@
+use openjarvis_cross_device_travel::travel::{run_demo, Scenario};
+use std::process::ExitCode;
+
+fn main() -> ExitCode {
+    let args: Vec<_> = std::env::args().skip(1).collect();
+    if args.len() == 1 && matches!(args[0].as_str(), "--help" | "-h") {
+        println!(
+            "Usage: cargo run -- [scenario]\nScenarios: {}\nDefault: happy",
+            Scenario::NAMES
+        );
+        return ExitCode::SUCCESS;
+    }
+    if args.len() > 1 {
+        eprintln!("Expected at most one scenario. Use --help for usage.");
+        return ExitCode::from(2);
+    }
+    let scenario = match Scenario::parse(args.first().map(String::as_str).unwrap_or("happy")) {
+        Ok(scenario) => scenario,
+        Err(error) => {
+            eprintln!("{error}");
+            return ExitCode::from(2);
+        }
+    };
+    match run_demo(scenario) {
+        Ok(value) => {
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&value).expect("JSON Value serializes")
+            );
+            if value["report"]["aborted"] == true {
+                ExitCode::FAILURE
+            } else {
+                ExitCode::SUCCESS
+            }
+        }
+        Err(error) => {
+            eprintln!("{error}");
+            ExitCode::FAILURE
+        }
+    }
+}