steerable-agent-runtime-native 0.6.34__tar.gz → 0.6.36__tar.gz

{steerable_agent_runtime_native-0.6.34 → steerable_agent_runtime_native-0.6.36}/Cargo.lock

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

{steerable_agent_runtime_native-0.6.34 → steerable_agent_runtime_native-0.6.36}/Cargo.toml

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

{steerable_agent_runtime_native-0.6.34 → steerable_agent_runtime_native-0.6.36}/PKG-INFO

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

{steerable_agent_runtime_native-0.6.34 → steerable_agent_runtime_native-0.6.36}/pyproject.toml

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

{steerable_agent_runtime_native-0.6.34 → steerable_agent_runtime_native-0.6.36}/src/engine.rs

@@ -387,79 +387,96 @@ impl<P: LLMProvider, E: ToolExecutor, H: LoopHooks> CoreLoop<P, E, H> {
                 }
             }
 
-            let (step_tool_choice, step_tool_choice_honored) =
-                match self.hooks.pre_step(&history).await {
-                    PreStepOutcome::Reject { reason } => {
-                        emit(completion_event(
-                            round_index,
-                            "stop",
-                            "",
-                            &[],
-                            ctx.consecutive_tool_errors,
-                            "failed",
-                            reason,
-                            1.0,
-                            &ctx,
+            let (step_tool_choice, step_tool_choice_honored) = match self
+                .hooks
+                .pre_step(&history)
+                .await
+            {
+                PreStepOutcome::Reject { reason } => {
+                    emit(completion_event(
+                        round_index,
+                        "stop",
+                        "",
+                        &[],
+                        ctx.consecutive_tool_errors,
+                        "failed",
+                        reason,
+                        1.0,
+                        &ctx,
+                    ));
+                    break;
+                }
+                PreStepOutcome::Proceed {
+                    appends,
+                    rewrite,
+                    reason,
+                    action,
+                    append_reason,
+                    append_action,
+                    appended_count,
+                    pre_tokens,
+                    post_tokens,
+                    tool_choice,
+                    tool_choice_honored,
+                    notes,
+                } => {
+                    if let Some(replacement) = rewrite {
+                        history = replacement;
+                        emit(LoopEvent::new(
+                            "hook_action",
+                            json!({
+                                "hook": "pre_step",
+                                "action": action.clone(),
+                                "reason": reason.clone(),
+                                "round": round_index,
+                                "pre_tokens": pre_tokens,
+                                "post_tokens": post_tokens,
+                            }),
                         ));
-                        break;
                     }
-                    PreStepOutcome::Proceed {
-                        appends,
-                        rewrite,
-                        reason,
-                        action,
-                        pre_tokens,
-                        post_tokens,
-                        tool_choice,
-                        tool_choice_honored,
-                        notes,
-                    } => {
-                        if let Some(replacement) = rewrite {
-                            history = replacement;
-                            emit(LoopEvent::new(
-                                "hook_action",
-                                json!({
-                                    "hook": "pre_step",
-                                    "action": action.clone(),
-                                    "reason": reason.clone(),
-                                    "round": round_index,
-                                    "pre_tokens": pre_tokens,
-                                    "post_tokens": post_tokens,
-                                }),
-                            ));
-                        }
-                        for message in appends {
-                            history.push(message);
-                            emit(LoopEvent::new(
-                                "hook_action",
-                                json!({
-                                    "hook": "pre_step",
-                                    "action": action.clone(),
-                                    "reason": reason.clone(),
-                                    "round": round_index,
-                                }),
-                            ));
-                        }
-                        // Verdicts that took no action. Without these a trace
-                        // shows only the rounds a hook intervened in, which is a
-                        // numerator with no denominator — "routing allowed a
-                        // no-tool turn" and "routing never ran" look identical.
-                        for note in notes {
-                            emit(LoopEvent::new(
-                                "hook_action",
-                                json!({
-                                    "hook": "pre_step",
-                                    "action": note.action,
-                                    "reason": note.reason,
-                                    "value": note.value,
-                                    "probability": note.probability,
-                                    "round": round_index,
-                                }),
-                            ));
-                        }
-                        (tool_choice, tool_choice_honored)
+                    for message in appends {
+                        history.push(message);
+                        emit(LoopEvent::new(
+                            "hook_action",
+                            json!({
+                                "hook": "pre_step",
+                                "action": append_action.clone().unwrap_or_else(|| action.clone()),
+                                "reason": append_reason.clone().or_else(|| reason.clone()),
+                                "round": round_index,
+                            }),
+                        ));
                     }
-                };
+                    for _ in 0..appended_count {
+                        emit(LoopEvent::new(
+                            "hook_action",
+                            json!({
+                                "hook": "pre_step",
+                                "action": append_action.clone().unwrap_or_else(|| "append".to_string()),
+                                "reason": append_reason.clone(),
+                                "round": round_index,
+                            }),
+                        ));
+                    }
+                    // Verdicts that took no action. Without these a trace
+                    // shows only the rounds a hook intervened in, which is a
+                    // numerator with no denominator — "routing allowed a
+                    // no-tool turn" and "routing never ran" look identical.
+                    for note in notes {
+                        emit(LoopEvent::new(
+                            "hook_action",
+                            json!({
+                                "hook": "pre_step",
+                                "action": note.action,
+                                "reason": note.reason,
+                                "value": note.value,
+                                "probability": note.probability,
+                                "round": round_index,
+                            }),
+                        ));
+                    }
+                    (tool_choice, tool_choice_honored)
+                }
+            };
 
             if let Some(tool_choice) = &step_tool_choice {
                 emit(LoopEvent::new(

{steerable_agent_runtime_native-0.6.34 → steerable_agent_runtime_native-0.6.36}/src/hooks.rs

@@ -44,6 +44,9 @@ pub enum PreStepOutcome {
         rewrite: Option<Vec<LLMMessage>>,
         reason: Option<String>,
         action: String,
+        append_reason: Option<String>,
+        append_action: Option<String>,
+        appended_count: u32,
         pre_tokens: Option<i64>,
         post_tokens: Option<i64>,
         tool_choice: Option<String>,
@@ -77,6 +80,9 @@ impl Default for PreStepOutcome {
             rewrite: None,
             reason: None,
             action: "append".into(),
+            append_reason: None,
+            append_action: None,
+            appended_count: 0,
             pre_tokens: None,
             post_tokens: None,
             tool_choice: None,

{steerable_agent_runtime_native-0.6.34 → steerable_agent_runtime_native-0.6.36}/src/python.rs

@@ -358,6 +358,19 @@ impl LoopHooks for CallbackHooks {
                 .and_then(Value::as_str)
                 .unwrap_or("append")
                 .to_string(),
+            append_reason: value
+                .get("append_reason")
+                .and_then(Value::as_str)
+                .map(str::to_string),
+            append_action: value
+                .get("append_action")
+                .and_then(Value::as_str)
+                .map(str::to_string),
+            appended_count: value
+                .get("appended_count")
+                .and_then(Value::as_u64)
+                .and_then(|count| u32::try_from(count).ok())
+                .unwrap_or(0),
             pre_tokens: value.get("pre_tokens").and_then(Value::as_i64),
             post_tokens: value.get("post_tokens").and_then(Value::as_i64),
             tool_choice: value

{steerable_agent_runtime_native-0.6.34 → steerable_agent_runtime_native-0.6.36}/tests/test_loop.rs

@@ -945,6 +945,9 @@ impl LoopHooks for RouteVerdict {
             rewrite: None,
             reason: None,
             action: "append".into(),
+            append_reason: None,
+            append_action: None,
+            appended_count: 0,
             pre_tokens: None,
             post_tokens: None,
             tool_choice: forcing.then(|| "required".to_string()),
@@ -959,6 +962,32 @@ impl LoopHooks for RouteVerdict {
     }
 }
 
+struct RewriteWithFoldedAppend;
+
+#[async_trait]
+impl LoopHooks for RewriteWithFoldedAppend {
+    async fn pre_step(&self, _transcript: &[LLMMessage]) -> PreStepOutcome {
+        PreStepOutcome::Proceed {
+            appends: Vec::new(),
+            rewrite: Some(vec![
+                LLMMessage::text("system", "system"),
+                LLMMessage::text("user", "instruction"),
+                LLMMessage::text("user", "write now"),
+            ]),
+            reason: Some("required tool rounds produced no tool call".into()),
+            action: "livelock_reset".into(),
+            append_reason: Some("forced_empty_livelock_reset".into()),
+            append_action: Some("delivery_nudge".into()),
+            appended_count: 1,
+            pre_tokens: None,
+            post_tokens: None,
+            tool_choice: Some("required".into()),
+            tool_choice_honored: Some(false),
+            notes: Vec::new(),
+        }
+    }
+}
+
 #[tokio::test]
 async fn test_pre_step_notes_record_a_verdict_that_changed_nothing() {
     let mut agent = CoreLoop::new(
@@ -1013,6 +1042,58 @@ async fn test_tool_choice_event_reports_a_vendor_downgrade() {
     assert_eq!(forced.data["honored"], json!(false));
 }
 
+#[tokio::test]
+async fn test_rewrite_with_folded_append_is_sent_once_and_attributed() {
+    let mut agent = CoreLoop::new(
+        provider(vec![text_turn("done")]),
+        RouterToolExecutor::new(ToolRouter::new()),
+    )
+    .with_hooks(RewriteWithFoldedAppend);
+
+    let events = agent
+        .run(vec![
+            LLMMessage::text("system", "old-system"),
+            LLMMessage::text("user", "old-instruction"),
+            LLMMessage::text("assistant", "very long reasoning"),
+        ])
+        .await;
+
+    assert_eq!(
+        agent.provider().calls[0]
+            .iter()
+            .map(LLMMessage::content_text)
+            .collect::<Vec<_>>(),
+        vec!["system", "instruction", "write now"]
+    );
+    assert_eq!(
+        events
+            .iter()
+            .filter(|event| {
+                event.kind == "hook_action" && event.data["action"] == "livelock_reset"
+            })
+            .count(),
+        1
+    );
+    assert_eq!(
+        events
+            .iter()
+            .filter(|event| {
+                event.kind == "hook_action" && event.data["action"] == "delivery_nudge"
+            })
+            .count(),
+        1
+    );
+    let forced = events
+        .iter()
+        .find(|event| {
+            event.kind == "hook_action"
+                && event.data["action"] == "tool_choice"
+                && event.data["value"] == "required"
+        })
+        .unwrap();
+    assert_eq!(forced.data["honored"], false);
+}
+
 struct NarrateOnFailure;
 
 #[async_trait]