dimensionalOS
diff --git a/‎dimos/agents/skills/google_maps_skill_container.py‎
Lines changed: 14 additions & 1 deletion b/‎dimos/agents/skills/google_maps_skill_container.py‎
Lines changed: 14 additions & 1 deletion
diff --git a/‎dimos/agents/skills/osm.py‎
Lines changed: 6 additions & 1 deletion b/‎dimos/agents/skills/osm.py‎
Lines changed: 6 additions & 1 deletion
diff --git a/‎dimos/robot/all_blueprints.py‎
Lines changed: 2 additions & 0 deletions b/‎dimos/robot/all_blueprints.py‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎dimos/robot/drone/README.md‎
Lines changed: 130 additions & 93 deletions b/‎dimos/robot/drone/README.md‎
Lines changed: 130 additions & 93 deletions
diff --git a/‎dimos/robot/drone/__init__.py‎
Lines changed: 0 additions & 1 deletion b/‎dimos/robot/drone/__init__.py‎
Lines changed: 0 additions & 1 deletion
@@ -34,7 +34,15 @@ class GoogleMapsSkillContainer(Module):
 
     def __init__(self) -> None:
         super().__init__()
-        self._client = GoogleMaps()
+        try:
+            self._client = GoogleMaps()
+        except ValueError:
+            from dimos.utils.logging_config import setup_logger
+
+            setup_logger().warning(
+                "GOOGLE_MAPS_API_KEY not set — GoogleMapsSkillContainer disabled"
+            )
+            self._client = None  # type: ignore[assignment]
         self._started = True
         self._max_valid_distance = 20000  # meters
 
@@ -72,6 +80,8 @@ def where_am_i(self, context_radius: int = 200) -> str:
 
         result = None
         try:
+            if self._client is None:
+                return "Google Maps is not configured (missing API key)."
             result = self._client.get_location_context(location, radius=context_radius)
         except Exception:
             return "There is an issue with the Google Maps API."
@@ -102,6 +112,9 @@ def get_gps_position_for_queries(self, queries: list[str]) -> str:
 
         for query in queries:
             try:
+                if self._client is None:
+                    latlon = None
+                    continue
                 latlon = self._client.get_position(query, location)
             except Exception:
                 latlon = None
 
@@ -38,7 +38,12 @@ def __init__(self) -> None:
 
     def start(self) -> None:
         super().start()
-        self._disposables.add(self.gps_location.subscribe(self._on_gps_location))  # type: ignore[arg-type]
+        if hasattr(self.gps_location, "subscribe"):
+            self._disposables.add(self.gps_location.subscribe(self._on_gps_location))  # type: ignore[arg-type]
+        else:
+            logger.warning(
+                "OsmSkill: gps_location stream does not support direct subscribe (RemoteIn)"
+            )
 
     def stop(self) -> None:
         super().stop()
 
@@ -50,6 +50,8 @@
     "demo-object-scene-registration": "dimos.perception.demo_object_scene_registration:demo_object_scene_registration",
     "demo-osm": "dimos.mapping.osm.demo_osm:demo_osm",
     "demo-skill": "dimos.agents.skills.demo_skill:demo_skill",
+    "drone-agentic": "dimos.robot.drone.blueprints.agentic.drone_agentic:drone_agentic",
+    "drone-basic": "dimos.robot.drone.blueprints.basic.drone_basic:drone_basic",
     "dual-xarm6-planner": "dimos.manipulation.manipulation_blueprints:dual_xarm6_planner",
     "keyboard-teleop-piper": "dimos.robot.manipulators.piper.blueprints:keyboard_teleop_piper",
     "keyboard-teleop-xarm6": "dimos.robot.manipulators.xarm.blueprints:keyboard_teleop_xarm6",
 
@@ -1,48 +1,58 @@
 # DimOS Drone Module
 
-Complete integration for DJI drones via RosettaDrone MAVLink bridge with visual servoing and autonomous tracking capabilities.
+DJI drone integration via RosettaDrone MAVLink bridge, with visual servoing, autonomous tracking, and LLM agent control.
 
 ## Quick Start
 
-### Test the System
 ```bash
-# Test with replay mode (no hardware needed)
-python dimos/robot/drone/drone.py --replay
+# Replay mode (no hardware needed)
+dimos --replay run drone-basic
 
-# Real drone - indoor (IMU odometry)
-python dimos/robot/drone/drone.py
+# Agentic mode with replay
+dimos --replay run drone-agentic
 
-# Real drone - outdoor (GPS odometry)
-python dimos/robot/drone/drone.py --outdoor
+# Real drone — indoor (velocity-based odometry)
+dimos run drone-basic
+
+# Real drone — outdoor (GPS-based odometry)
+dimos run drone-basic --set outdoor=true
+
+# Agentic with LLM control
+dimos run drone-agentic
 ```
 
-### Python API Usage
-```python
-from dimos.robot.drone.drone import Drone
+To interact with the agent, run `dimos humancli` in a separate terminal.
 
-# Connect to drone
-drone = Drone(connection_string='udp:0.0.0.0:14550', outdoor=True)  # Use outdoor=True for GPS
-drone.start()
+## Blueprints
 
-# Basic operations
-drone.arm()
-drone.takeoff(altitude=5.0)
-drone.move(Vector3(1.0, 0, 0), duration=2.0)  # Forward 1m/s for 2s
+### `drone-basic`
+Connection + camera + visualization. The foundation layer.
 
-# Visual tracking
-drone.tracking.track_object("person", duration=120)  # Track for 2 minutes
+| Module | Purpose |
+|--------|---------|
+| `DroneConnectionModule` | MAVLink communication, movement skills |
+| `DroneCameraModule` | Camera intrinsics, image processing |
+| `WebsocketVisModule` | Web-based visualization |
+| `RerunBridgeModule` / `FoxgloveBridge` | 3D viewer (selected by `--viewer`) |
 
-# Land and cleanup
-drone.land()
-drone.stop()
-```
+**Indoor vs Outdoor:** By default, the drone uses velocity integration for odometry (indoor mode). For outdoor flights with GPS, set `outdoor=true` — this switches to GPS-only positioning which is more reliable in open environments but less precise for close-range maneuvers.
+
+### `drone-agentic`
+Composes on top of `drone-basic`, adding autonomous capabilities:
+
+| Module | Purpose |
+|--------|---------|
+| `DroneTrackingModule` | Visual servoing & object tracking |
+| `GoogleMapsSkillContainer` | GPS-based navigation skills |
+| `OsmSkill` | OpenStreetMap queries |
+| `Agent` | LLM agent (default: GPT-4o) |
+| `WebInput` | Web/CLI interface for human commands |
 
 ## Installation
 
-### Python Package
+### Python (included with DimOS)
 ```bash
-# Install DimOS with drone support
-pip install -e .[drone]
+pip install -e ".[drone]"
 ```
 
 ### System Dependencies
@@ -56,11 +66,13 @@ sudo apt-get install -y gstreamer1.0-tools gstreamer1.0-plugins-base \
 sudo apt-get install liblcm-dev
 ```
 
-### Environment Setup
+### Environment
 ```bash
-export DRONE_IP=0.0.0.0  # Listen on all interfaces
-export DRONE_VIDEO_PORT=5600
-export DRONE_MAVLINK_PORT=14550
+# Required for agentic blueprint
+export OPENAI_API_KEY=sk-...
+
+# Optional
+export GOOGLE_MAPS_API_KEY=...  # For GoogleMapsSkillContainer
 ```
 
 ## RosettaDrone Setup (Critical)
@@ -124,26 +136,35 @@ DJI Drone ← Wireless → DJI Controller ← USB → Android Device ← WiFi
 
 ### Module Structure
 ```
-drone.py                    # Main orchestrator
-├── connection_module.py    # MAVLink communication & skills
-├── camera_module.py        # Video processing
-├── tracking_module.py      # Visual servoing & object tracking
-├── mavlink_connection.py   # Low-level MAVLink protocol
-└── dji_video_stream.py     # GStreamer video capture
+dimos/robot/drone/
+├── blueprints/
+│   ├── basic/drone_basic.py              # Base blueprint (connection + camera + vis)
+│   └── agentic/drone_agentic.py          # Agentic blueprint (composes on basic)
+├── connection_module.py                   # MAVLink communication & skills
+├── camera_module.py                       # Camera processing & intrinsics
+├── drone_tracking_module.py               # Visual servoing & object tracking
+├── drone_visual_servoing_controller.py    # PID-based visual servoing
+├── mavlink_connection.py                  # Low-level MAVLink protocol
+└── dji_video_stream.py                    # GStreamer video capture + replay
 ```
 
 ### Communication Flow
 ```
 DJI Drone → RosettaDrone → MAVLink UDP → connection_module → LCM Topics
-                         → Video UDP → dji_video_stream → tracking_module
+                         → Video UDP   → dji_video_stream → tracking_module
 ```
 
 ### LCM Topics
-- `/drone/odom` - Position and orientation
-- `/drone/status` - Armed state, battery
-- `/drone/video` - Camera frames
-- `/drone/tracking/cmd_vel` - Tracking velocity commands
-- `/drone/tracking/overlay` - Visualization with tracking box
+- `/video` — Camera frames (`sensor_msgs.Image`)
+- `/odom` — Position and orientation (`geometry_msgs.PoseStamped`)
+- `/movecmd_twist` — Velocity commands (`geometry_msgs.Twist`)
+- `/gps_location` — GPS coordinates (`LatLon`)
+- `/gps_goal` — GPS navigation target (`LatLon`)
+- `/tracking_status` — Tracking module state
+- `/follow_object_cmd` — Object tracking commands
+- `/color_image` — Processed camera image
+- `/camera_info` — Camera intrinsics
+- `/camera_pose` — Camera pose in world frame
 
 ## Visual Servoing & Tracking
 
@@ -160,7 +181,6 @@ drone.tracking.stop_tracking()
 ```
 
 ### PID Tuning
-Configure in `drone.py` initialization:
 ```python
 # Indoor (gentle, precise)
 x_pid_params=(0.001, 0.0, 0.0001, (-0.5, 0.5), None, 30)
@@ -180,35 +200,66 @@ Parameters: `(Kp, Ki, Kd, (min_output, max_output), integral_limit, deadband_pix
 
 ## Available Skills
 
+All skills are exposed to the LLM agent via the `@skill` decorator on `DroneConnectionModule`:
+
 ### Movement & Control
-- `move(vector, duration)` - Move with velocity vector
-- `takeoff(altitude)` - Takeoff to altitude
-- `land()` - Land at current position
-- `arm()/disarm()` - Arm/disarm motors
-- `fly_to(lat, lon, alt)` - Fly to GPS coordinates
+- `move(x, y, z, duration)` — Move with velocity (m/s)
+- `takeoff(altitude)` — Takeoff to altitude
+- `land()` — Land at current position
+- `arm()` / `disarm()` — Arm/disarm motors
+- `set_mode(mode)` — Set flight mode (GUIDED, LOITER, etc.)
+- `fly_to(lat, lon, alt)` — Fly to GPS coordinates
 
 ### Perception
-- `observe()` - Get current camera frame
-- `follow_object(description, duration)` - Follow object with servoing
+- `observe()` — Get current camera frame
+- `follow_object(description, duration)` — Follow object with visual servoing
+- `is_flying_to_target()` — Check if navigating to GPS target
+
+## Replay Mode
+
+Replay data includes:
+- **2,148 video frames** (640×360 RGB, ~71s at 30fps)
+- **4,098 MAVLink telemetry frames** (~136s)
+
+Stored as `TimedSensorStorage` pickle files in `data/drone/`. Downloaded automatically on first use.
+
+```bash
+# Basic replay
+dimos --replay run drone-basic
+
+# Agentic replay (requires OPENAI_API_KEY)
+dimos --replay run drone-agentic
+```
+
+## Visualization
+
+### Rerun Viewer (Recommended)
+```bash
+dimos --viewer rerun run drone-basic
+```
+Split layout with camera feed + 3D world view. Includes static drone body visualization and LCM transport integration.
+
+### Foxglove Studio
+```bash
+dimos --viewer foxglove run drone-basic
+```
+Connect Foxglove Studio to `ws://localhost:8765` to see:
+- Live video with tracking overlay
+- 3D drone position
+- Telemetry plots
+- Transform tree
 
-### Tracking Module
-- `track_object(name, duration)` - Track and follow object
-- `stop_tracking()` - Stop current tracking
-- `get_status()` - Get tracking status
+### Web Visualization
+Always available at `http://localhost:7779` via `WebsocketVisModule`.
 
 ## Testing
 
-### Unit Tests
 ```bash
+# Unit tests
 pytest -s dimos/robot/drone/
-```
 
-### Replay Mode (No Hardware)
-```python
-# Use recorded data for testing
-drone = Drone(connection_string='replay')
-drone.start()
-# All operations work with recorded data
+# Replay integration test
+dimos --replay run drone-basic
 ```
 
 ## Troubleshooting
@@ -228,47 +279,33 @@ drone.start()
 - Increase lighting for better detection
 - Adjust PID gains for environment
 - Check `max_lost_frames` in tracking module
-- Monitor with Foxglove on `ws://localhost:8765`
+
+### Agent Not Responding
+- Check `OPENAI_API_KEY` is set
+- Run `dimos humancli` to send commands
+- Check logs for `on_system_modules` errors
 
 ### Wrong Movement Direction
 - Don't modify coordinate conversions
 - Verify with: `pytest test_drone.py::test_ned_to_ros_coordinate_conversion`
 - Check camera orientation assumptions
 
-## Advanced Features
+## Network Ports
 
-### Coordinate Systems
+| Port | Protocol | Purpose |
+|------|----------|---------|
+| 14550 | UDP | MAVLink commands/telemetry |
+| 5600 | UDP | Video stream |
+| 7779 | WebSocket | DimOS web visualization |
+| 8765 | WebSocket | Foxglove bridge |
+| 7667 | UDP | LCM messaging |
+
+## Coordinate Systems
 - **MAVLink/NED**: X=North, Y=East, Z=Down
 - **ROS/DimOS**: X=Forward, Y=Left, Z=Up
 - Automatic conversion handled internally
 
-### Foxglove Visualization
-Connect Foxglove Studio to `ws://localhost:8765` to see:
-- Live video with tracking overlay
-- 3D drone position
-- Telemetry plots
-- Transform tree
-
-## Network Ports
-- **14550**: MAVLink UDP
-- **5600**: Video stream UDP
-- **8765**: Foxglove WebSocket
-- **7667**: LCM messaging
-
-## Development
-
-### Adding New Skills
-Add to `connection_module.py` with `@skill` decorator:
-```python
-@skill
-def my_skill(self, param: float) -> str:
-    """Skill description for LLM."""
-    # Implementation
-    return "Result"
-```
-
-### Modifying PID Control
-Edit gains in `drone.py` `_deploy_tracking()`:
+## Modifying PID Control
 - Increase Kp for faster response
 - Add Ki for steady-state error
 - Increase Kd for damping
 
@@ -21,7 +21,6 @@
     submod_attrs={
         "camera_module": ["DroneCameraModule"],
         "connection_module": ["DroneConnectionModule"],
-        "drone": ["Drone"],
         "mavlink_connection": ["MavlinkConnection"],
     },
 )
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,6 @@`
`21`	`21`	`submod_attrs={`
`22`	`22`	`"camera_module": ["DroneCameraModule"],`
`23`	`23`	`"connection_module": ["DroneConnectionModule"],`
`24`		`- "drone": ["Drone"],`
`25`	`24`	`"mavlink_connection": ["MavlinkConnection"],`
`26`	`25`	`},`
`27`	`26`	`)`