chore(release): release version 1.13.0 (minor)

.github/workflows/pr-smoke-test.yml

@@ -153,3 +153,14 @@ jobs:
           SKIP_BUILD: 1
         run: |
           bash scripts/test_subrecipes.sh
+
+      - name: Run Compaction Tests
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          GOOSE_PROVIDER: anthropic
+          GOOSE_MODEL: claude-sonnet-4-5-20250929
+          HOME: /tmp/goose-home
+          GOOSE_DISABLE_KEYRING: 1
+          SKIP_BUILD: 1
+        run: |
+          bash scripts/test_compaction.sh

Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "1.12.0"
+version = "1.13.0"
 authors = ["Block <ai-oss-tools@block.xyz>"]
 license = "Apache-2.0"
 repository = "https://github.com/block/goose"

crates/goose-server/src/routes/reply.rs

@@ -133,6 +133,7 @@ pub enum MessageEvent {
     },
     Finish {
         reason: String,
+        token_state: TokenState,
     },
     ModelChange {
         model: String,
@@ -149,6 +150,27 @@ pub enum MessageEvent {
     Ping,
 }
 
+async fn get_token_state(session_id: &str) -> TokenState {
+    SessionManager::get_session(session_id, false)
+        .await
+        .map(|session| TokenState {
+            input_tokens: session.input_tokens.unwrap_or(0),
+            output_tokens: session.output_tokens.unwrap_or(0),
+            total_tokens: session.total_tokens.unwrap_or(0),
+            accumulated_input_tokens: session.accumulated_input_tokens.unwrap_or(0),
+            accumulated_output_tokens: session.accumulated_output_tokens.unwrap_or(0),
+            accumulated_total_tokens: session.accumulated_total_tokens.unwrap_or(0),
+        })
+        .inspect_err(|e| {
+            tracing::warn!(
+                "Failed to fetch session token state for {}: {}",
+                session_id,
+                e
+            );
+        })
+        .unwrap_or_default()
+}
+
 async fn stream_event(
     event: MessageEvent,
     tx: &mpsc::Sender<String>,
@@ -321,29 +343,7 @@ pub async fn reply(
 
                             all_messages.push(message.clone());
 
-                            let token_state = match SessionManager::get_session(&session_id, false).await {
-                                Ok(session) => {
-                                    TokenState {
-                                        input_tokens: session.input_tokens.unwrap_or(0),
-                                        output_tokens: session.output_tokens.unwrap_or(0),
-                                        total_tokens: session.total_tokens.unwrap_or(0),
-                                        accumulated_input_tokens: session.accumulated_input_tokens.unwrap_or(0),
-                                        accumulated_output_tokens: session.accumulated_output_tokens.unwrap_or(0),
-                                        accumulated_total_tokens: session.accumulated_total_tokens.unwrap_or(0),
-                                    }
-                                },
-                                Err(e) => {
-                                    tracing::warn!("Failed to fetch session for token state: {}", e);
-                                    TokenState {
-                                        input_tokens: 0,
-                                        output_tokens: 0,
-                                        total_tokens: 0,
-                                        accumulated_input_tokens: 0,
-                                        accumulated_output_tokens: 0,
-                                        accumulated_total_tokens: 0,
-                                    }
-                                }
-                            };
+                            let token_state = get_token_state(&session_id).await;
 
                             stream_event(MessageEvent::Message { message, token_state }, &tx, &cancel_token).await;
                         }
@@ -437,9 +437,12 @@ pub async fn reply(
             );
         }
 
+        let final_token_state = get_token_state(&session_id).await;
+
         let _ = stream_event(
             MessageEvent::Finish {
                 reason: "stop".to_string(),
+                token_state: final_token_state,
             },
             &task_tx,
             &cancel_token,

crates/goose/src/agents/agent.rs

@@ -750,14 +750,14 @@ impl Agent {
             .clone()
             .ok_or_else(|| anyhow::anyhow!("Session {} has no conversation", session_config.id))?;
 
-        let needs_auto_compact =
-            crate::context_mgmt::check_if_compaction_needed(self, &conversation, None, &session)
+        let needs_auto_compact = !is_manual_compact
+            && crate::context_mgmt::check_if_compaction_needed(self, &conversation, None, &session)
                 .await?;
 
         let conversation_to_compact = conversation.clone();
 
         Ok(Box::pin(async_stream::try_stream! {
-            let final_conversation = if !needs_auto_compact {
+            let final_conversation = if !needs_auto_compact && !is_manual_compact {
                 conversation
             } else {
                 if !is_manual_compact {

crates/goose/src/conversation/message.rs

@@ -711,7 +711,7 @@ impl Message {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct TokenState {
     pub input_tokens: i32,

crates/goose/src/providers/utils.rs

@@ -553,7 +553,7 @@ impl RequestLog {
     fn finish(&mut self) -> Result<()> {
         if let Some(mut writer) = self.writer.take() {
             writer.flush()?;
-            let logs_dir = crate::logging::prepare_log_directory("llm", true)?;
+            let logs_dir = Paths::in_state_dir("logs");
             let log_path = |i| logs_dir.join(format!("llm_request.{}.jsonl", i));
 
             for i in (0..LOGS_TO_KEEP - 1).rev() {