steerable-agent-runtime-native 0.6.31__tar.gz → 0.6.32__tar.gz

{steerable_agent_runtime_native-0.6.31 → steerable_agent_runtime_native-0.6.32}/Cargo.lock

@@ -955,7 +955,7 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
 [[package]]
 name = "steerable-agent-runtime"
-version = "0.6.31"
+version = "0.6.32"
 dependencies = [
  "async-stream",
  "async-trait",

{steerable_agent_runtime_native-0.6.31 → steerable_agent_runtime_native-0.6.32}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "steerable-agent-runtime"
-version = "0.6.31"
+version = "0.6.32"
 edition = "2021"
 description = "Steerable CoreLoop in Rust: think → act → observe, yielding LoopEvents."
 license = "MIT"

{steerable_agent_runtime_native-0.6.31 → steerable_agent_runtime_native-0.6.32}/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime-native
-Version: 0.6.31
+Version: 0.6.32
 Summary: PyO3 bindings for the Rust CoreLoop.
 Requires-Python: >=3.10

{steerable_agent_runtime_native-0.6.31 → steerable_agent_runtime_native-0.6.32}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "steerable-agent-runtime-native"
-version = "0.6.31"
+version = "0.6.32"
 description = "PyO3 bindings for the Rust CoreLoop."
 requires-python = ">=3.10"
 

{steerable_agent_runtime_native-0.6.31 → steerable_agent_runtime_native-0.6.32}/src/engine.rs

@@ -467,19 +467,41 @@ impl<P: LLMProvider, E: ToolExecutor, H: LoopHooks> CoreLoop<P, E, H> {
                 self.tools.clone()
             };
             let mut llm_started;
-            let chunks = loop {
+            let mut content = String::new();
+            let mut reasoning = String::new();
+            let mut reasoning_details = Vec::new();
+            let mut tool_calls: Vec<ToolCall> = Vec::new();
+            let mut token_exhausted;
+            let mut stream_cancelled;
+            let mut stream_soft_cut;
+            let mut stream_wrap_cut;
+            let mut stream_idle_cut;
+            let mut stream_failed = false;
+            // Mid-stream errors share on_request_error with stream_with_options
+            // failures. Retry drops this attempt's partial text and re-streams;
+            // Fail keeps it and ends the run.
+            'stream_attempt: loop {
+                content.clear();
+                reasoning.clear();
+                reasoning_details.clear();
+                tool_calls.clear();
+                token_exhausted = false;
+                stream_cancelled = false;
+                stream_soft_cut = false;
+                stream_wrap_cut = false;
+                stream_idle_cut = None;
                 llm_started = std::time::Instant::now();
                 emit(LoopEvent::new(
                     "llm_request",
                     json!({ "round": round_index, "attempt": llm_attempt }),
                 ));
                 self.observe_history(&history);
-                match self
+                let mut chunks = match self
                     .provider
                     .stream_with_options(&history, &request_tools, step_tool_choice.as_deref())
                     .await
                 {
-                    Ok(chunks) => break Some(chunks),
+                    Ok(chunks) => chunks,
                     Err(error) => {
                         let message = error.message.clone();
                         let kind = error.kind.as_str();
@@ -508,12 +530,17 @@ impl<P: LLMProvider, E: ToolExecutor, H: LoopHooks> CoreLoop<P, E, H> {
                                     history = rewrite;
                                     self.observe_history(&history);
                                 }
+                                let retry_reason = if reason.is_empty() {
+                                    message.clone()
+                                } else {
+                                    reason
+                                };
                                 emit(LoopEvent::new(
                                     "hook_action",
                                     json!({
                                         "hook": "on_request_error",
                                         "action": "retry",
-                                        "reason": reason,
+                                        "reason": retry_reason,
                                         "delayMs": delay_ms,
                                         "compacted": compacted,
                                         "round": round_index,
@@ -524,6 +551,7 @@ impl<P: LLMProvider, E: ToolExecutor, H: LoopHooks> CoreLoop<P, E, H> {
                                         .await;
                                 }
                                 llm_attempt += 1;
+                                continue 'stream_attempt;
                             }
                             RequestErrorAction::Fail { reason } => {
                                 let failure_reason = if reason.is_empty() {
@@ -555,249 +583,323 @@ impl<P: LLMProvider, E: ToolExecutor, H: LoopHooks> CoreLoop<P, E, H> {
                                     0.9,
                                     &ctx,
                                 ));
-                                break None;
+                                stream_failed = true;
+                                break 'stream_attempt;
                             }
                         }
                     }
-                }
-            };
-            let Some(mut chunks) = chunks else {
-                break;
-            };
-            let mut content = String::new();
-            let mut reasoning = String::new();
-            let mut reasoning_details = Vec::new();
-            let mut tool_calls: Vec<ToolCall> = Vec::new();
-            let mut token_exhausted = false;
-            let mut stream_cancelled = false;
-            let mut stream_provider_error = None;
-            let mut stream_soft_cut = false;
-            let mut stream_wrap_cut = false;
-            let mut stream_idle_cut: Option<(String, u64, u64)> = None;
-            let mut stream_active_ms = 0_u64;
-            let mut stream_chars = 0_u64;
-            let mut stream_has_tool = false;
-            let mut stream_progress_accounted = false;
-            let mut last_chunk_at = llm_started;
-            let stream_budget = if wrap_up {
-                self.config
-                    .wrap_up_tool_timeout_ms
-                    .map(|limit| (limit.max(50), true))
-            } else {
-                self.config.soft_timeout_ms.map(|limit| {
-                    let elapsed =
-                        u64::try_from(run_started.elapsed().as_millis()).unwrap_or(u64::MAX);
-                    (limit.saturating_sub(elapsed).max(50), false)
-                })
-            };
+                };
+                let mut stream_provider_error = None;
+                let mut stream_active_ms = 0_u64;
+                let mut stream_chars = 0_u64;
+                let mut stream_has_tool = false;
+                let mut stream_progress_accounted = false;
+                let mut last_chunk_at = llm_started;
+                let stream_budget = if wrap_up {
+                    self.config
+                        .wrap_up_tool_timeout_ms
+                        .map(|limit| (limit.max(50), true))
+                } else {
+                    self.config.soft_timeout_ms.map(|limit| {
+                        let elapsed =
+                            u64::try_from(run_started.elapsed().as_millis()).unwrap_or(u64::MAX);
+                        (limit.saturating_sub(elapsed).max(50), false)
+                    })
+                };
 
-            loop {
-                let deadline = stream_budget.map(|(limit, is_wrap)| {
-                    (
-                        limit.saturating_sub(
-                            u64::try_from(llm_started.elapsed().as_millis()).unwrap_or(u64::MAX),
-                        ),
-                        is_wrap,
-                    )
-                });
-                if let Some((0, is_wrap)) = deadline {
-                    if is_wrap {
-                        stream_wrap_cut = true;
-                    } else {
-                        stream_soft_cut = true;
+                loop {
+                    let deadline = stream_budget.map(|(limit, is_wrap)| {
+                        (
+                            limit.saturating_sub(
+                                u64::try_from(llm_started.elapsed().as_millis())
+                                    .unwrap_or(u64::MAX),
+                            ),
+                            is_wrap,
+                        )
+                    });
+                    if let Some((0, is_wrap)) = deadline {
+                        if is_wrap {
+                            stream_wrap_cut = true;
+                        } else {
+                            stream_soft_cut = true;
+                        }
+                        break;
                     }
-                    break;
-                }
-                let wait_ms = deadline
-                    .map(|(remaining, _)| remaining.min(50))
-                    .unwrap_or(50);
-                let chunk = loop {
-                    tokio::select! {
-                        chunk = chunks.next() => break chunk,
-                        _ = tokio::time::sleep(std::time::Duration::from_millis(wait_ms)) => {
-                            if self.poll(false).cancel {
-                                stream_cancelled = true;
-                                break None;
-                            }
-                            if let Some((remaining, is_wrap)) = deadline {
-                                if remaining <= wait_ms {
-                                    if is_wrap {
-                                        stream_wrap_cut = true;
-                                    } else {
-                                        stream_soft_cut = true;
-                                    }
+                    let wait_ms = deadline
+                        .map(|(remaining, _)| remaining.min(50))
+                        .unwrap_or(50);
+                    let chunk = loop {
+                        tokio::select! {
+                            chunk = chunks.next() => break chunk,
+                            _ = tokio::time::sleep(std::time::Duration::from_millis(wait_ms)) => {
+                                if self.poll(false).cancel {
+                                    stream_cancelled = true;
                                     break None;
                                 }
+                                if let Some((remaining, is_wrap)) = deadline {
+                                    if remaining <= wait_ms {
+                                        if is_wrap {
+                                            stream_wrap_cut = true;
+                                        } else {
+                                            stream_soft_cut = true;
+                                        }
+                                        break None;
+                                    }
+                                }
                             }
                         }
-                    }
-                };
-                let Some(chunk) = chunk else {
-                    break;
-                };
-                let chunk = match chunk {
-                    Ok(chunk) => chunk,
-                    Err(error) => {
-                        stream_provider_error = Some(error);
+                    };
+                    let Some(chunk) = chunk else {
                         break;
+                    };
+                    let chunk = match chunk {
+                        Ok(chunk) => chunk,
+                        Err(error) => {
+                            stream_provider_error = Some(error);
+                            break;
+                        }
+                    };
+                    let now = std::time::Instant::now();
+                    let gap_ms = u64::try_from(now.duration_since(last_chunk_at).as_millis())
+                        .unwrap_or(u64::MAX);
+                    last_chunk_at = now;
+                    if gap_ms <= self.config.idle_reasoning_gap_ms {
+                        stream_active_ms = stream_active_ms.saturating_add(gap_ms);
                     }
-                };
-                let now = std::time::Instant::now();
-                let gap_ms = u64::try_from(now.duration_since(last_chunk_at).as_millis())
-                    .unwrap_or(u64::MAX);
-                last_chunk_at = now;
-                if gap_ms <= self.config.idle_reasoning_gap_ms {
-                    stream_active_ms = stream_active_ms.saturating_add(gap_ms);
-                }
-                let chunk_content_chars = chunk
-                    .content_delta
-                    .as_deref()
-                    .map(|text| text.chars().count() as u64)
-                    .unwrap_or(0);
-                let chunk_reasoning_chars = chunk
-                    .reasoning_delta
-                    .as_deref()
-                    .map(|text| text.chars().count() as u64)
-                    .unwrap_or(0);
-                let chunk_has_tool = chunk.tool_call_delta.is_some();
-                if let Some(finish_reason) = chunk.finish_reason.as_deref() {
-                    if finish_reason == "__soft_timeout_cut__" {
-                        stream_soft_cut = true;
-                        break;
+                    let chunk_content_chars = chunk
+                        .content_delta
+                        .as_deref()
+                        .map(|text| text.chars().count() as u64)
+                        .unwrap_or(0);
+                    let chunk_reasoning_chars = chunk
+                        .reasoning_delta
+                        .as_deref()
+                        .map(|text| text.chars().count() as u64)
+                        .unwrap_or(0);
+                    let chunk_has_tool = chunk.tool_call_delta.is_some();
+                    if let Some(finish_reason) = chunk.finish_reason.as_deref() {
+                        if finish_reason == "__soft_timeout_cut__" {
+                            stream_soft_cut = true;
+                            break;
+                        }
+                        if finish_reason == "__wrap_stream_cut__" {
+                            stream_wrap_cut = true;
+                            break;
+                        }
+                        if let Some(details) = finish_reason.strip_prefix("__idle_stream_cut__:") {
+                            let mut parts = details.split(':');
+                            let trigger = parts.next().unwrap_or("active_ms").to_string();
+                            let chars = parts
+                                .next()
+                                .and_then(|value| value.parse().ok())
+                                .unwrap_or(0);
+                            let stale_chars = parts
+                                .next()
+                                .and_then(|value| value.parse().ok())
+                                .unwrap_or(0);
+                            stream_idle_cut = Some((trigger, chars, stale_chars));
+                            break;
+                        }
                     }
-                    if finish_reason == "__wrap_stream_cut__" {
-                        stream_wrap_cut = true;
-                        break;
+                    if let Some(delta) = chunk.content_delta {
+                        content.push_str(&delta);
+                        emit(LoopEvent::new("content_delta", json!({ "delta": delta })));
                     }
-                    if let Some(details) = finish_reason.strip_prefix("__idle_stream_cut__:") {
-                        let mut parts = details.split(':');
-                        let trigger = parts.next().unwrap_or("active_ms").to_string();
-                        let chars = parts
-                            .next()
-                            .and_then(|value| value.parse().ok())
-                            .unwrap_or(0);
-                        let stale_chars = parts
-                            .next()
-                            .and_then(|value| value.parse().ok())
-                            .unwrap_or(0);
-                        stream_idle_cut = Some((trigger, chars, stale_chars));
+                    if let Some(delta) = chunk.reasoning_delta {
+                        reasoning.push_str(&delta);
+                        emit(LoopEvent::new("reasoning_delta", json!({ "delta": delta })));
+                    }
+                    if let Some(details) = chunk.reasoning_details {
+                        match details {
+                            Value::Array(items) => reasoning_details.extend(items),
+                            item => reasoning_details.push(item),
+                        }
+                    }
+                    if let Some(call) = chunk.tool_call_delta {
+                        tool_calls.push(call);
+                    }
+                    if let Some(usage) = chunk.usage {
+                        ctx.last_prompt_tokens = usage.prompt_tokens;
+                        ctx.last_prompt_transcript_len = history.len();
+                        ctx.last_cached_prompt_tokens = usage.cached_prompt_tokens;
+                        ctx.last_cache_creation_tokens = usage.cache_creation_tokens;
+                        ctx.accumulated_prompt_tokens += usage.prompt_tokens;
+                        ctx.accumulated_completion_tokens += usage.completion_tokens;
+                        self.last_run_usage = Some(LLMUsage {
+                            prompt_tokens: ctx.accumulated_prompt_tokens,
+                            completion_tokens: ctx.accumulated_completion_tokens,
+                            total_tokens: ctx.accumulated_prompt_tokens
+                                + ctx.accumulated_completion_tokens,
+                            cached_prompt_tokens: usage.cached_prompt_tokens,
+                            cache_creation_tokens: usage.cache_creation_tokens,
+                        });
+                        self.observe_context(&ctx, round_index);
+                        if let Some(limits) = &self.config.budget {
+                            let (next, exhausted) = consume_budget(
+                                &budget_state,
+                                limits,
+                                usage.total_tokens,
+                                usage.cached_prompt_tokens,
+                                false,
+                                false,
+                            );
+                            budget_state = next;
+                            if exhausted {
+                                emit(LoopEvent::new(
+                                    "budget_exhausted",
+                                    json!({ "budget": "tokens", "used": budget_state.tokens_used }),
+                                ));
+                                emit(completion_event(
+                                    round_index,
+                                    "stop",
+                                    &content,
+                                    &tool_calls,
+                                    ctx.consecutive_tool_errors,
+                                    "budget_exhausted",
+                                    "token budget exceeded",
+                                    1.0,
+                                    &ctx,
+                                ));
+                                token_exhausted = true;
+                                break;
+                            }
+                        }
+                    }
+                    if self.poll(false).cancel {
+                        stream_cancelled = true;
                         break;
                     }
-                }
-                if let Some(delta) = chunk.content_delta {
-                    content.push_str(&delta);
-                    emit(LoopEvent::new("content_delta", json!({ "delta": delta })));
-                }
-                if let Some(delta) = chunk.reasoning_delta {
-                    reasoning.push_str(&delta);
-                    emit(LoopEvent::new("reasoning_delta", json!({ "delta": delta })));
-                }
-                if let Some(details) = chunk.reasoning_details {
-                    match details {
-                        Value::Array(items) => reasoning_details.extend(items),
-                        item => reasoning_details.push(item),
+                    if !stream_has_tool && !chunk_has_tool {
+                        let delta_chars = chunk_content_chars.saturating_add(chunk_reasoning_chars);
+                        stream_chars = stream_chars.saturating_add(delta_chars);
+                        let stale_chars = ctx.reasoning_since_progress.saturating_add(stream_chars);
+                        let trigger = if self
+                            .config
+                            .idle_stream_timeout_ms
+                            .is_some_and(|limit| stream_active_ms >= limit)
+                        {
+                            Some("active_ms")
+                        } else if self
+                            .config
+                            .idle_stream_max_chars
+                            .is_some_and(|limit| stream_chars >= limit)
+                        {
+                            Some("chars")
+                        } else if self
+                            .config
+                            .reasoning_without_progress_chars
+                            .is_some_and(|limit| stale_chars >= limit)
+                        {
+                            Some("no_progress")
+                        } else {
+                            None
+                        };
+                        if let Some(trigger) = trigger {
+                            if trigger == "no_progress" {
+                                ctx.reasoning_since_progress = 0;
+                            } else {
+                                ctx.reasoning_since_progress = stale_chars;
+                            }
+                            stream_progress_accounted = true;
+                            stream_idle_cut =
+                                Some((trigger.to_string(), stream_chars, stale_chars));
+                            break;
+                        }
+                    }
+                    if chunk_has_tool {
+                        stream_has_tool = true;
                     }
                 }
-                if let Some(call) = chunk.tool_call_delta {
-                    tool_calls.push(call);
-                }
-                if let Some(usage) = chunk.usage {
-                    ctx.last_prompt_tokens = usage.prompt_tokens;
-                    ctx.last_prompt_transcript_len = history.len();
-                    ctx.last_cached_prompt_tokens = usage.cached_prompt_tokens;
-                    ctx.last_cache_creation_tokens = usage.cache_creation_tokens;
-                    ctx.accumulated_prompt_tokens += usage.prompt_tokens;
-                    ctx.accumulated_completion_tokens += usage.completion_tokens;
-                    self.last_run_usage = Some(LLMUsage {
-                        prompt_tokens: ctx.accumulated_prompt_tokens,
-                        completion_tokens: ctx.accumulated_completion_tokens,
-                        total_tokens: ctx.accumulated_prompt_tokens
-                            + ctx.accumulated_completion_tokens,
-                        cached_prompt_tokens: usage.cached_prompt_tokens,
-                        cache_creation_tokens: usage.cache_creation_tokens,
-                    });
-                    self.observe_context(&ctx, round_index);
-                    if let Some(limits) = &self.config.budget {
-                        let (next, exhausted) = consume_budget(
-                            &budget_state,
-                            limits,
-                            usage.total_tokens,
-                            usage.cached_prompt_tokens,
-                            false,
-                            false,
-                        );
-                        budget_state = next;
-                        if exhausted {
+                if let Some(error) = stream_provider_error {
+                    let message = error.message.clone();
+                    let kind = error.kind.as_str();
+                    emit(LoopEvent::new(
+                        "llm_response",
+                        json!({
+                            "round": round_index,
+                            "attempt": llm_attempt,
+                            "durationMs": llm_started.elapsed().as_millis(),
+                            "error": message,
+                            "errorKind": kind,
+                        }),
+                    ));
+                    match self
+                        .hooks
+                        .on_request_error(&error, &history, round_index)
+                        .await
+                    {
+                        RequestErrorAction::Retry {
+                            delay_ms,
+                            reason,
+                            rewrite,
+                        } => {
+                            let compacted = rewrite.is_some();
+                            if let Some(rewrite) = rewrite {
+                                history = rewrite;
+                                self.observe_history(&history);
+                            }
+                            let retry_reason = if reason.is_empty() {
+                                message.clone()
+                            } else {
+                                reason
+                            };
                             emit(LoopEvent::new(
-                                "budget_exhausted",
-                                json!({ "budget": "tokens", "used": budget_state.tokens_used }),
+                                "hook_action",
+                                json!({
+                                    "hook": "on_request_error",
+                                    "action": "retry",
+                                    "reason": retry_reason,
+                                    "delayMs": delay_ms,
+                                    "compacted": compacted,
+                                    "round": round_index,
+                                }),
+                            ));
+                            if delay_ms > 0 {
+                                tokio::time::sleep(std::time::Duration::from_millis(delay_ms))
+                                    .await;
+                            }
+                            llm_attempt += 1;
+                            continue 'stream_attempt;
+                        }
+                        RequestErrorAction::Fail { reason } => {
+                            let failure_reason = if reason.is_empty() {
+                                format!("llm stream error: {message}")
+                            } else {
+                                reason
+                            };
+                            emit(LoopEvent::new(
+                                "error",
+                                json!({
+                                    "message": message,
+                                    "round": round_index,
+                                    "phase": "llm_stream",
+                                    "kind": kind,
+                                    "provider": error.provider,
+                                    "statusCode": error.status_code,
+                                    "retryAfterMs": error.retry_after_ms,
+                                }),
                             ));
+                            if !content.trim().is_empty() && tool_calls.is_empty() {
+                                history.push(LLMMessage::text("assistant", content.clone()));
+                            }
+                            self.observe_history(&history);
                             emit(completion_event(
                                 round_index,
                                 "stop",
                                 &content,
                                 &tool_calls,
                                 ctx.consecutive_tool_errors,
-                                "budget_exhausted",
-                                "token budget exceeded",
-                                1.0,
+                                "failed",
+                                failure_reason,
+                                0.9,
                                 &ctx,
                             ));
-                            token_exhausted = true;
-                            break;
+                            stream_failed = true;
+                            break 'stream_attempt;
                         }
                     }
                 }
-                if self.poll(false).cancel {
-                    stream_cancelled = true;
-                    break;
-                }
-                if !stream_has_tool && !chunk_has_tool {
-                    let delta_chars = chunk_content_chars.saturating_add(chunk_reasoning_chars);
-                    stream_chars = stream_chars.saturating_add(delta_chars);
-                    let stale_chars = ctx.reasoning_since_progress.saturating_add(stream_chars);
-                    let trigger = if self
-                        .config
-                        .idle_stream_timeout_ms
-                        .is_some_and(|limit| stream_active_ms >= limit)
-                    {
-                        Some("active_ms")
-                    } else if self
-                        .config
-                        .idle_stream_max_chars
-                        .is_some_and(|limit| stream_chars >= limit)
-                    {
-                        Some("chars")
-                    } else if self
-                        .config
-                        .reasoning_without_progress_chars
-                        .is_some_and(|limit| stale_chars >= limit)
-                    {
-                        Some("no_progress")
-                    } else {
-                        None
-                    };
-                    if let Some(trigger) = trigger {
-                        if trigger == "no_progress" {
-                            ctx.reasoning_since_progress = 0;
-                        } else {
-                            ctx.reasoning_since_progress = stale_chars;
-                        }
-                        stream_progress_accounted = true;
-                        stream_idle_cut = Some((trigger.to_string(), stream_chars, stale_chars));
-                        break;
-                    }
-                }
-                if chunk_has_tool {
-                    stream_has_tool = true;
-                }
-            }
-            if !stream_progress_accounted && tool_calls.is_empty() {
-                ctx.reasoning_since_progress =
-                    ctx.reasoning_since_progress.saturating_add(stream_chars);
-            }
 
-            if stream_provider_error.is_none() {
                 emit(LoopEvent::new(
                     "llm_response",
                     json!({
@@ -809,57 +911,13 @@ impl<P: LLMProvider, E: ToolExecutor, H: LoopHooks> CoreLoop<P, E, H> {
                         "cancelled": stream_cancelled,
                     }),
                 ));
-            }
-
-            if let Some(error) = stream_provider_error {
-                let message = error.message.clone();
-                let kind = error.kind.as_str();
-                emit(LoopEvent::new(
-                    "llm_response",
-                    json!({
-                        "round": round_index,
-                        "attempt": llm_attempt,
-                        "durationMs": llm_started.elapsed().as_millis(),
-                        "error": message,
-                        "errorKind": kind,
-                    }),
-                ));
-                let reason = match self
-                    .hooks
-                    .on_request_error(&error, &history, round_index)
-                    .await
-                {
-                    RequestErrorAction::Fail { reason } => reason,
-                    RequestErrorAction::Retry { reason, .. } if !reason.is_empty() => reason,
-                    RequestErrorAction::Retry { .. } => format!("llm stream error: {message}"),
-                };
-                emit(LoopEvent::new(
-                    "error",
-                    json!({
-                        "message": message,
-                        "round": round_index,
-                        "phase": "llm_stream",
-                        "kind": kind,
-                        "provider": error.provider,
-                        "statusCode": error.status_code,
-                        "retryAfterMs": error.retry_after_ms,
-                    }),
-                ));
-                if !content.trim().is_empty() && tool_calls.is_empty() {
-                    history.push(LLMMessage::text("assistant", content.clone()));
+                if !stream_progress_accounted && tool_calls.is_empty() {
+                    ctx.reasoning_since_progress =
+                        ctx.reasoning_since_progress.saturating_add(stream_chars);
                 }
-                self.observe_history(&history);
-                emit(completion_event(
-                    round_index,
-                    "stop",
-                    &content,
-                    &tool_calls,
-                    ctx.consecutive_tool_errors,
-                    "failed",
-                    reason,
-                    0.9,
-                    &ctx,
-                ));
+                break 'stream_attempt;
+            }
+            if stream_failed {
                 break;
             }
 

{steerable_agent_runtime_native-0.6.31 → steerable_agent_runtime_native-0.6.32}/tests/test_loop.rs

@@ -6,8 +6,8 @@ use serde_json::{json, Value};
 use steerable_agent_runtime::{
     chunk_stream, BudgetLimit, CompletionDraft, ContentPart, CoreLoop, HookAction, LLMChunkStream,
     LLMError, LLMErrorKind, LLMMessage, LLMProvider, LLMStreamChunk, LLMUsage, LoopConfig,
-    LoopContext, LoopEvent, LoopHooks, RoundControl, RouterToolExecutor, ScriptedProvider,
-    ScriptedTurn, ToolCall, ToolExecutor, ToolResult, ToolRouter,
+    LoopContext, LoopEvent, LoopHooks, RequestErrorAction, RoundControl, RouterToolExecutor,
+    ScriptedProvider, ScriptedTurn, ToolCall, ToolExecutor, ToolResult, ToolRouter,
 };
 
 fn provider(scripts: Vec<ScriptedTurn>) -> ScriptedProvider {
@@ -684,6 +684,125 @@ async fn test_provider_error_emits_error_and_failed_completion() {
     assert_eq!(events[4].data["reason"], "failing: HTTP 401 (auth)");
 }
 
+struct MidStreamThenOk {
+    attempts: usize,
+}
+
+#[async_trait]
+impl LLMProvider for MidStreamThenOk {
+    fn name(&self) -> &str {
+        "mid-stream"
+    }
+
+    fn model(&self) -> &str {
+        "mid-stream"
+    }
+
+    async fn stream(&mut self, _messages: &[LLMMessage]) -> Result<LLMChunkStream, LLMError> {
+        self.attempts += 1;
+        if self.attempts == 1 {
+            return Ok(Box::pin(async_stream::stream! {
+                yield Ok(LLMStreamChunk {
+                    content_delta: Some("partial".into()),
+                    ..LLMStreamChunk::default()
+                });
+                yield Err(LLMError::new(
+                    "openai_compat: transport error: incomplete chunked read",
+                    LLMErrorKind::Transport,
+                ));
+            }));
+        }
+        Ok(chunk_stream(vec![
+            LLMStreamChunk {
+                content_delta: Some("recovered after retry".into()),
+                ..LLMStreamChunk::default()
+            },
+            LLMStreamChunk {
+                finish_reason: Some("stop".into()),
+                ..LLMStreamChunk::default()
+            },
+        ]))
+    }
+}
+
+struct RetryRequestError;
+
+#[async_trait]
+impl LoopHooks for RetryRequestError {
+    async fn on_request_error(
+        &self,
+        _error: &LLMError,
+        _transcript: &[LLMMessage],
+        _round_index: u32,
+    ) -> RequestErrorAction {
+        RequestErrorAction::Retry {
+            delay_ms: 0,
+            reason: String::new(),
+            rewrite: None,
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_mid_stream_transport_error_retries_then_recovers() {
+    let mut agent = CoreLoop::new(
+        MidStreamThenOk { attempts: 0 },
+        RouterToolExecutor::new(ToolRouter::new()),
+    )
+    .with_hooks(RetryRequestError);
+
+    let events = agent.run(vec![LLMMessage::text("user", "go")]).await;
+
+    assert_eq!(final_completion(&events)["status"], "completed");
+    let retry = events
+        .iter()
+        .find(|event| {
+            event.kind == "hook_action"
+                && event.data["hook"] == "on_request_error"
+                && event.data["action"] == "retry"
+        })
+        .expect("mid-stream transport should emit on_request_error retry");
+    assert!(retry.data["reason"]
+        .as_str()
+        .is_some_and(|reason| reason.contains("incomplete chunked read")));
+    assert!(!events.iter().any(|event| event.kind == "error"));
+    let assistant = agent
+        .last_history
+        .iter()
+        .rev()
+        .find(|message| message.role == "assistant")
+        .expect("retry should record the recovered assistant text");
+    assert_eq!(assistant.content_text(), "recovered after retry");
+}
+
+#[tokio::test]
+async fn test_mid_stream_error_keeps_partial_text_when_hook_fails() {
+    let mut agent = CoreLoop::new(
+        MidStreamThenOk { attempts: 0 },
+        RouterToolExecutor::new(ToolRouter::new()),
+    );
+
+    let events = agent.run(vec![LLMMessage::text("user", "go")]).await;
+
+    assert_eq!(
+        events
+            .iter()
+            .filter(|event| event.kind == "content_delta")
+            .filter_map(|event| event.data["delta"].as_str())
+            .collect::<Vec<_>>(),
+        vec!["partial"]
+    );
+    assert_eq!(final_completion(&events)["status"], "failed");
+    assert_eq!(final_completion(&events)["textLength"], 7);
+    let assistant = agent
+        .last_history
+        .iter()
+        .rev()
+        .find(|message| message.role == "assistant")
+        .expect("failed mid-stream should keep partial assistant text");
+    assert_eq!(assistant.content_text(), "partial");
+}
+
 struct SlowToolExecutor;
 
 #[async_trait]