feat(minichat): Persist web_search/code_interpreter completed counts in chat_turns

Signed-off-by: Jalan Kulkija <ankoo67@proton.me>

Author: jalankulkija

modules/mini-chat/mini-chat/src/domain/model/finalization.rs

@@ -119,4 +119,8 @@ pub struct OrphanFinalizationInput {
     pub minimal_generation_floor_applied: Option<i32>,
     /// `started_at` — used to derive `period_starts` for quota settlement.
     pub started_at: OffsetDateTime,
+    /// Completed web search tool calls persisted from the DB (0 if pod crashed before increment).
+    pub web_search_completed_count: u32,
+    /// Completed code interpreter tool calls persisted from the DB (0 if pod crashed before increment).
+    pub code_interpreter_completed_count: u32,
 }

modules/mini-chat/mini-chat/src/domain/repos/mod.rs

@@ -32,7 +32,8 @@ pub(crate) use quota_usage_repo::{IncrementReserveParams, QuotaUsageRepository,
 pub(crate) use reaction_repo::{ReactionRepository, UpsertReactionParams};
 pub(crate) use thread_summary_repo::{ThreadSummaryModel, ThreadSummaryRepository};
 pub(crate) use turn_repo::{
-    CasCompleteParams, CasTerminalParams, CreateTurnParams, TurnRepository, UpdatePreflightParams,
+    CasCompleteParams, CasTerminalParams, CreateTurnParams, ToolCallType, TurnRepository,
+    UpdatePreflightParams,
 };
 pub(crate) use user_limits_provider::UserLimitsProvider;
 pub(crate) use vector_store_repo::{InsertVectorStoreParams, VectorStoreRepository};

modules/mini-chat/mini-chat/src/domain/repos/turn_repo.rs

@@ -69,6 +69,14 @@ pub struct UpdatePreflightParams {
     pub minimal_generation_floor_applied: i32,
 }
 
+/// Identifies which completed tool call counter to increment.
+#[domain_model]
+#[derive(Debug, Clone, Copy)]
+pub enum ToolCallType {
+    WebSearch,
+    CodeInterpreter,
+}
+
 /// Repository trait for turn persistence operations.
 #[async_trait]
 #[allow(dead_code)]
@@ -212,4 +220,16 @@ pub trait TurnRepository: Send + Sync {
         scope: &AccessScope,
         params: UpdatePreflightParams,
     ) -> Result<u64, DomainError>;
+
+    /// Atomically increment the completed tool call counter for a turn.
+    ///
+    /// Called from the streaming task on `ToolPhase::Done`. Best-effort:
+    /// callers are expected to log and swallow errors.
+    async fn increment_tool_calls<C: DBRunner>(
+        &self,
+        runner: &C,
+        scope: &AccessScope,
+        turn_id: Uuid,
+        tool: ToolCallType,
+    ) -> Result<(), DomainError>;
 }

modules/mini-chat/mini-chat/src/domain/service/finalization_service.rs

@@ -518,8 +518,8 @@ impl<TR: TurnRepository + 'static, MR: MessageRepository + 'static> Finalization
                                 .unwrap_or(0),
                             settlement_path: SettlementPath::Estimated,
                             period_starts,
-                            web_search_calls: 0,
-                            code_interpreter_calls: 0,
+                            web_search_calls: input.web_search_completed_count,
+                            code_interpreter_calls: input.code_interpreter_completed_count,
                         };
 
                         let scope = modkit_security::AccessScope::allow_all();
@@ -571,8 +571,8 @@ impl<TR: TurnRepository + 'static, MR: MessageRepository + 'static> Finalization
                         actual_credits_micro,
                         settlement_method: settlement_method_str.to_owned(),
                         policy_version_applied: input.policy_version_applied.unwrap_or(0),
-                        web_search_calls: 0,
-                        code_interpreter_calls: 0,
+                        web_search_calls: input.web_search_completed_count,
+                        code_interpreter_calls: input.code_interpreter_completed_count,
                         timestamp: now,
                     };
                     outbox_enqueuer
@@ -1758,6 +1758,8 @@ mod tests {
             policy_version_applied: Some(1),
             minimal_generation_floor_applied: Some(10),
             started_at: time::OffsetDateTime::now_utc(),
+            web_search_completed_count: 0,
+            code_interpreter_completed_count: 0,
         };
 
         let result = svc.finalize_orphan_turn(input, 60).await.unwrap();
@@ -1803,6 +1805,56 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn finalize_orphan_tool_counts_propagate_to_usage_event() {
+        let db = mock_db_provider(inmem_db().await);
+        let (svc, outbox) = build_finalization_service(Arc::clone(&db));
+
+        let tenant_id = Uuid::new_v4();
+        let chat_id = Uuid::new_v4();
+        let turn_id = Uuid::new_v4();
+        let request_id = Uuid::new_v4();
+        let user_id = Uuid::new_v4();
+
+        insert_test_chat(&db, tenant_id, chat_id, user_id).await;
+        insert_running_turn(&db, tenant_id, chat_id, turn_id, request_id).await;
+
+        let conn = db.conn().unwrap();
+        backdate_turn_progress(&conn, turn_id).await;
+
+        let input = crate::domain::model::finalization::OrphanFinalizationInput {
+            turn_id,
+            tenant_id,
+            chat_id,
+            request_id,
+            user_id: Some(user_id),
+            requester_type: mini_chat_sdk::RequesterType::User,
+            effective_model: Some("gpt-5.2".to_owned()),
+            reserve_tokens: Some(100),
+            max_output_tokens_applied: Some(4096),
+            reserved_credits_micro: Some(1000),
+            policy_version_applied: Some(1),
+            minimal_generation_floor_applied: Some(10),
+            started_at: time::OffsetDateTime::now_utc(),
+            web_search_completed_count: 3,
+            code_interpreter_completed_count: 2,
+        };
+
+        let result = svc.finalize_orphan_turn(input, 60).await.unwrap();
+        assert!(result, "should be CAS winner");
+
+        let usage_events = outbox.usage_events.lock().unwrap();
+        assert_eq!(usage_events.len(), 1);
+        assert_eq!(
+            usage_events[0].web_search_calls, 3,
+            "web_search_calls must reflect persisted count"
+        );
+        assert_eq!(
+            usage_events[0].code_interpreter_calls, 2,
+            "code_interpreter_calls must reflect persisted count"
+        );
+    }
+
     #[tokio::test]
     async fn finalize_orphan_cas_loser() {
         let db = mock_db_provider(inmem_db().await);
@@ -1852,6 +1904,8 @@ mod tests {
             policy_version_applied: Some(1),
             minimal_generation_floor_applied: Some(10),
             started_at: time::OffsetDateTime::now_utc(),
+            web_search_completed_count: 0,
+            code_interpreter_completed_count: 0,
         };
 
         let result = svc.finalize_orphan_turn(input, 60).await.unwrap();
@@ -1901,6 +1955,8 @@ mod tests {
             policy_version_applied: Some(1),
             minimal_generation_floor_applied: Some(10),
             started_at: time::OffsetDateTime::now_utc(),
+            web_search_completed_count: 0,
+            code_interpreter_completed_count: 0,
         };
 
         let result = svc.finalize_orphan_turn(input, 60).await.unwrap();

modules/mini-chat/mini-chat/src/domain/service/replay.rs

@@ -289,6 +289,8 @@ mod tests {
             effective_model,
             minimal_generation_floor_applied: Some(10),
             web_search_enabled: false,
+            web_search_completed_count: 0,
+            code_interpreter_completed_count: 0,
             deleted_at: None,
             replaced_by_request_id: None,
             started_at: OffsetDateTime::now_utc(),

modules/mini-chat/mini-chat/src/domain/service/stream_service/mod.rs

@@ -4829,6 +4829,8 @@ mod tests {
             effective_model: Set(None),
             minimal_generation_floor_applied: Set(None),
             web_search_enabled: Set(false),
+            web_search_completed_count: Set(0),
+            code_interpreter_completed_count: Set(0),
             deleted_at: Set(None),
             replaced_by_request_id: Set(None),
             started_at: Set(now),

modules/mini-chat/mini-chat/src/domain/service/stream_service/provider_task.rs

@@ -8,7 +8,7 @@ use tracing::{Instrument, debug, info, warn};
 
 use crate::domain::llm::ToolPhase;
 use crate::domain::ports::metric_labels::{stage, trigger};
-use crate::domain::repos::{MessageRepository, TurnRepository};
+use crate::domain::repos::{MessageRepository, ToolCallType, TurnRepository};
 use crate::domain::stream_events::{DoneData, ErrorData, StreamEvent};
 use crate::infra::db::entity::chat_turn::TurnState;
 use crate::infra::llm::{
@@ -394,6 +394,18 @@ pub(super) fn spawn_provider_task<TR: TurnRepository + 'static, MR: MessageRepos
                                     }
                                     ToolPhase::Done => {
                                         web_search_completed_count += 1;
+                                        if let Some(ref fctx) = fin_ctx {
+                                            match fctx.db.conn() {
+                                                Ok(conn) => {
+                                                    if let Err(e) = fctx.turn_repo.increment_tool_calls(&conn, &fctx.scope, fctx.turn_id, ToolCallType::WebSearch).await {
+                                                        warn!(turn_id = %fctx.turn_id, error = %e, "failed to persist web_search_completed_count");
+                                                    }
+                                                }
+                                                Err(e) => {
+                                                    warn!(turn_id = %fctx.turn_id, error = %e, "failed to acquire DB connection for web_search_completed_count");
+                                                }
+                                            }
+                                        }
                                     }
                                 }
                             }
@@ -480,6 +492,18 @@ pub(super) fn spawn_provider_task<TR: TurnRepository + 'static, MR: MessageRepos
                                     }
                                     ToolPhase::Done => {
                                         code_interpreter_completed_count += 1;
+                                        if let Some(ref fctx) = fin_ctx {
+                                            match fctx.db.conn() {
+                                                Ok(conn) => {
+                                                    if let Err(e) = fctx.turn_repo.increment_tool_calls(&conn, &fctx.scope, fctx.turn_id, ToolCallType::CodeInterpreter).await {
+                                                        warn!(turn_id = %fctx.turn_id, error = %e, "failed to persist code_interpreter_completed_count");
+                                                    }
+                                                }
+                                                Err(e) => {
+                                                    warn!(turn_id = %fctx.turn_id, error = %e, "failed to acquire DB connection for code_interpreter_completed_count");
+                                                }
+                                            }
+                                        }
                                     }
                                 }
                             }

modules/mini-chat/mini-chat/src/infra/db/entity/chat_turn.rs

@@ -30,6 +30,8 @@ pub struct Model {
     pub effective_model: Option<String>,
     pub minimal_generation_floor_applied: Option<i32>,
     pub web_search_enabled: bool,
+    pub web_search_completed_count: i32,
+    pub code_interpreter_completed_count: i32,
     pub deleted_at: Option<OffsetDateTime>,
     pub replaced_by_request_id: Option<Uuid>,
     pub started_at: OffsetDateTime,

modules/mini-chat/mini-chat/src/infra/db/migrations/m20260402_000003_add_tool_counts_to_turns.rs

@@ -0,0 +1,32 @@
+use sea_orm_migration::prelude::*;
+use sea_orm_migration::sea_orm::ConnectionTrait;
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        let conn = manager.get_connection();
+        conn.execute_unprepared(
+            "ALTER TABLE chat_turns ADD COLUMN web_search_completed_count INT NOT NULL DEFAULT 0",
+        )
+        .await?;
+        conn.execute_unprepared(
+            "ALTER TABLE chat_turns ADD COLUMN code_interpreter_completed_count INT NOT NULL DEFAULT 0",
+        )
+        .await?;
+        Ok(())
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        let conn = manager.get_connection();
+        conn.execute_unprepared("ALTER TABLE chat_turns DROP COLUMN web_search_completed_count")
+            .await?;
+        conn.execute_unprepared(
+            "ALTER TABLE chat_turns DROP COLUMN code_interpreter_completed_count",
+        )
+        .await?;
+        Ok(())
+    }
+}

modules/mini-chat/mini-chat/src/infra/db/migrations/mod.rs

@@ -3,6 +3,7 @@ use sea_orm_migration::prelude::*;
 mod m20260302_000001_initial;
 mod m20260329_000001_add_last_progress_at;
 mod m20260330_000002_add_web_search_enabled_to_turns;
+mod m20260402_000003_add_tool_counts_to_turns;
 
 pub struct Migrator;
 
@@ -13,6 +14,7 @@ impl MigratorTrait for Migrator {
             Box::new(m20260302_000001_initial::Migration),
             Box::new(m20260329_000001_add_last_progress_at::Migration),
             Box::new(m20260330_000002_add_web_search_enabled_to_turns::Migration),
+            Box::new(m20260402_000003_add_tool_counts_to_turns::Migration),
         ]
     }
 }