fix: echo protocol run inputs

crates/worker-runtime/src/runtime.rs

@@ -576,6 +576,8 @@ impl Runtime {
             return Ok(vec![Event::Completions { kind, entries }]);
         }
 
+        let observation_payload = protocol_method_observation_event(&method);
+
         let (backend, handle) = {
             let mut state = self.lock()?;
             state.ensure_running()?;
@@ -622,6 +624,9 @@ impl Runtime {
         }
 
         self.record_execution_result(worker_ref, dispatch_result)?;
+        if let Some(payload) = observation_payload {
+            self.record_protocol_method_observation(worker_ref, payload)?;
+        }
         Ok(Vec::new())
     }
 
@@ -958,12 +963,7 @@ impl Runtime {
         worker_ref: &WorkerRef,
         input: WorkerInput,
     ) -> Result<(), RuntimeError> {
-        let mut state = self.lock()?;
-        state.ensure_worker_ref(worker_ref)?;
-        let event =
-            state.push_worker_observation_event(worker_ref.clone(), input_protocol_event(&input));
-        state.persist_worker_observation_event(&event)?;
-        Ok(())
+        self.record_protocol_method_observation(worker_ref, input_protocol_event(&input))
     }
 
     #[cfg(not(feature = "ws-server"))]
@@ -975,6 +975,28 @@ impl Runtime {
         Ok(())
     }
 
+    #[cfg(feature = "ws-server")]
+    fn record_protocol_method_observation(
+        &self,
+        worker_ref: &WorkerRef,
+        payload: Event,
+    ) -> Result<(), RuntimeError> {
+        let mut state = self.lock()?;
+        state.ensure_worker_ref(worker_ref)?;
+        let event = state.push_worker_observation_event(worker_ref.clone(), payload);
+        state.persist_worker_observation_event(&event)?;
+        Ok(())
+    }
+
+    #[cfg(not(feature = "ws-server"))]
+    fn record_protocol_method_observation(
+        &self,
+        _worker_ref: &WorkerRef,
+        _payload: Event,
+    ) -> Result<(), RuntimeError> {
+        Ok(())
+    }
+
     fn transition_worker(
         &self,
         worker_ref: &WorkerRef,
@@ -1836,6 +1858,48 @@ fn validate_worker_input(input: &WorkerInput) -> Result<(), RuntimeError> {
     Ok(())
 }
 
+#[cfg(feature = "ws-server")]
+fn protocol_method_observation_event(method: &Method) -> Option<Event> {
+    match method {
+        Method::Run { input } => Some(Event::UserMessage {
+            segments: input.clone(),
+        }),
+        Method::Notify { message, .. } => Some(Event::SystemItem {
+            item: serde_json::json!({
+                "kind": "embedded_worker_system_input",
+                "content": message,
+            }),
+        }),
+        Method::RegisterPeer { name } => Some(Event::SystemItem {
+            item: serde_json::json!({
+                "kind": "embedded_worker_command_input",
+                "command": "register_peer",
+                "content": name,
+            }),
+        }),
+        Method::Compact => Some(Event::SystemItem {
+            item: serde_json::json!({
+                "kind": "embedded_worker_command_input",
+                "command": "compact",
+                "content": "",
+            }),
+        }),
+        Method::ListRewindTargets => Some(Event::SystemItem {
+            item: serde_json::json!({
+                "kind": "embedded_worker_command_input",
+                "command": "list_rewind_targets",
+                "content": "",
+            }),
+        }),
+        _ => None,
+    }
+}
+
+#[cfg(not(feature = "ws-server"))]
+fn protocol_method_observation_event(_method: &Method) -> Option<Event> {
+    None
+}
+
 #[cfg(feature = "ws-server")]
 fn input_protocol_event(input: &WorkerInput) -> protocol::Event {
     match input.kind {