dial-providers 4.1.3

AI provider implementations for DIAL engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use async_trait::async_trait;
use dial_core::provider::{Provider, ProviderRequest, ProviderResponse};
use dial_core::errors::Result;
use std::time::Instant;
use tokio::process::Command;

/// Provider that shells out to a CLI AI tool (claude, codex, gemini).
pub struct CliPassthrough {
    /// CLI binary name (e.g., "claude", "codex")
    pub cli: String,
}

impl CliPassthrough {
    pub fn new(cli: &str) -> Self {
        Self { cli: cli.to_string() }
    }

    fn build_args(&self, request: &ProviderRequest) -> Vec<String> {
        match self.cli.as_str() {
            "claude" => vec![
                "-p".to_string(),
                request.prompt.clone(),
                "--output-format".to_string(),
                "text".to_string(),
            ],
            "codex" => vec![
                "--task".to_string(),
                request.prompt.clone(),
            ],
            _ => vec![request.prompt.clone()],
        }
    }
}

#[async_trait]
impl Provider for CliPassthrough {
    fn name(&self) -> &str {
        &self.cli
    }

    async fn execute(&self, request: ProviderRequest) -> Result<ProviderResponse> {
        let start = Instant::now();
        let args = self.build_args(&request);

        let timeout = request.timeout_secs.unwrap_or(600);

        let output = tokio::time::timeout(
            std::time::Duration::from_secs(timeout),
            Command::new(&self.cli)
                .args(&args)
                .current_dir(&request.work_dir)
                .output()
        )
        .await
        .map_err(|_| dial_core::errors::DialError::CommandTimeout(timeout))?
        .map_err(|e| dial_core::errors::DialError::CommandFailed(e.to_string()))?;

        let duration = start.elapsed().as_secs_f64();
        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
        let combined = if stderr.is_empty() {
            stdout
        } else {
            format!("{}\n{}", stdout, stderr)
        };

        Ok(ProviderResponse {
            output: combined,
            success: output.status.success(),
            exit_code: output.status.code(),
            usage: None, // CLI tools don't report token usage
            model: None,
            duration_secs: Some(duration),
        })
    }

    async fn is_available(&self) -> bool {
        Command::new("which")
            .arg(&self.cli)
            .output()
            .await
            .map(|o| o.status.success())
            .unwrap_or(false)
    }
}