feat(ai): add Codex CLI as a no-API-key AI provider for Desktop

* codex cli provider

* fixes

* mcp check

* reasoning

* simplify

* minor fixes
This commit is contained in:
Oleksandr Liakhevych authored and GitHub committed 2026-06-19 08:51:10 +08:00
1 parent 93a6a65707
commit 4f5d09aaa8
22 files changed
+1401 -101

No files matched your search

+27
View File
@@ -9,6 +9,7 @@ use tokio::sync::Notify;
use crate::agent_events::{AgentEvent, ToolCall, ToolDefinition, ToolResult};
use crate::agent_tools;
use crate::ai::{self, AiCompletionRequest, AiConfig, AiMessage, AiProvider, AiStreamChunk};
use crate::ai_cli_agent::CliAgentCommandSpec;
use crate::connection::AppState;
use crate::models::connection::DatabaseType;
use crate::token_usage::TokenUsage;
@@ -27,6 +28,7 @@ pub struct AgentLoopContext {
pub connection_id: String,
pub database: String,
pub db_type: DatabaseType,
pub cli_mcp_server_command: Option<CliAgentCommandSpec>,
}
/// Check if the provider supports function calling / tool use.
@@ -59,6 +61,31 @@ pub async fn run_agent_loop(
temperature: Option<f32>,
is_agent_mode: bool,
) -> Result<String, String> {
if matches!(config.provider, AiProvider::CodexCli) {
let connection_name = {
let configs = agent_ctx.state.configs.read().await;
configs
.get(&agent_ctx.connection_id)
.map(|config| config.name.clone())
.unwrap_or_else(|| agent_ctx.connection_id.clone())
};
let prompt = crate::ai_codex_cli::build_codex_prompt(system_prompt, messages);
return crate::ai_codex_cli::run_codex_agent(
config,
&prompt,
crate::ai_codex_cli::CodexRunOptions {
connection_id: agent_ctx.connection_id.clone(),
connection_name,
database: agent_ctx.database.clone(),
agent_mode: is_agent_mode,
mcp_server_command: agent_ctx.cli_mcp_server_command.clone(),
},
cancelled,
on_event,
)
.await;
}
// Auto-degrade: providers without function calling fall back to text-only completion.
if !provider_supports_function_calling(config) {
return run_agent_loop_text_only(
+74 -1
View File
@@ -50,6 +50,8 @@ pub enum AiProvider {
Ollama,
#[serde(rename = "openai-compatible")]
OpenaiCompatible,
#[serde(rename = "codex-cli")]
CodexCli,
Custom,
}
@@ -69,6 +71,29 @@ pub enum AiAuthMethod {
Bearer,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
#[serde(rename_all = "kebab-case")]
pub enum AiReasoningLevel {
#[default]
Default,
Minimal,
Low,
Medium,
High,
}
impl AiReasoningLevel {
pub fn as_codex_effort(&self) -> Option<&'static str> {
match self {
AiReasoningLevel::Default => None,
AiReasoningLevel::Minimal => Some("minimal"),
AiReasoningLevel::Low => Some("low"),
AiReasoningLevel::Medium => Some("medium"),
AiReasoningLevel::High => Some("high"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AiConfig {
@@ -90,7 +115,11 @@ pub struct AiConfig {
#[serde(default = "default_enable_thinking")]
pub enable_thinking: bool,
#[serde(default)]
pub reasoning_level: AiReasoningLevel,
#[serde(default)]
pub context_window: Option<u32>,
#[serde(default)]
pub codex_cli_path: Option<String>,
}
fn default_enable_thinking() -> bool {
@@ -234,6 +263,7 @@ pub fn resolve_endpoint(config: &AiConfig) -> String {
}
match config.provider {
AiProvider::Claude => format!("{ep}/messages"),
AiProvider::CodexCli => unreachable!(),
AiProvider::Openai
| AiProvider::Deepseek
| AiProvider::Qwen
@@ -465,6 +495,9 @@ pub fn build_responses_input(system_prompt: &str, messages: &[AiMessage]) -> ser
// ---------------------------------------------------------------------------
fn validate_config(config: &AiConfig) -> Result<(), String> {
if matches!(config.provider, AiProvider::CodexCli) {
return Ok(());
}
if !matches!(config.provider, AiProvider::Ollama) && config.api_key.trim().is_empty() {
return Err("API key is required".to_string());
}
@@ -478,6 +511,9 @@ fn validate_config(config: &AiConfig) -> Result<(), String> {
}
fn validate_model_list_config(config: &AiConfig) -> Result<(), String> {
if matches!(config.provider, AiProvider::CodexCli) {
return Ok(());
}
if !matches!(config.provider, AiProvider::Ollama) && config.api_key.trim().is_empty() {
return Err("API key is required".to_string());
}
@@ -611,6 +647,9 @@ async fn list_openai_compatible_models(
}
pub async fn list_models_core(config: &AiConfig) -> Result<Vec<AiModelInfo>, String> {
if matches!(config.provider, AiProvider::CodexCli) {
return crate::ai_codex_cli::list_codex_models(config).await;
}
validate_model_list_config(config)?;
let client = build_ai_http_client(config, 30)?;
@@ -623,6 +662,7 @@ pub async fn list_models_core(config: &AiConfig) -> Result<Vec<AiModelInfo>, Str
| AiProvider::Ollama
| AiProvider::OpenaiCompatible
| AiProvider::Custom => list_openai_compatible_models(&client, config).await,
AiProvider::CodexCli => unreachable!(),
AiProvider::Gemini => {
Err("Model listing is only supported for OpenAI-compatible and Claude providers".to_string())
}
@@ -844,6 +884,9 @@ fn claude_system_prompt(system_prompt: &str) -> &str {
}
pub async fn test_connection_core(config: &AiConfig) -> Result<AiTestConnectionResult, String> {
if matches!(config.provider, AiProvider::CodexCli) {
return crate::ai_codex_cli::test_codex_connection(config).await;
}
validate_config(config)?;
let client = build_ai_http_client(config, 15)?;
@@ -973,11 +1016,16 @@ fn classify_error(msg: &str) -> &'static str {
pub async fn complete(request: &AiCompletionRequest) -> Result<String, String> {
validate_config(&request.config)?;
if matches!(request.config.provider, AiProvider::CodexCli) {
return Err("Codex CLI provider is only supported in DBX AI agent mode".to_string());
}
let client = build_ai_http_client(&request.config, 60)?;
match request.config.provider {
AiProvider::Claude => call_claude(&client, request.clone()).await,
AiProvider::Gemini => call_gemini(&client, request.clone()).await,
AiProvider::CodexCli => unreachable!(),
AiProvider::Openai
| AiProvider::Deepseek
| AiProvider::Qwen
@@ -1005,12 +1053,17 @@ pub async fn stream(
) -> Result<(), String> {
validate_config(&request.config)?;
if matches!(request.config.provider, AiProvider::CodexCli) {
return Err("Codex CLI provider is only supported in DBX AI agent mode".to_string());
}
let stream_timeout = if request.config.enable_thinking { 600 } else { 120 };
let client = build_ai_http_client(&request.config, stream_timeout)?;
match request.config.provider {
AiProvider::Claude => stream_claude(&client, session_id, request, cancelled, &on_chunk).await,
AiProvider::Gemini => stream_gemini(&client, session_id, request, cancelled, &on_chunk).await,
AiProvider::CodexCli => unreachable!(),
AiProvider::Openai
| AiProvider::Deepseek
| AiProvider::Qwen
@@ -2025,7 +2078,7 @@ mod tests {
build_ai_http_client, claude_headers, claude_system_prompt, gemini_text, is_kimi_model, openai_response_text,
openai_stream_reasoning, openai_stream_text, parse_model_list_response, resolve_endpoint,
resolve_model_list_endpoint, responses_max_output_tokens, responses_text, supports_temperature,
validate_config, AiApiStyle, AiAuthMethod, AiConfig, AiModelInfo, AiProvider, AUTHORIZATION,
validate_config, AiApiStyle, AiAuthMethod, AiConfig, AiModelInfo, AiProvider, AiReasoningLevel, AUTHORIZATION,
CLAUDE_DEFAULT_SYSTEM,
};
@@ -2058,7 +2111,9 @@ mod tests {
proxy_enabled: true,
proxy_url: "not a proxy url".to_string(),
enable_thinking: true,
reasoning_level: AiReasoningLevel::Default,
context_window: None,
codex_cli_path: None,
};
let err = build_ai_http_client(&config, 1).unwrap_err();
@@ -2078,7 +2133,9 @@ mod tests {
proxy_enabled: true,
proxy_url: "127.0.0.1:7890".to_string(),
enable_thinking: true,
reasoning_level: AiReasoningLevel::Default,
context_window: None,
codex_cli_path: None,
};
build_ai_http_client(&config, 1).unwrap();
@@ -2096,7 +2153,9 @@ mod tests {
proxy_enabled: true,
proxy_url: "not a proxy url".to_string(),
enable_thinking: true,
reasoning_level: AiReasoningLevel::Default,
context_window: None,
codex_cli_path: None,
};
build_ai_http_client(&config, 1).unwrap();
@@ -2114,7 +2173,9 @@ mod tests {
proxy_enabled: false,
proxy_url: String::new(),
enable_thinking: true,
reasoning_level: AiReasoningLevel::Default,
context_window: None,
codex_cli_path: None,
};
assert_eq!(
@@ -2132,7 +2193,9 @@ mod tests {
proxy_enabled: false,
proxy_url: String::new(),
enable_thinking: true,
reasoning_level: AiReasoningLevel::Default,
context_window: None,
codex_cli_path: None,
};
assert_eq!(resolve_endpoint(&ollama), "http://localhost:11434/v1/chat/completions");
@@ -2151,7 +2214,9 @@ mod tests {
proxy_enabled: false,
proxy_url: String::new(),
enable_thinking: true,
reasoning_level: AiReasoningLevel::Default,
context_window: None,
codex_cli_path: None,
};
assert_eq!(resolve_model_list_endpoint(&openai).unwrap(), "https://api.openai.com/v1/models");
@@ -2165,7 +2230,9 @@ mod tests {
proxy_enabled: false,
proxy_url: String::new(),
enable_thinking: true,
reasoning_level: AiReasoningLevel::Default,
context_window: None,
codex_cli_path: None,
};
assert_eq!(resolve_model_list_endpoint(&claude).unwrap(), "https://api.anthropic.com/v1/models");
}
@@ -2183,7 +2250,9 @@ mod tests {
proxy_enabled: false,
proxy_url: String::new(),
enable_thinking: true,
reasoning_level: AiReasoningLevel::Default,
context_window: None,
codex_cli_path: None,
};
assert_eq!(resolve_endpoint(&config), "https://api.example.com/v1/chat/completions");
assert_eq!(resolve_model_list_endpoint(&config).unwrap(), "https://api.example.com/v1/models");
@@ -2236,7 +2305,9 @@ mod tests {
proxy_enabled: false,
proxy_url: String::new(),
enable_thinking: true,
reasoning_level: AiReasoningLevel::Default,
context_window: None,
codex_cli_path: None,
};
let api_key_headers = claude_headers(&config).unwrap();
@@ -2305,7 +2376,9 @@ mod tests {
proxy_enabled: false,
proxy_url: String::new(),
enable_thinking: true,
reasoning_level: AiReasoningLevel::Default,
context_window: None,
codex_cli_path: None,
};
assert!(!supports_temperature(&config));
+457
View File
@@ -0,0 +1,457 @@
use crate::agent_events::AgentEvent;
use crate::ai::{AiMessage, AiModelInfo};
use crate::token_usage::TokenUsage;
use serde_json::Value;
use std::process::Stdio;
use tokio::io::{AsyncBufReadExt, AsyncReadExt, BufReader};
use tokio::process::Command;
use tokio::sync::Notify;
#[derive(Debug, Clone)]
pub struct CliAgentRunOptions {
pub connection_id: String,
pub connection_name: String,
pub database: String,
pub agent_mode: bool,
pub mcp_server_command: Option<CliAgentCommandSpec>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CliAgentCommandSpec {
pub program: String,
pub args: Vec<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CliAgentJsonlDialect {
CodexExec,
}
pub struct CliAgentProcessSpec {
pub command: CliAgentCommandSpec,
pub dialect: CliAgentJsonlDialect,
pub classify_spawn_error: fn(&str) -> String,
pub classify_run_error: fn(&str) -> String,
}
pub fn toml_string(value: &str) -> String {
serde_json::to_string(value).unwrap_or_else(|_| "\"\"".to_string())
}
pub fn toml_string_array(values: &[&str]) -> String {
let items = values.iter().map(|value| toml_string(value)).collect::<Vec<_>>().join(", ");
format!("[{items}]")
}
pub fn dbx_mcp_enabled_tools(agent_mode: bool) -> Vec<&'static str> {
let mut tools = vec!["dbx_list_connections", "dbx_list_tables", "dbx_describe_table", "dbx_get_schema_context"];
if agent_mode {
tools.push("dbx_execute_query");
}
tools
}
pub fn dbx_mcp_scope_env(options: &CliAgentRunOptions) -> Vec<(&'static str, String)> {
vec![
("DBX_MCP_ALLOW_WRITES", "0".to_string()),
("DBX_MCP_SCOPE_CONNECTION_ID", options.connection_id.clone()),
("DBX_MCP_SCOPE_CONNECTION_NAME", options.connection_name.clone()),
("DBX_MCP_SCOPE_DATABASE", options.database.clone()),
]
}
pub fn append_config_overrides(args: &mut Vec<String>, overrides: impl IntoIterator<Item = String>) {
for override_arg in overrides {
args.push("-c".to_string());
args.push(override_arg);
}
}
pub fn build_cli_agent_prompt(provider_label: &str, system_prompt: &str, messages: &[AiMessage]) -> String {
let mut sections = vec![
format!("You are running inside DBX Desktop as the {provider_label} CLI provider."),
"Use the DBX MCP tools when you need live database schema or read-only query results.".to_string(),
"Do not modify files or run shell commands. The DBX MCP server is the only intended tool surface.".to_string(),
String::new(),
"## System instructions".to_string(),
system_prompt.to_string(),
String::new(),
"## Conversation".to_string(),
];
for message in messages {
sections.push(format!("### {}", message.role));
sections.push(message.content.clone());
if !message.tool_calls.is_empty() {
sections.push(format!("[Previous tool calls omitted from CLI replay: {}]", message.tool_calls.len()));
}
sections.push(String::new());
}
sections.join("\n")
}
pub fn model_infos(ids: &[&str]) -> Vec<AiModelInfo> {
ids.iter().map(|id| AiModelInfo { id: (*id).to_string(), display_name: None }).collect()
}
pub async fn list_json_models_or_default(
program: String,
args: impl IntoIterator<Item = String>,
default_models: &[&str],
) -> Result<Vec<AiModelInfo>, String> {
let output = Command::new(program).args(args).output().await;
let Ok(output) = output else {
return Ok(model_infos(default_models));
};
if !output.status.success() {
return Ok(model_infos(default_models));
}
let stdout = String::from_utf8_lossy(&output.stdout);
let Ok(data) = serde_json::from_str::<Value>(&stdout) else {
return Ok(model_infos(default_models));
};
let mut models = Vec::new();
collect_model_ids(&data, &mut models);
models.sort();
models.dedup();
if models.is_empty() {
Ok(model_infos(default_models))
} else {
let mut result = vec![AiModelInfo { id: "default".to_string(), display_name: None }];
result.extend(models.into_iter().map(|id| AiModelInfo { id, display_name: None }));
Ok(result)
}
}
fn collect_model_ids(value: &Value, out: &mut Vec<String>) {
match value {
Value::Object(map) => {
if let Some(id) = map.get("id").and_then(Value::as_str).or_else(|| map.get("name").and_then(Value::as_str))
{
if !id.trim().is_empty() {
out.push(id.to_string());
}
}
for child in map.values() {
collect_model_ids(child, out);
}
}
Value::Array(items) => {
for item in items {
collect_model_ids(item, out);
}
}
_ => {}
}
}
#[derive(Default)]
struct ParsedCliAgentEvent {
events: Vec<AgentEvent>,
final_text: Option<String>,
error: Option<String>,
}
pub fn parse_cli_jsonl_event(line: &str, dialect: CliAgentJsonlDialect) -> Option<Vec<AgentEvent>> {
let parsed = parse_cli_jsonl_line(line, dialect);
if parsed.events.is_empty() {
None
} else {
Some(parsed.events)
}
}
fn parse_cli_jsonl_line(line: &str, dialect: CliAgentJsonlDialect) -> ParsedCliAgentEvent {
match dialect {
CliAgentJsonlDialect::CodexExec => parse_codex_jsonl_line(line),
}
}
fn parse_codex_jsonl_line(line: &str) -> ParsedCliAgentEvent {
let Ok(value) = serde_json::from_str::<Value>(line) else {
return ParsedCliAgentEvent::default();
};
let event_type = value.get("type").and_then(Value::as_str).unwrap_or_default();
match event_type {
"item.started" => parse_codex_item_started(&value),
"item.completed" => parse_codex_item_completed(&value),
"turn.completed" => parse_codex_turn_completed(&value),
"turn.failed" | "error" => {
let message = codex_error_message(&value);
ParsedCliAgentEvent {
error: Some(message.clone()),
events: vec![AgentEvent::Error { message }],
..Default::default()
}
}
_ => ParsedCliAgentEvent::default(),
}
}
fn parse_codex_item_started(value: &Value) -> ParsedCliAgentEvent {
let item = &value["item"];
let item_type = item.get("type").and_then(Value::as_str).unwrap_or_default();
if is_mcp_tool_item(item_type) {
ParsedCliAgentEvent {
events: vec![AgentEvent::ToolCallStart {
tool_call_id: cli_item_id(item),
tool_name: cli_tool_name(item),
args: cli_tool_args(item),
}],
..Default::default()
}
} else {
ParsedCliAgentEvent::default()
}
}
fn parse_codex_item_completed(value: &Value) -> ParsedCliAgentEvent {
let item = &value["item"];
let item_type = item.get("type").and_then(Value::as_str).unwrap_or_default();
if item_type == "agent_message" {
if let Some(text) = cli_text(item) {
return ParsedCliAgentEvent {
final_text: Some(text.clone()),
events: vec![AgentEvent::TextDelta { delta: text }],
..Default::default()
};
}
}
if item_type == "reasoning" {
if let Some(text) = cli_text(item) {
return ParsedCliAgentEvent {
events: vec![AgentEvent::ReasoningDelta { delta: text }],
..Default::default()
};
}
}
if is_mcp_tool_item(item_type) {
return ParsedCliAgentEvent {
events: vec![AgentEvent::ToolCallEnd {
tool_call_id: cli_item_id(item),
tool_name: cli_tool_name(item),
result: cli_tool_result(item),
is_error: item.get("status").and_then(Value::as_str).map(|status| status == "failed").unwrap_or(false),
}],
..Default::default()
};
}
ParsedCliAgentEvent::default()
}
fn parse_codex_turn_completed(value: &Value) -> ParsedCliAgentEvent {
let usage = value.get("usage").and_then(|usage| {
let input =
usage.get("input_tokens").or_else(|| usage.get("prompt_tokens")).and_then(Value::as_u64).unwrap_or(0)
as u32;
let output =
usage.get("output_tokens").or_else(|| usage.get("completion_tokens")).and_then(Value::as_u64).unwrap_or(0)
as u32;
(input > 0 || output > 0).then_some(TokenUsage { input_tokens: input, output_tokens: output })
});
ParsedCliAgentEvent {
events: vec![AgentEvent::AgentEnd {
input_tokens: usage.as_ref().and_then(|u| (u.input_tokens > 0).then_some(u.input_tokens)),
output_tokens: usage.as_ref().and_then(|u| (u.output_tokens > 0).then_some(u.output_tokens)),
}],
..Default::default()
}
}
fn is_mcp_tool_item(item_type: &str) -> bool {
item_type == "mcp_tool_call" || item_type == "mcp_tool" || item_type == "tool_call"
}
fn cli_item_id(item: &Value) -> String {
item.get("id")
.and_then(Value::as_str)
.or_else(|| item.get("call_id").and_then(Value::as_str))
.unwrap_or("cli-tool-call")
.to_string()
}
fn cli_tool_name(item: &Value) -> String {
item.get("tool_name")
.and_then(Value::as_str)
.or_else(|| item.get("name").and_then(Value::as_str))
.or_else(|| item.get("server_tool_name").and_then(Value::as_str))
.unwrap_or("cli_tool")
.to_string()
}
fn cli_tool_args(item: &Value) -> Value {
item.get("arguments")
.or_else(|| item.get("args"))
.or_else(|| item.get("input"))
.cloned()
.unwrap_or(Value::Object(Default::default()))
}
fn cli_tool_result(item: &Value) -> Value {
item.get("result").or_else(|| item.get("output")).or_else(|| item.get("content")).cloned().unwrap_or(Value::Null)
}
fn cli_text(item: &Value) -> Option<String> {
item.get("text")
.and_then(Value::as_str)
.or_else(|| item.get("message").and_then(Value::as_str))
.or_else(|| item.get("content").and_then(Value::as_str))
.map(ToString::to_string)
}
fn codex_error_message(value: &Value) -> String {
value
.get("message")
.and_then(Value::as_str)
.or_else(|| value.get("error").and_then(Value::as_str))
.or_else(|| value.get("error").and_then(|e| e.get("message")).and_then(Value::as_str))
.unwrap_or("CLI agent failed")
.to_string()
}
pub async fn run_cli_jsonl_agent(
spec: CliAgentProcessSpec,
cancelled: &Notify,
on_event: impl Fn(AgentEvent) + Send + Sync + 'static,
) -> Result<String, String> {
let mut child = Command::new(&spec.command.program)
.args(&spec.command.args)
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.map_err(|e| (spec.classify_spawn_error)(&e.to_string()))?;
let stdout = child.stdout.take().ok_or_else(|| "Failed to capture CLI agent stdout".to_string())?;
let stderr = child.stderr.take().ok_or_else(|| "Failed to capture CLI agent stderr".to_string())?;
let mut lines = BufReader::new(stdout).lines();
let stderr_task = tokio::spawn(async move {
let mut reader = BufReader::new(stderr);
let mut buf = String::new();
let _ = reader.read_to_string(&mut buf).await;
buf
});
let mut final_text = String::new();
let mut saw_agent_end = false;
let mut terminal_error: Option<String> = None;
loop {
tokio::select! {
line = lines.next_line() => {
let line = match line {
Ok(Some(line)) => line,
Ok(None) => break,
Err(e) => {
terminal_error = Some(format!("CLI agent stream read failed: {e}"));
let _ = child.kill().await;
break;
}
};
let parsed = parse_cli_jsonl_line(&line, spec.dialect);
if let Some(text) = parsed.final_text {
final_text.push_str(&text);
}
for event in parsed.events {
if matches!(event, AgentEvent::AgentEnd { .. }) {
saw_agent_end = true;
}
on_event(event);
}
if let Some(error) = parsed.error {
terminal_error = Some(error);
let _ = child.kill().await;
break;
}
}
_ = cancelled.notified() => {
terminal_error = Some("Agent loop cancelled".to_string());
let _ = child.kill().await;
break;
}
}
}
let status = child.wait().await.map_err(|e| format!("CLI agent wait failed: {e}"))?;
let stderr = stderr_task.await.unwrap_or_default();
if let Some(error) = terminal_error {
return Err(error);
}
if !status.success() {
return Err((spec.classify_run_error)(&stderr));
}
if !saw_agent_end {
on_event(AgentEvent::AgentEnd { input_tokens: None, output_tokens: None });
}
Ok(final_text)
}
#[cfg(all(test, unix))]
mod tests {
use super::*;
use std::process::Command as StdCommand;
use std::time::{SystemTime, UNIX_EPOCH};
use tokio::time::{sleep, timeout, Duration};
fn classify_spawn_error(message: &str) -> String {
message.to_string()
}
fn classify_run_error(message: &str) -> String {
message.to_string()
}
fn process_is_alive(pid: &str) -> bool {
StdCommand::new("kill")
.args(["-0", pid])
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status()
.map(|status| status.success())
.unwrap_or(false)
}
#[tokio::test]
async fn jsonl_error_kills_and_waits_for_child() {
let pid_file = std::env::temp_dir().join(format!(
"dbx-cli-agent-error-{}-{}",
std::process::id(),
SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos()
));
let script = format!(
"echo $$ > {}; printf '%s\\n' '{{\"type\":\"turn.failed\",\"message\":\"boom\"}}'; exec sleep 30",
pid_file.display()
);
let spec = CliAgentProcessSpec {
command: CliAgentCommandSpec { program: "sh".to_string(), args: vec!["-c".to_string(), script] },
dialect: CliAgentJsonlDialect::CodexExec,
classify_spawn_error,
classify_run_error,
};
let result = timeout(Duration::from_secs(3), run_cli_jsonl_agent(spec, &Notify::new(), |_| {}))
.await
.expect("runner should return after JSONL error");
assert_eq!(result.unwrap_err(), "boom");
sleep(Duration::from_millis(100)).await;
let pid = std::fs::read_to_string(&pid_file).expect("child pid should be captured");
assert!(!process_is_alive(pid.trim()));
let _ = std::fs::remove_file(pid_file);
}
}
+346
View File
@@ -0,0 +1,346 @@
use crate::agent_events::AgentEvent;
use crate::ai::{AiConfig, AiModelInfo, AiTestConnectionResult};
use crate::ai_cli_agent::{
append_config_overrides, build_cli_agent_prompt, dbx_mcp_enabled_tools, dbx_mcp_scope_env, model_infos,
parse_cli_jsonl_event, run_cli_jsonl_agent, toml_string, toml_string_array, CliAgentCommandSpec,
CliAgentJsonlDialect, CliAgentProcessSpec, CliAgentRunOptions,
};
use serde_json::Value;
use std::time::Instant;
use tokio::process::Command;
use tokio::sync::Notify;
const DEFAULT_CODEX_MODELS: &[&str] = &["default", "gpt-5.5", "gpt-5.4-mini"];
pub type CodexRunOptions = CliAgentRunOptions;
pub type CodexCommandSpec = CliAgentCommandSpec;
fn codex_program(config: &AiConfig) -> String {
config.codex_cli_path.as_deref().map(str::trim).filter(|path| !path.is_empty()).unwrap_or("codex").to_string()
}
pub fn codex_enabled_tools(agent_mode: bool) -> Vec<&'static str> {
dbx_mcp_enabled_tools(agent_mode)
}
fn codex_mcp_config_overrides(options: &CodexRunOptions) -> Vec<String> {
let mcp_command =
options.mcp_server_command.as_ref().map(|command| command.program.as_str()).unwrap_or("dbx-mcp-server");
let mut overrides = vec![
format!("mcp_servers.dbx.command={}", toml_string(mcp_command)),
"mcp_servers.dbx.required=true".to_string(),
"mcp_servers.dbx.startup_timeout_sec=20".to_string(),
"mcp_servers.dbx.tool_timeout_sec=120".to_string(),
"mcp_servers.dbx.default_tools_approval_mode=\"auto\"".to_string(),
format!("mcp_servers.dbx.enabled_tools={}", toml_string_array(&dbx_mcp_enabled_tools(options.agent_mode))),
];
if let Some(command) = options.mcp_server_command.as_ref().filter(|command| !command.args.is_empty()) {
let args = command.args.iter().map(String::as_str).collect::<Vec<_>>();
overrides.push(format!("mcp_servers.dbx.args={}", toml_string_array(&args)));
}
overrides.extend(
dbx_mcp_scope_env(options)
.into_iter()
.map(|(name, value)| format!("mcp_servers.dbx.env.{name}={}", toml_string(&value))),
);
overrides
}
pub fn build_codex_exec_command(config: &AiConfig, prompt: &str, options: &CodexRunOptions) -> CodexCommandSpec {
let mut args = vec![
"exec".to_string(),
"--json".to_string(),
"--skip-git-repo-check".to_string(),
"--sandbox".to_string(),
"read-only".to_string(),
];
let mut config_overrides = vec!["features.shell_tool=false".to_string(), "web_search=\"disabled\"".to_string()];
if let Some(reasoning_effort) = config.reasoning_level.as_codex_effort() {
config_overrides.push(format!("model_reasoning_effort={}", toml_string(reasoning_effort)));
}
append_config_overrides(&mut args, config_overrides.into_iter().chain(codex_mcp_config_overrides(options)));
let model = config.model.trim();
if !model.is_empty() && !model.eq_ignore_ascii_case("default") {
args.push("--model".to_string());
args.push(model.to_string());
}
args.push(prompt.to_string());
CodexCommandSpec { program: codex_program(config), args }
}
pub fn build_codex_prompt(system_prompt: &str, messages: &[crate::ai::AiMessage]) -> String {
build_cli_agent_prompt("Codex", system_prompt, messages)
}
pub async fn list_codex_models(config: &AiConfig) -> Result<Vec<AiModelInfo>, String> {
let output = Command::new(codex_program(config)).args(["debug", "models"]).output().await;
let Ok(output) = output else {
return Ok(model_infos(DEFAULT_CODEX_MODELS));
};
if !output.status.success() {
return Ok(model_infos(DEFAULT_CODEX_MODELS));
}
Ok(parse_codex_models(&String::from_utf8_lossy(&output.stdout))
.unwrap_or_else(|| model_infos(DEFAULT_CODEX_MODELS)))
}
fn parse_codex_models(stdout: &str) -> Option<Vec<AiModelInfo>> {
let json_start = stdout.find('{')?;
let data = serde_json::from_str::<Value>(&stdout[json_start..]).ok()?;
let models = data.get("models").and_then(Value::as_array)?;
let mut result = vec![AiModelInfo { id: "default".to_string(), display_name: Some("Default".to_string()) }];
for model in models {
let Some(id) = model
.get("slug")
.and_then(Value::as_str)
.or_else(|| model.get("id").and_then(Value::as_str))
.map(str::trim)
.filter(|id| !id.is_empty())
else {
continue;
};
if result.iter().any(|existing| existing.id == id) {
continue;
}
let display_name = model
.get("display_name")
.and_then(Value::as_str)
.map(str::trim)
.filter(|name| !name.is_empty())
.map(ToString::to_string);
result.push(AiModelInfo { id: id.to_string(), display_name });
}
(result.len() > 1).then_some(result)
}
pub async fn test_codex_connection(config: &AiConfig) -> Result<AiTestConnectionResult, String> {
let start = Instant::now();
let mut command = Command::new(codex_program(config));
command.args(["exec", "--json", "--skip-git-repo-check", "--sandbox", "read-only"]);
let model = config.model.trim();
if !model.is_empty() && !model.eq_ignore_ascii_case("default") {
command.args(["--model", model]);
}
let output = command
.arg("Reply with exactly: DBX Codex OK")
.output()
.await
.map_err(|e| classify_codex_spawn_error(&e.to_string()))?;
if output.status.success() {
let stdout = String::from_utf8_lossy(&output.stdout);
if !stdout.contains("DBX Codex OK") {
let stderr = String::from_utf8_lossy(&output.stderr);
return Err(format!(
"[codexRunFailed] Codex CLI smoke test returned unexpected output. stdout: {stdout} stderr: {stderr}"
));
}
Ok(AiTestConnectionResult {
success: true,
message: format!("OK - {}ms", start.elapsed().as_millis()),
latency_ms: Some(start.elapsed().as_millis() as u64),
model_used: config.model.trim().to_string(),
error_category: None,
})
} else {
let stderr = String::from_utf8_lossy(&output.stderr);
Err(classify_codex_run_error(&stderr))
}
}
fn classify_codex_spawn_error(message: &str) -> String {
if message.contains("No such file") || message.contains("not found") {
"[codexNotInstalled] Codex CLI was not found. Install Codex CLI or set the Codex CLI path in DBX AI settings."
.to_string()
} else {
format!("[codexRunFailed] Failed to start Codex CLI: {message}")
}
}
fn classify_codex_run_error(stderr: &str) -> String {
let lower = stderr.to_ascii_lowercase();
if lower.contains("not authenticated") || lower.contains("login") || lower.contains("auth") {
format!("[codexNotAuthenticated] Codex CLI is not authenticated. Run `codex login` and try again. {stderr}")
} else if lower.contains("dbx-mcp-server") || lower.contains("enoent") {
format!("[dbxMcpMissing] DBX MCP server was not found. Install @dbx-app/mcp-server and try again. {stderr}")
} else if lower.contains("mcp") && (lower.contains("dbx") || lower.contains("server")) {
format!("[codexMcpStartupFailed] Codex could not start the DBX MCP server. {stderr}")
} else {
format!("[codexRunFailed] Codex CLI failed. {stderr}")
}
}
pub fn parse_codex_jsonl_event(line: &str) -> Option<Vec<AgentEvent>> {
parse_cli_jsonl_event(line, CliAgentJsonlDialect::CodexExec)
}
pub async fn run_codex_agent(
config: &AiConfig,
prompt: &str,
options: CodexRunOptions,
cancelled: &Notify,
on_event: impl Fn(AgentEvent) + Send + Sync + 'static,
) -> Result<String, String> {
let command = build_codex_exec_command(config, prompt, &options);
run_cli_jsonl_agent(
CliAgentProcessSpec {
command,
dialect: CliAgentJsonlDialect::CodexExec,
classify_spawn_error: classify_codex_spawn_error,
classify_run_error: classify_codex_run_error,
},
cancelled,
on_event,
)
.await
}
#[cfg(test)]
mod tests {
use super::{
build_codex_exec_command, codex_enabled_tools, parse_codex_jsonl_event, parse_codex_models, CodexRunOptions,
DEFAULT_CODEX_MODELS,
};
use crate::agent_events::AgentEvent;
use crate::ai::{AiApiStyle, AiAuthMethod, AiConfig, AiProvider, AiReasoningLevel};
use crate::ai_cli_agent::{model_infos, CliAgentCommandSpec};
fn codex_config(model: &str) -> AiConfig {
AiConfig {
provider: AiProvider::CodexCli,
api_key: String::new(),
auth_method: AiAuthMethod::Bearer,
endpoint: String::new(),
model: model.to_string(),
api_style: AiApiStyle::Completions,
proxy_enabled: false,
proxy_url: String::new(),
enable_thinking: true,
reasoning_level: AiReasoningLevel::Default,
context_window: None,
codex_cli_path: None,
}
}
fn run_options() -> CodexRunOptions {
CodexRunOptions {
connection_id: "conn-1".to_string(),
connection_name: "local".to_string(),
database: "demo".to_string(),
agent_mode: true,
mcp_server_command: None,
}
}
#[test]
fn builds_codex_command_with_scoped_mcp_and_omits_default_model() {
let spec = build_codex_exec_command(&codex_config("default"), "hello", &run_options());
assert_eq!(spec.program, "codex");
assert!(spec.args.contains(&"--json".to_string()));
assert!(!spec.args.contains(&"--model".to_string()));
assert!(!spec.args.contains(&"--ask-for-approval".to_string()));
assert!(spec.args.contains(&"mcp_servers.dbx.command=\"dbx-mcp-server\"".to_string()));
assert!(spec.args.contains(&"mcp_servers.dbx.env.DBX_MCP_ALLOW_WRITES=\"0\"".to_string()));
assert!(spec.args.contains(&"mcp_servers.dbx.env.DBX_MCP_SCOPE_CONNECTION_ID=\"conn-1\"".to_string()));
assert!(spec.args.iter().any(|arg| arg.contains("dbx_execute_query")));
}
#[test]
fn builds_codex_command_with_non_default_model_and_ask_tools() {
let mut options = run_options();
options.agent_mode = false;
let spec = build_codex_exec_command(&codex_config("gpt-5.5"), "hello", &options);
let model_pos = spec.args.iter().position(|arg| arg == "--model").unwrap();
assert_eq!(spec.args[model_pos + 1], "gpt-5.5");
assert!(!codex_enabled_tools(false).contains(&"dbx_execute_query"));
assert!(spec.args.iter().any(|arg| arg.contains("dbx_get_schema_context")));
assert!(!spec.args.iter().any(|arg| arg.contains("dbx_execute_query")));
}
#[test]
fn builds_codex_command_with_resolved_mcp_server_path() {
let mut options = run_options();
options.mcp_server_command = Some(CliAgentCommandSpec {
program: "/opt/dbx/bin/dbx-mcp-server".to_string(),
args: vec!["--stdio".to_string()],
});
let spec = build_codex_exec_command(&codex_config("default"), "hello", &options);
assert!(spec.args.contains(&"mcp_servers.dbx.command=\"/opt/dbx/bin/dbx-mcp-server\"".to_string()));
assert!(spec.args.contains(&"mcp_servers.dbx.args=[\"--stdio\"]".to_string()));
}
#[test]
fn builds_codex_command_with_reasoning_effort_override() {
let mut config = codex_config("default");
config.reasoning_level = AiReasoningLevel::High;
let spec = build_codex_exec_command(&config, "hello", &run_options());
assert!(!spec.args.contains(&"--reasoning-effort".to_string()));
assert!(spec.args.contains(&"model_reasoning_effort=\"high\"".to_string()));
}
#[test]
fn default_model_list_matches_plan() {
assert_eq!(model_infos(DEFAULT_CODEX_MODELS), model_infos(&["default", "gpt-5.5", "gpt-5.4-mini"]));
}
#[test]
fn parses_codex_model_catalog_without_service_tiers() {
let models = parse_codex_models(
r#"{"models":[{"slug":"gpt-5.5","display_name":"GPT-5.5","service_tiers":[{"id":"priority","name":"Priority"}]},{"slug":"gpt-5.4-mini","display_name":"GPT-5.4 mini"}]}"#,
)
.unwrap();
assert_eq!(
models.iter().map(|model| model.id.as_str()).collect::<Vec<_>>(),
vec!["default", "gpt-5.5", "gpt-5.4-mini"]
);
assert_eq!(models[1].display_name.as_deref(), Some("GPT-5.5"));
assert!(!models.iter().any(|model| model.id == "priority" || model.id == "Priority"));
}
#[test]
fn parses_codex_jsonl_events() {
assert!(parse_codex_jsonl_event(r#"{"type":"thread.started","thread_id":"t"}"#).is_none());
let started = parse_codex_jsonl_event(
r#"{"type":"item.started","item":{"id":"tool-1","type":"mcp_tool_call","tool_name":"dbx_list_tables","arguments":{"schema":"public"}}}"#,
)
.unwrap();
assert!(matches!(&started[0], AgentEvent::ToolCallStart { tool_name, .. } if tool_name == "dbx_list_tables"));
let completed = parse_codex_jsonl_event(
r#"{"type":"item.completed","item":{"id":"msg-1","type":"agent_message","text":"Done"}}"#,
)
.unwrap();
assert!(matches!(&completed[0], AgentEvent::TextDelta { delta } if delta == "Done"));
let tool_done = parse_codex_jsonl_event(
r#"{"type":"item.completed","item":{"id":"tool-1","type":"mcp_tool_call","tool_name":"dbx_list_tables","result":{"content":"users"}}}"#,
)
.unwrap();
assert!(
matches!(&tool_done[0], AgentEvent::ToolCallEnd { tool_name, is_error, .. } if tool_name == "dbx_list_tables" && !is_error)
);
let turn_done =
parse_codex_jsonl_event(r#"{"type":"turn.completed","usage":{"input_tokens":12,"output_tokens":3}}"#)
.unwrap();
assert!(matches!(&turn_done[0], AgentEvent::AgentEnd { input_tokens: Some(12), output_tokens: Some(3) }));
let failed = parse_codex_jsonl_event(r#"{"type":"turn.failed","message":"boom"}"#).unwrap();
assert!(matches!(&failed[0], AgentEvent::Error { message } if message == "boom"));
}
}
+2
View File
@@ -8,6 +8,8 @@ pub mod agent_runtime;
pub mod agent_service;
pub mod agent_tools;
pub mod ai;
pub mod ai_cli_agent;
pub mod ai_codex_cli;
pub mod cloud_sync;
pub mod connection;
pub mod connection_secrets;