aca 0.3.1

A Rust-based agentic tool that automates coding tasks using Claude Code and OpenAI Codex CLI integrations
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::PathBuf;
use std::time::Duration;
use uuid::Uuid;

pub type TaskId = Uuid;

/// Configuration for interacting with the Codex CLI.
#[derive(Debug, Clone)]
pub struct OpenAIConfig {
    pub cli_path: String,
    pub default_model: String,
    pub profile: Option<String>,
    pub working_dir: PathBuf,
    pub extra_args: Vec<String>,
    pub allow_outside_git: bool,
    pub rate_limits: OpenAIRateLimitConfig,
    pub logging: OpenAILoggingConfig,
}

/// Logging configuration for Codex CLI executions.
#[derive(Debug, Clone)]
pub struct OpenAILoggingConfig {
    pub enable_interaction_logs: bool,
    pub max_preview_chars: usize,
}

/// Rate limiting configuration shared with the provider.
#[derive(Debug, Clone)]
pub struct OpenAIRateLimitConfig {
    pub max_tokens_per_minute: u64,
    pub max_requests_per_minute: u64,
    pub burst_allowance: u64,
    pub backoff_multiplier: f64,
    pub max_backoff_delay: Duration,
}

/// Request forwarded to the Codex CLI.
#[derive(Debug, Clone)]
pub struct OpenAITaskRequest {
    pub id: TaskId,
    pub prompt: String,
    pub metadata: HashMap<String, String>,
    pub model: String,
    pub estimated_tokens: u64,
    pub system_message: Option<String>,
}

/// Response returned from the Codex CLI.
#[derive(Debug, Clone)]
pub struct OpenAITaskResponse {
    pub task_id: TaskId,
    pub response_text: String,
    pub token_usage: TokenUsage,
    pub execution_time: Duration,
    pub model_used: String,
    pub finish_reason: Option<String>,
}

/// Token usage reported by Codex.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct TokenUsage {
    pub prompt_tokens: u64,
    pub cached_prompt_tokens: u64,
    pub completion_tokens: u64,
    pub total_tokens: u64,
    pub estimated_cost: f64,
}

/// Permit returned by the smart rate limiter.
#[derive(Debug, Clone)]
pub struct RatePermit {
    pub granted_at: DateTime<Utc>,
    pub tokens_consumed: u64,
    pub permit_id: Uuid,
}

/// Errors emitted by the Codex CLI integration.
#[derive(Debug, thiserror::Error)]
pub enum OpenAIError {
    #[error("Rate limit exceeded: {message}")]
    RateLimit {
        message: String,
        reset_time: Option<DateTime<Utc>>,
    },
    #[error("Codex CLI not found at path: {0}")]
    CliUnavailable(String),
    #[error("Authentication required: {0}")]
    Authentication(String),
    #[error("Invalid request: {0}")]
    InvalidRequest(String),
    #[error("Context too large: current={current}, max={max}")]
    ContextTooLarge { current: u64, max: u64 },
    #[error("Failed to execute Codex CLI: {0}")]
    CliFailed(String),
    #[error("Serialization error: {0}")]
    Serialization(String),
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error("Unknown Codex error: {0}")]
    Unknown(String),
}

impl Default for OpenAIRateLimitConfig {
    fn default() -> Self {
        Self {
            max_tokens_per_minute: 60_000,
            max_requests_per_minute: 60,
            burst_allowance: 4_000,
            backoff_multiplier: 2.0,
            max_backoff_delay: Duration::from_secs(300),
        }
    }
}