feat: Introduce reasoning delta

Sytten · Sytten · commit 537345a33f34 · 2025-11-16T12:31:56.000-05:00
Stop gap to differentiate between the full reasoning and partial
diff --git a/rig-bedrock/src/streaming.rs b/rig-bedrock/src/streaming.rs
@@ -107,10 +107,9 @@ impl CompletionModel {
                                         }
 
                                         if !text.is_empty() {
-                                            yield Ok(RawStreamingChoice::Reasoning {
+                                            yield Ok(RawStreamingChoice::ReasoningDelta {
                                                 reasoning: text.clone(),
                                                 id: None,
-                                                signature: None,
                                             })
                                         }
                                     },
diff --git a/rig-core/src/agent/prompt_request/streaming.rs b/rig-core/src/agent/prompt_request/streaming.rs
@@ -359,6 +359,10 @@ where
                             yield Ok(MultiTurnStreamItem::stream_item(StreamedAssistantContent::Reasoning(rig::message::Reasoning { reasoning, id, signature })));
                             did_call_tool = false;
                         },
+                        Ok(StreamedAssistantContent::ReasoningDelta { reasoning, id }) => {
+                            yield Ok(MultiTurnStreamItem::stream_item(StreamedAssistantContent::ReasoningDelta { reasoning, id }));
+                            did_call_tool = false;
+                        },
                         Ok(StreamedAssistantContent::Final(final_resp)) => {
                             if let Some(usage) = final_resp.token_usage() { aggregated_usage += usage; };
                             if is_text_response {
diff --git a/rig-core/src/providers/anthropic/streaming.rs b/rig-core/src/providers/anthropic/streaming.rs
@@ -323,10 +323,9 @@ fn handle_event(
                     state.thinking.push_str(thinking);
                 }
 
-                Some(Ok(RawStreamingChoice::Reasoning {
+                Some(Ok(RawStreamingChoice::ReasoningDelta {
                     id: None,
                     reasoning: thinking.clone(),
-                    signature: None,
                 }))
             }
             ContentDelta::SignatureDelta { signature } => {
@@ -504,11 +503,11 @@ mod tests {
         let choice = result.unwrap().unwrap();
 
         match choice {
-            RawStreamingChoice::Reasoning { id, reasoning, .. } => {
+            RawStreamingChoice::ReasoningDelta { id, reasoning, .. } => {
                 assert_eq!(id, None);
                 assert_eq!(reasoning, "Analyzing the request...");
             }
-            _ => panic!("Expected Reasoning choice"),
+            _ => panic!("Expected ReasoningDelta choice"),
         }
 
         // Verify thinking state was updated
@@ -584,10 +583,10 @@ mod tests {
         let choice = result.unwrap().unwrap();
 
         match choice {
-            RawStreamingChoice::Reasoning { reasoning, .. } => {
+            RawStreamingChoice::ReasoningDelta { reasoning, .. } => {
                 assert_eq!(reasoning, "Thinking while tool is active...");
             }
-            _ => panic!("Expected Reasoning choice"),
+            _ => panic!("Expected ReasoningDelta choice"),
         }
 
         // Tool call state should remain unchanged
diff --git a/rig-core/src/providers/deepseek.rs b/rig-core/src/providers/deepseek.rs
@@ -879,10 +879,9 @@ where
 
                         // DeepSeek-specific reasoning stream
                         if let Some(content) = &delta.reasoning_content {
-                            yield Ok(crate::streaming::RawStreamingChoice::Reasoning {
-                                reasoning: content.to_string(),
+                            yield Ok(crate::streaming::RawStreamingChoice::ReasoningDelta {
                                 id: None,
-                                signature: None,
+                                reasoning: content.to_string()
                             });
                         }
 
diff --git a/rig-core/src/providers/gemini/streaming.rs b/rig-core/src/providers/gemini/streaming.rs
@@ -158,7 +158,10 @@ where
                                     thought: Some(true),
                                     ..
                                 } => {
-                                    yield Ok(streaming::RawStreamingChoice::Reasoning { reasoning: text.clone(), id: None, signature: None });
+                                    yield Ok(streaming::RawStreamingChoice::ReasoningDelta {
+                                        id: None,
+                                        reasoning: text.clone(),
+                                    });
                                 },
                                 Part {
                                     part: PartKind::Text(text),
diff --git a/rig-core/src/providers/groq.rs b/rig-core/src/providers/groq.rs
@@ -780,10 +780,9 @@ where
                     if let Some(choice) = data.choices.first() {
                         match &choice.delta {
                             StreamingDelta::Reasoning { reasoning } => {
-                                yield Ok(crate::streaming::RawStreamingChoice::Reasoning {
+                                yield Ok(crate::streaming::RawStreamingChoice::ReasoningDelta {
                                     id: None,
                                     reasoning: reasoning.to_string(),
-                                    signature: None,
                                 });
                             }
 
diff --git a/rig-core/src/providers/ollama.rs b/rig-core/src/providers/ollama.rs
@@ -738,10 +738,9 @@ where
                         if let Some(thinking_content) = thinking
                             && !thinking_content.is_empty() {
                             thinking_response += &thinking_content;
-                            yield RawStreamingChoice::Reasoning {
-                                reasoning: thinking_content,
+                            yield RawStreamingChoice::ReasoningDelta {
                                 id: None,
-                                signature: None,
+                                reasoning: thinking_content,
                             };
                         }
 
diff --git a/rig-core/src/providers/openai/responses_api/streaming.rs b/rig-core/src/providers/openai/responses_api/streaming.rs
@@ -117,8 +117,8 @@ pub enum ItemChunkKind {
     ReasoningSummaryPartAdded(SummaryPartChunk),
     #[serde(rename = "response.reasoning_summary_part.done")]
     ReasoningSummaryPartDone(SummaryPartChunk),
-    #[serde(rename = "response.reasoning_summary_text.added")]
-    ReasoningSummaryTextAdded(SummaryTextChunk),
+    #[serde(rename = "response.reasoning_summary_text.delta")]
+    ReasoningSummaryTextDelta(SummaryTextChunk),
     #[serde(rename = "response.reasoning_summary_text.done")]
     ReasoningSummaryTextDone(SummaryTextChunk),
 }
@@ -295,7 +295,11 @@ where
                                                 })
                                                 .collect::<Vec<String>>()
                                                 .join("\n");
-                                            yield Ok(streaming::RawStreamingChoice::Reasoning { reasoning, id: Some(id.to_string()), signature: None })
+                                            yield Ok(streaming::RawStreamingChoice::Reasoning {
+                                                id: Some(id.to_string()),
+                                                reasoning,
+                                                signature: None,
+                                            })
                                         }
                                         _ => continue
                                     }
@@ -304,6 +308,9 @@ where
                                     combined_text.push_str(&delta.delta);
                                     yield Ok(streaming::RawStreamingChoice::Message(delta.delta.clone()))
                                 }
+                                ItemChunkKind::ReasoningSummaryTextDelta(delta) => {
+                                    yield Ok(streaming::RawStreamingChoice::ReasoningDelta { id: None, reasoning: delta.delta.clone() })
+                                }
                                 ItemChunkKind::RefusalDelta(delta) => {
                                     combined_text.push_str(&delta.delta);
                                     yield Ok(streaming::RawStreamingChoice::Message(delta.delta.clone()))
diff --git a/rig-core/src/providers/openrouter/streaming.rs b/rig-core/src/providers/openrouter/streaming.rs
@@ -252,10 +252,9 @@ where
 
                     // Streamed reasoning content
                     if let Some(reasoning) = &delta.reasoning && !reasoning.is_empty() {
-                        yield Ok(streaming::RawStreamingChoice::Reasoning {
+                        yield Ok(streaming::RawStreamingChoice::ReasoningDelta {
                             reasoning: reasoning.clone(),
                             id: None,
-                            signature: None,
                         });
                     }
 
diff --git a/rig-core/src/streaming.rs b/rig-core/src/streaming.rs
@@ -79,12 +79,17 @@ where
     },
     /// A tool call partial/delta
     ToolCallDelta { id: String, delta: String },
-    /// A reasoning chunk
+    /// A reasoning (in its entirety)
     Reasoning {
         id: Option<String>,
         reasoning: String,
         signature: Option<String>,
     },
+    /// A reasoning partial/delta
+    ReasoningDelta {
+        id: Option<String>,
+        reasoning: String,
+    },
 
     /// The final response object, must be yielded if you want the
     /// `response` field to be populated on the `StreamingCompletionResponse`
@@ -231,15 +236,19 @@ where
                     id,
                     reasoning,
                     signature,
-                } => {
+                } => Poll::Ready(Some(Ok(StreamedAssistantContent::Reasoning(Reasoning {
+                    id,
+                    reasoning: vec![reasoning],
+                    signature,
+                })))),
+                RawStreamingChoice::ReasoningDelta { id, reasoning } => {
                     // Forward the streaming tokens to the outer stream
                     // and concat the text together
                     stream.reasoning = format!("{}{}", stream.reasoning, reasoning);
-                    Poll::Ready(Some(Ok(StreamedAssistantContent::Reasoning(Reasoning {
+                    Poll::Ready(Some(Ok(StreamedAssistantContent::ReasoningDelta {
                         id,
-                        reasoning: vec![reasoning],
-                        signature,
-                    }))))
+                        reasoning,
+                    })))
                 }
                 RawStreamingChoice::ToolCall {
                     id,
@@ -362,6 +371,12 @@ impl<R: Clone + Unpin + GetTokenUsage> Stream for StreamingResultDyn<R> {
                     reasoning,
                     signature,
                 }))),
+                RawStreamingChoice::ReasoningDelta { id, reasoning } => {
+                    Poll::Ready(Some(Ok(RawStreamingChoice::ReasoningDelta {
+                        id,
+                        reasoning,
+                    })))
+                }
                 RawStreamingChoice::ToolCall {
                     id,
                     name,
@@ -514,6 +529,10 @@ mod tests {
                     print!("{reasoning}");
                     std::io::Write::flush(&mut std::io::stdout()).unwrap();
                 }
+                Ok(StreamedAssistantContent::ReasoningDelta { reasoning, .. }) => {
+                    println!("Reasoning delta: {reasoning}");
+                    chunk_count += 1;
+                }
                 Err(e) => {
                     eprintln!("Error: {e:?}");
                     break;
@@ -555,8 +574,15 @@ mod tests {
 pub enum StreamedAssistantContent<R> {
     Text(Text),
     ToolCall(ToolCall),
-    ToolCallDelta { id: String, delta: String },
+    ToolCallDelta {
+        id: String,
+        delta: String,
+    },
     Reasoning(Reasoning),
+    ReasoningDelta {
+        id: Option<String>,
+        reasoning: String,
+    },
     Final(R),
 }
 

Original file line number	Diff line number	Diff line change
`@@ -107,10 +107,9 @@ impl CompletionModel {`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`if !text.is_empty() {`
`110`		`- yield Ok(RawStreamingChoice::Reasoning {`
	`110`	`+ yield Ok(RawStreamingChoice::ReasoningDelta {`
`111`	`111`	`reasoning: text.clone(),`
`112`	`112`	`id: None,`
`113`		`- signature: None,`
`114`	`113`	`})`
`115`	`114`	`}`
`116`	`115`	`},`
Original file line number	Diff line number	Diff line change
`@@ -323,10 +323,9 @@ fn handle_event(`
`323`	`323`	`state.thinking.push_str(thinking);`
`324`	`324`	`}`
`325`	`325`
`326`		`- Some(Ok(RawStreamingChoice::Reasoning {`
	`326`	`+ Some(Ok(RawStreamingChoice::ReasoningDelta {`
`327`	`327`	`id: None,`
`328`	`328`	`reasoning: thinking.clone(),`
`329`		`- signature: None,`
`330`	`329`	`}))`
`331`	`330`	`}`
`332`	`331`	`ContentDelta::SignatureDelta { signature } => {`
`@@ -504,11 +503,11 @@ mod tests {`
`504`	`503`	`let choice = result.unwrap().unwrap();`
`505`	`504`
`506`	`505`	`match choice {`
`507`		`- RawStreamingChoice::Reasoning { id, reasoning, .. } => {`
	`506`	`+ RawStreamingChoice::ReasoningDelta { id, reasoning, .. } => {`
`508`	`507`	`assert_eq!(id, None);`
`509`	`508`	`assert_eq!(reasoning, "Analyzing the request...");`
`510`	`509`	`}`
`511`		`- _ => panic!("Expected Reasoning choice"),`
	`510`	`+ _ => panic!("Expected ReasoningDelta choice"),`
`512`	`511`	`}`
`513`	`512`
`514`	`513`	`// Verify thinking state was updated`
`@@ -584,10 +583,10 @@ mod tests {`
`584`	`583`	`let choice = result.unwrap().unwrap();`
`585`	`584`
`586`	`585`	`match choice {`
`587`		`- RawStreamingChoice::Reasoning { reasoning, .. } => {`
	`586`	`+ RawStreamingChoice::ReasoningDelta { reasoning, .. } => {`
`588`	`587`	`assert_eq!(reasoning, "Thinking while tool is active...");`
`589`	`588`	`}`
`590`		`- _ => panic!("Expected Reasoning choice"),`
	`589`	`+ _ => panic!("Expected ReasoningDelta choice"),`
`591`	`590`	`}`
`592`	`591`
`593`	`592`	`// Tool call state should remain unchanged`