openheim 0.1.0

A fast, multi-provider LLM agent runtime written in Rust
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

use clap::{Parser, Subcommand};
use tracing_subscriber::{EnvFilter, fmt};

use openheim::{
    config::init_config,
    transport::{run, stdio, ws},
    tui,
};

#[derive(Parser, Debug)]
#[command(name = "openheim", about = "AI agent")]
struct Cli {
    #[command(subcommand)]
    command: Option<Command>,
    /// Comma-separated skills to activate for this session (e.g. --skills rust,nodejs)
    #[arg(
        long = "skills",
        value_name = "NAMES",
        value_delimiter = ',',
        global = false
    )]
    skills: Vec<String>,
}

#[derive(Subcommand, Debug)]
enum Command {
    /// Serve as an ACP agent over stdio (for Zed, Claude Code, etc.)
    Acp,
    /// Run a single prompt headlessly and stream output to stdout
    Run {
        /// Prompt to send to the agent
        prompt: String,
        /// Model name override (must be configured in a provider)
        #[arg(long)]
        model: Option<String>,
    },
    /// Start WebSocket/ACP server
    Serve {
        #[arg(long, default_value = "0.0.0.0")]
        host: String,
        #[arg(long, default_value = "1217")]
        port: u16,
    },
    /// Initialize config file at ~/.openheim/config.toml
    Init,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let env_filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("warn"));
    fmt::Subscriber::builder()
        .with_env_filter(env_filter)
        .init();

    let cli = Cli::parse();

    match cli.command {
        None => {
            if let Err(e) = tui::run(cli.skills).await {
                eprintln!("Error: {e}");
                std::process::exit(1);
            }
        }
        Some(Command::Acp) => {
            if let Err(e) = stdio::run().await {
                eprintln!("Error: {e}");
                std::process::exit(1);
            }
        }
        Some(Command::Run { prompt, model }) => {
            if let Err(e) = run::run_headless(prompt, model).await {
                eprintln!("Error: {e}");
                std::process::exit(1);
            }
        }
        Some(Command::Serve { host, port }) => {
            if let Err(e) = ws::serve(host, port).await {
                eprintln!("Error: {e}");
                std::process::exit(1);
            }
        }
        Some(Command::Init) => match init_config() {
            Ok(path) => {
                println!("Config file created at {}", path.display());
                println!("Edit it to configure your LLM providers.");
            }
            Err(e) => {
                eprintln!("Error: {e}");
                std::process::exit(1);
            }
        },
    }

    Ok(())
}