Method prune_session

crates/opencode-session/src/compaction.rs:717–780

Prune tool results for a session using `SessionOps` for persistence. This is the high-level async version that mirrors the TS `prune()` function which fetches messages, prunes, and persists updates.

(
        &self,
        session_id: &str,
        session_ops: &S,
    )

    /// This is the high-level async version that mirrors the TS `prune()`
    /// function which fetches messages, prunes, and persists updates.
    pub async fn prune_session<S: SessionOps>(
        &self,
        session_id: &str,
        session_ops: &S,
    ) -> anyhow::Result<Vec<String>> {
        if !self.config.prune {
            return Ok(vec![]);
        }

        let msgs = session_ops.messages(session_id).await?;
        let mut prune_msgs = messages_to_prune_format(&msgs);
        let pruned_ids = self.prune(&mut prune_msgs);

        // Persist the compacted timestamps back via session ops.
        // We need to map pruned IDs back to their message_id + part for update.
        for msg in &msgs {
            let message_id = match &msg.info {
                MessageInfo::User { id, .. } => id,
                MessageInfo::Assistant { id, .. } => id,
            };
            for part in &msg.parts {
                if let Part::Tool(tool_part) = part {
                    if pruned_ids.contains(&tool_part.id) {
                        // Re-create the part with the compacted timestamp set.
                        if let ToolState::Completed {
                            input,
                            output,
                            title,
                            metadata,
                            time,
                            attachments,
                        } = &tool_part.state
                        {
                            let updated_part = Part::Tool(crate::message_v2::ToolPart {
                                id: tool_part.id.clone(),
                                session_id: tool_part.session_id.clone(),
                                message_id: tool_part.message_id.clone(),
                                call_id: tool_part.call_id.clone(),
                                tool: tool_part.tool.clone(),
                                state: ToolState::Completed {
                                    input: input.clone(),
                                    output: output.clone(),
                                    title: title.clone(),
                                    metadata: metadata.clone(),
                                    time: CompletedTime {
                                        start: time.start,
                                        end: time.end,
                                        compacted: Some(Utc::now().timestamp_millis()),
                                    },
                                    attachments: attachments.clone(),
                                },
                                metadata: tool_part.metadata.clone(),
                            });
                            let _ = session_ops
                                .update_part(session_id, message_id, updated_part)
                                .await;
                        }
                    }