Method invoke

crates/chat-cli/src/cli/chat/tools/fs_read.rs:269–357

(&self, os: &Os, updates: &mut impl Write)

    }

    pub async fn invoke(&self, os: &Os, updates: &mut impl Write) -> Result<InvokeOutput> {
        if self.operations.len() == 1 {
            // Single operation - return result directly
            self.operations[0].invoke(os, updates).await
        } else {
            // Multiple operations - combine results
            let mut combined_results = Vec::new();
            let mut all_images = Vec::new();
            let mut has_non_image_ops = false;
            let mut success_ops = 0usize;
            let mut failed_ops = 0usize;

            for (i, op) in self.operations.iter().enumerate() {
                match op.invoke(os, updates).await {
                    Ok(result) => {
                        success_ops += 1;

                        match &result.output {
                            OutputKind::Text(text) => {
                                combined_results.push(format!("=== Operation {} Result (Text) ===\n{}", i + 1, text));
                                has_non_image_ops = true;
                            },
                            OutputKind::Json(json) => {
                                combined_results.push(format!(
                                    "=== Operation {} Result (Json) ===\n{}",
                                    i + 1,
                                    serde_json::to_string_pretty(json)?
                                ));
                                has_non_image_ops = true;
                            },
                            OutputKind::Images(images) => {
                                all_images.extend(images.clone());
                                combined_results.push(format!(
                                    "=== Operation {} Result (Images) ===\n[{} images processed]",
                                    i + 1,
                                    images.len()
                                ));
                            },
                            // This branch won't be reached because single operation execution never returns a Mixed
                            // result
                            OutputKind::Mixed { text: _, images: _ } => {},
                        }
                    },

                    Err(err) => {
                        failed_ops += 1;
                        combined_results.push(format!("=== Operation {} Error ===\n{}", i + 1, err));
                    },
                }
            }

            queue!(
                updates,
                style::Print("\n"),
                style::Print(CONTINUATION_LINE),
                style::Print("\n")
            )?;
            super::queue_function_result(