aix-rs 1.0.0

Manage AI gateway profiles and launch AI coding tools with the right credentials
use crate::commands::env::resolve_profile;
use crate::commands::GatewayRequestOptions;
use crate::config;
use crate::error::AixError;
use crate::gateway::openai::OpenAiClient;
use crate::output;
use color_eyre::Result;
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use std::io::{IsTerminal, Read, Write};
use std::path::{Path, PathBuf};

#[derive(Serialize)]
pub(crate) struct InferenceOutput {
    model: String,
    content: String,
    usage: Usage,
}

#[derive(Default, Deserialize, Serialize)]
struct Usage {
    prompt_tokens: Option<u64>,
    completion_tokens: Option<u64>,
    total_tokens: Option<u64>,
}

impl Usage {
    fn from_response(response: &Value) -> Self {
        response
            .get("usage")
            .cloned()
            .and_then(|usage| serde_json::from_value(usage).ok())
            .unwrap_or_default()
    }
}

pub(crate) fn load_config(config_path: Option<&Path>) -> Result<config::Config> {
    let path = config::find_config_path(config_path)?.ok_or(AixError::NoConfigFile)?;
    let cfg = config::load(&path)?;
    config::validate(&cfg)?;
    Ok(cfg)
}

pub(crate) fn prepare_request_options(
    cfg: &config::Config,
    mut options: GatewayRequestOptions,
) -> Result<GatewayRequestOptions> {
    let profile_name = resolve_profile(options.selection.clone(), cfg)?;
    if !cfg.profiles.contains_key(&profile_name) {
        return Err(AixError::ProfileNotFound {
            name: profile_name.clone(),
            available_hint: config::format_available_profiles(cfg),
        }
        .into());
    }
    options.selection.profile = Some(profile_name);
    Ok(options)
}

pub(crate) async fn execute(
    cfg: &config::Config,
    options: GatewayRequestOptions,
    requested_model: Option<&str>,
    messages: Vec<Value>,
) -> Result<InferenceOutput> {
    config::load_env_files(cfg)?;
    let GatewayRequestOptions { selection, timeout } = options;
    let profile_name = resolve_profile(selection, cfg)?;
    let profile = cfg
        .profiles
        .get(&profile_name)
        .ok_or_else(|| AixError::ProfileNotFound {
            name: profile_name.clone(),
            available_hint: config::format_available_profiles(cfg),
        })?;
    let resolved_model = config::resolve_model(requested_model, cfg, profile)?;
    let base_url = config::resolve_base_url(profile, &cfg.endpoint)?;
    let api_key = profile.resolve_api_key()?;

    let request = json!({ "model": resolved_model.clone(), "messages": messages });
    let client =
        OpenAiClient::with_timeout(base_url.expose_secret(), api_key.expose_secret(), timeout);
    let response = client
        .chat_completions(&request)
        .await
        .map_err(|error| match error {
            AixError::GatewayError { status, .. } => AixError::GatewayRequestFailed { status },
            error => error,
        })?;

    Ok(InferenceOutput {
        model: resolved_model,
        content: assistant_content(&response)?,
        usage: Usage::from_response(&response),
    })
}

pub(crate) fn print_result(
    command: &str,
    json_output: bool,
    result: InferenceOutput,
) -> Result<()> {
    if json_output {
        output::print_json(command, result)?;
    } else {
        let mut stdout = std::io::stdout().lock();
        stdout.write_all(result.content.as_bytes())?;
        if !result.content.ends_with('\n') {
            stdout.write_all(b"\n")?;
        }
    }
    Ok(())
}

pub(crate) fn collect_messages(
    system: Option<String>,
    prompt: Option<String>,
    files: &[PathBuf],
) -> Result<Vec<Value>, AixError> {
    let stdin = std::io::stdin();
    let stdin_is_terminal = stdin.is_terminal();
    validate_input_shape(prompt.is_some(), !files.is_empty(), stdin_is_terminal)?;

    let stdin_context = if stdin_is_terminal {
        None
    } else {
        let mut contents = String::new();
        stdin
            .lock()
            .read_to_string(&mut contents)
            .map_err(|source| AixError::AskStdinRead { source })?;
        (!contents.is_empty()).then_some(contents)
    };

    if prompt.is_none() && stdin_context.is_none() {
        return Err(AixError::AskInputRequired);
    }

    let mut messages = Vec::new();
    if let Some(system) = system {
        messages.push(json!({ "role": "system", "content": system }));
    }
    if let Some(prompt) = prompt {
        messages.push(json!({ "role": "user", "content": prompt }));
        if let Some(context) = stdin_context {
            messages.push(json!({
                "role": "user",
                "content": format!("Context from stdin:\n{context}")
            }));
        }
    } else if let Some(context) = stdin_context {
        messages.push(json!({ "role": "user", "content": context }));
    }
    for path in files {
        let contents = std::fs::read_to_string(path).map_err(|source| AixError::AskFileRead {
            path: path.clone(),
            source,
        })?;
        let name = path.display();
        messages.push(json!({
            "role": "user",
            "content": format!("--- Begin file: {name} ---\n{contents}\n--- End file: {name} ---")
        }));
    }

    Ok(messages)
}

pub(crate) fn validate_input_shape(
    has_prompt: bool,
    has_files: bool,
    stdin_is_terminal: bool,
) -> Result<(), AixError> {
    if !has_prompt && has_files {
        return Err(AixError::AskInstructionRequired);
    }
    if !has_prompt && stdin_is_terminal {
        return Err(AixError::AskInputRequired);
    }
    Ok(())
}

fn assistant_content(response: &Value) -> Result<String> {
    response
        .get("choices")
        .and_then(Value::as_array)
        .and_then(|choices| choices.first())
        .and_then(|choice| choice.get("message"))
        .and_then(|message| {
            message
                .get("content")
                .and_then(Value::as_str)
                .filter(|content| !content.trim().is_empty())
                .or_else(|| {
                    message
                        .get("refusal")
                        .and_then(Value::as_str)
                        .filter(|refusal| !refusal.trim().is_empty())
                })
                .map(str::to_string)
        })
        .ok_or_else(|| {
            AixError::GatewayProtocolError("response contained no assistant text").into()
        })
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn missing_instruction_on_terminal_fails_with_usage_guidance() {
        assert!(matches!(
            validate_input_shape(false, false, true),
            Err(AixError::AskInputRequired)
        ));
    }

    #[test]
    fn files_without_instruction_require_one_even_if_stdin_is_piped() {
        assert!(matches!(
            validate_input_shape(false, true, false),
            Err(AixError::AskInstructionRequired)
        ));
    }
}