Hotfix: session.read writes provider-state text as plain text

Since 0.3.220, assistant text on OpenAI Responses, ChatGPT, Gemini and Code Assist is stored
as a text_with_state block: the text plus opaque provider state such as the Responses phase.
session.read wrote that canonical block onto the wire, so a caller expecting a text block
read a different block type, and Core stringified it, so every OpenAI worker's final report
was unreadable. session.read now writes each such block as a plain text block with the same
text and no provider state. The log is unchanged, so re-reading an affected session returns
the text. run.result already joined the text correctly.

Author: ualtinok

Cargo.lock

@@ -42,7 +42,7 @@ members = [
 # checkouts are used only to build integration-test rig binaries.
 
 [workspace.package]
-version = "0.3.220"
+version = "0.3.221"
 edition = "2021"
 rust-version = "1.96"
 license = "MIT"

Cargo.toml

@@ -758,12 +758,41 @@ pub enum SendResult {
     },
 }
 
+/// Serialize `message` as callers read it: every `text_with_state` block becomes a plain `text`
+/// block with the same text, and every other block is written unchanged.
+fn serialize_caller_message<S: serde::Serializer>(
+    message: &broca_protocol::Message,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    use broca_protocol::ContentBlock;
+    if !message
+        .content
+        .iter()
+        .any(|block| matches!(block, ContentBlock::TextWithState { .. }))
+    {
+        return message.serialize(serializer);
+    }
+    let mut caller = message.clone();
+    for block in &mut caller.content {
+        if let ContentBlock::TextWithState { text, .. } = block {
+            *block = ContentBlock::Text {
+                text: std::mem::take(text),
+            };
+        }
+    }
+    caller.serialize(serializer)
+}
+
 /// One message in a `session.read` page.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct SessionReadMessage {
     pub ordinal: u64,
     /// Message-coordinate spelling used by consumers for stable message badges.
     pub mid: String,
+    /// Written in the caller-facing vocabulary: assistant text that carries provider state
+    /// (`text_with_state`) goes out as a plain `text` block. The state is opaque bytes broca
+    /// keeps only to send back to the provider; a caller reading the transcript wants the text.
+    #[serde(serialize_with = "serialize_caller_message")]
     pub message: broca_protocol::Message,
     /// The producing run, not the page's latest run. Historical/imported messages with
     /// no recoverable producer omit this member; legacy replies without it still decode.
@@ -3796,3 +3825,62 @@ mod session_class_tests {
         }
     }
 }
+
+#[cfg(test)]
+mod caller_message_tests {
+    use super::*;
+    use broca_protocol::content::{ContentBlock, Role, TextProviderFormat, TextProviderState};
+    use serde_json::json;
+
+    fn read_message(content: Vec<ContentBlock>) -> SessionReadMessage {
+        SessionReadMessage {
+            ordinal: 3,
+            mid: "m3".into(),
+            message: broca_protocol::Message::new(Role::Assistant, content),
+            run: None,
+            tool_calls: Vec::new(),
+        }
+    }
+
+    /// A caller reads the transcript's text, never the provider bytes kept to send back. A
+    /// worker's final reply carrying a ChatGPT phase must reach the caller as plain text, or a
+    /// parser looking for its text sees a serialized envelope instead.
+    #[test]
+    fn text_with_provider_state_reaches_callers_as_plain_text() {
+        let message = read_message(vec![
+            ContentBlock::Text {
+                text: "before ".into(),
+            },
+            ContentBlock::TextWithState {
+                text: "<result>done</result>".into(),
+                provider_state: TextProviderState {
+                    format: TextProviderFormat::OpenAiResponsesChatgpt,
+                    data: r#"{"id":"msg_1","phase":"final_answer"}"#.into(),
+                },
+            },
+        ]);
+        let wire = serde_json::to_value(&message).unwrap();
+        assert_eq!(
+            wire["message"]["content"],
+            json!([
+                {"type": "text", "text": "before "},
+                {"type": "text", "text": "<result>done</result>"},
+            ])
+        );
+        assert!(!wire.to_string().contains("provider_state"));
+        assert!(!wire.to_string().contains("final_answer"));
+    }
+
+    /// Messages without provider state serialize exactly as the canonical message does, so the
+    /// conversion never moves bytes of an ordinary page.
+    #[test]
+    fn messages_without_provider_state_are_unchanged() {
+        let message = read_message(vec![ContentBlock::Text {
+            text: "plain".into(),
+        }]);
+        assert_eq!(
+            serde_json::to_value(&message).unwrap()["message"],
+            serde_json::to_value(&message.message).unwrap()
+        );
+    }
+}

crates/broca-wire/src/lib.rs

@@ -16232,3 +16232,16 @@ expect_red = ["framing::tests::provider_text_state_is_must_understand_before_rec
 file = "crates/broca-wal/src/record.rs"
 old = 'let base = if self.carries_provider_text_state() {'
 new = 'let base = if self.carries_provider_text_state() && false { // NON-VACUITY BREAK: omit reader feature'
+
+[[control]]
+id = "session-read-text-with-state-as-caller-text"
+guards = "session.read writes assistant text that carries provider state as a plain text block, so callers parsing the transcript read the text, never the serialized provider envelope"
+runner = "cargo"
+package = "broca-wire"
+target = "--lib"
+select = "expected"
+test_file = "crates/broca-wire/src/lib.rs"
+expect_red = ["caller_message_tests::text_with_provider_state_reaches_callers_as_plain_text"]
+file = "crates/broca-wire/src/lib.rs"
+old = '    #[serde(serialize_with = "serialize_caller_message")]'
+new = '    // NON-VACUITY BREAK: write the canonical block, provider state included.'