Add agentId envelope field on session events for sub-agent attribution

The wire-protocol schema added top-level `agentId?: string` to every
session event envelope in commit f8cf846 ("Derive session event
envelopes from schema") for sub-agent attribution. Every other SDK
carries it; Rust silently drops it at the deserialization boundary.

Concretely: the schema describes `agentId` as "Sub-agent instance
identifier. Absent for events from the root/main agent and session-
level events." Without the field, Rust consumers can't distinguish
events emitted by a sub-agent from events emitted by the root agent.

Adds:
- `pub agent_id: Option<String>` on `types::SessionEvent` (hand-
  authored consumer-facing).
- `pub agent_id: Option<String>` on
  `generated::session_events::TypedSessionEvent` via codegen update
  in `scripts/codegen/rust.ts`.
- `#[serde(rename = "agentId", skip_serializing_if = "Option::is_none")]`
  via the existing container `rename_all = "camelCase"` (covered) plus
  skip-on-None for clean wire output.

Round-trip tests cover both struct shapes — sub-agent event with the
field set, root-agent event without — to lock the parity in place
against future schema changes or codegen regressions.

Caught by a fresh parity audit against Node/Python/Go/.NET as part of
the post-main-merge gap review.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: tclem

rust/.parity_node.txt

@@ -0,0 +1,33 @@
+AssistantMessageToolRequestType
+ElicitationCompletedAction
+ElicitationCompletedContent
+ElicitationRequestedMode
+ExtensionsLoadedExtensionSource
+ExtensionsLoadedExtensionStatus
+HandoffSourceType
+McpServerStatusChangedStatus
+McpServersLoadedServerStatus
+ModelCallFailureSource
+PermissionPromptRequest
+PermissionPromptRequestMemoryAction
+PermissionPromptRequestMemoryDirection
+PermissionPromptRequestPathAccessKind
+PermissionRequest
+PermissionRequestMemoryAction
+PermissionRequestMemoryDirection
+PermissionResult
+PlanChangedOperation
+SessionEvent
+ShutdownType
+SystemMessageRole
+SystemNotification
+SystemNotificationAgentCompletedStatus
+ToolExecutionCompleteContent
+ToolExecutionCompleteContentResourceDetails
+ToolExecutionCompleteContentResourceLinkIconTheme
+UserMessageAgentMode
+UserMessageAttachment
+UserMessageAttachmentGithubReferenceType
+UserToolSessionApproval
+WorkingDirectoryContextHostType
+WorkspaceFileChangedOperation

rust/.parity_rust.txt

@@ -0,0 +1 @@
+pub

rust/CHANGELOG.md

@@ -423,6 +423,14 @@ public surface.
   fail fast as before.
 
 ### Fixed
+- `SessionEvent` and `TypedSessionEvent` now expose the `agentId`
+  envelope field added to `session-events.schema.json` upstream
+  (`f8cf846`, "Derive session event envelopes from schema"). Sub-agent
+  events were silently dropping the attribution at the deserialization
+  boundary; consumers had no way to distinguish events emitted by the
+  root agent from events emitted by a sub-agent. Other SDKs (Node,
+  Python, Go, .NET) all carry this field. Round-trip parity test added
+  in `types::tests::session_event_round_trips_agent_id_on_envelope`.
 - `Session::user_input` no longer double-dispatches when the CLI sends
   both a `user_input.requested` notification (for observers) and a
   `userInput.request` JSON-RPC call (the actual prompt) for the same

rust/src/generated/session_events.rs

@@ -336,9 +336,9 @@ pub enum SessionEventData {
 
 /// A session event with typed data payload.
 ///
-/// The common event fields (id, timestamp, parentId, ephemeral) are
-/// available directly. The event-specific data is in the `payload` field
-/// as a [`SessionEventData`] enum.
+/// The common event fields (id, timestamp, parentId, ephemeral, agentId)
+/// are available directly. The event-specific data is in the `payload`
+/// field as a [`SessionEventData`] enum.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TypedSessionEvent {
@@ -352,6 +352,10 @@ pub struct TypedSessionEvent {
     /// When true, the event is transient and not persisted.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ephemeral: Option<bool>,
+    /// Sub-agent instance identifier. Absent for events from the root /
+    /// main agent and session-level events.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub agent_id: Option<String>,
     /// The typed event payload (discriminated by event type).
     #[serde(flatten)]
     pub payload: SessionEventData,

rust/src/subscription.rs

@@ -166,6 +166,7 @@ mod tests {
             timestamp: "2025-01-01T00:00:00Z".into(),
             parent_id: None,
             ephemeral: None,
+            agent_id: None,
             debug_cli_received_at_ms: None,
             debug_ws_forwarded_at_ms: None,
             event_type: "noop".into(),

rust/src/types.rs

@@ -2542,6 +2542,10 @@ pub struct SessionEvent {
     /// Transient events that are not persisted to disk.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ephemeral: Option<bool>,
+    /// Sub-agent instance identifier. Absent for events emitted by the
+    /// root/main agent and for session-level events.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub agent_id: Option<String>,
     /// Debug timestamp: when the CLI received this event (ms since epoch).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub debug_cli_received_at_ms: Option<i64>,
@@ -2987,9 +2991,10 @@ mod tests {
     use super::{
         Attachment, AttachmentLineRange, AttachmentSelectionPosition, AttachmentSelectionRange,
         ConnectionState, CustomAgentConfig, DeliveryMode, GitHubReferenceType,
-        InfiniteSessionConfig, ProviderConfig, ResumeSessionConfig, SessionConfig, SessionId,
-        SystemMessageConfig, Tool, ensure_attachment_display_names,
+        InfiniteSessionConfig, ProviderConfig, ResumeSessionConfig, SessionConfig, SessionEvent,
+        SessionId, SystemMessageConfig, Tool, ensure_attachment_display_names,
     };
+    use crate::generated::session_events::TypedSessionEvent;
 
     #[test]
     fn tool_builder_composes() {
@@ -3252,6 +3257,62 @@ mod tests {
         assert_eq!(parsed, ConnectionState::Error);
     }
 
+    /// `agentId` is the sub-agent attribution field added in copilot-sdk
+    /// commit f8cf846 ("Derive session event envelopes from schema").
+    /// Every other SDK (Node, Python, Go, .NET) carries it on the event
+    /// envelope; Rust must too or sub-agent events lose attribution at
+    /// the deserialization boundary. Cross-SDK parity test.
+    #[test]
+    fn session_event_round_trips_agent_id_on_envelope() {
+        let wire = json!({
+            "id": "evt-1",
+            "timestamp": "2026-04-30T12:00:00Z",
+            "parentId": null,
+            "agentId": "sub-agent-42",
+            "type": "assistant.message",
+            "data": { "message": "hi" }
+        });
+
+        let event: SessionEvent = serde_json::from_value(wire.clone()).unwrap();
+        assert_eq!(event.agent_id.as_deref(), Some("sub-agent-42"));
+
+        // Round-trip preserves the field on the wire.
+        let roundtripped = serde_json::to_value(&event).unwrap();
+        assert_eq!(roundtripped["agentId"], "sub-agent-42");
+
+        // Absent agentId remains absent (skip_serializing_if).
+        let main_agent_event: SessionEvent = serde_json::from_value(json!({
+            "id": "evt-2",
+            "timestamp": "2026-04-30T12:00:01Z",
+            "parentId": null,
+            "type": "session.idle",
+            "data": {}
+        }))
+        .unwrap();
+        assert!(main_agent_event.agent_id.is_none());
+        let roundtripped = serde_json::to_value(&main_agent_event).unwrap();
+        assert!(roundtripped.get("agentId").is_none());
+    }
+
+    /// Same parity for the typed event envelope produced by the codegen.
+    #[test]
+    fn typed_session_event_round_trips_agent_id_on_envelope() {
+        let wire = json!({
+            "id": "evt-1",
+            "timestamp": "2026-04-30T12:00:00Z",
+            "parentId": null,
+            "agentId": "sub-agent-42",
+            "type": "session.idle",
+            "data": {}
+        });
+
+        let event: TypedSessionEvent = serde_json::from_value(wire).unwrap();
+        assert_eq!(event.agent_id.as_deref(), Some("sub-agent-42"));
+
+        let roundtripped = serde_json::to_value(&event).unwrap();
+        assert_eq!(roundtripped["agentId"], "sub-agent-42");
+    }
+
     #[test]
     fn connection_state_other_variants_serialize_as_lowercase() {
         assert_eq!(

scripts/codegen/rust.ts

@@ -747,12 +747,12 @@ function generateSessionEventsCode(schema: JSONSchema7): string {
 	typedEventLines.push("/// A session event with typed data payload.");
 	typedEventLines.push("///");
 	typedEventLines.push(
-		"/// The common event fields (id, timestamp, parentId, ephemeral) are",
+		"/// The common event fields (id, timestamp, parentId, ephemeral, agentId)",
 	);
 	typedEventLines.push(
-		"/// available directly. The event-specific data is in the `payload` field",
+		"/// are available directly. The event-specific data is in the `payload`",
 	);
-	typedEventLines.push("/// as a [`SessionEventData`] enum.");
+	typedEventLines.push("/// field as a [`SessionEventData`] enum.");
 	typedEventLines.push("#[derive(Debug, Clone, Serialize, Deserialize)]");
 	typedEventLines.push(`#[serde(rename_all = "camelCase")]`);
 	typedEventLines.push("pub struct TypedSessionEvent {");
@@ -770,6 +770,14 @@ function generateSessionEventsCode(schema: JSONSchema7): string {
 	);
 	typedEventLines.push(`    #[serde(skip_serializing_if = "Option::is_none")]`);
 	typedEventLines.push("    pub ephemeral: Option<bool>,");
+	typedEventLines.push(
+		"    /// Sub-agent instance identifier. Absent for events from the root /",
+	);
+	typedEventLines.push(
+		"    /// main agent and session-level events.",
+	);
+	typedEventLines.push(`    #[serde(skip_serializing_if = "Option::is_none")]`);
+	typedEventLines.push("    pub agent_id: Option<String>,");
 	typedEventLines.push(
 		"    /// The typed event payload (discriminated by event type).",
 	);