Rust API

# Cargo.toml
[dependencies]
alephcore = { path = "../Aleph/core" }
tokio = { version = "1", features = ["rt-multi-thread", "macros"] }

alephcore
  ├── agent_loop      # OTAF execution engine
  ├── agents          # Agent definitions, sub-agents, swarm
  ├── approval        # User approval workflows
  ├── browser         # CDP browser automation
  ├── builtin_tools   # Built-in tool implementations
  ├── capability      # Capability detection
  ├── cli             # CLI helpers (inquire prompts)
  ├── command         # Command definitions
  ├── components      # Reusable components
  ├── compressor      # Context compression
  ├── conversation    # Multi-turn conversation management
  ├── daemon          # Proactive AI daemon (worldmodel, perception)
  ├── desktop         # Desktop integration
  ├── discovery       # Service discovery
  ├── dispatcher      # Unified tool registry & dispatch
  ├── domain          # Domain modeling types
  ├── engine          # Engine coordination
  ├── event           # Event types
  ├── exec            # Command execution & security kernel
  ├── executor        # Task executors
  ├── extension       # Plugin/extension system
  ├── gateway*        # WebSocket JSON-RPC server (feature-gated)
  ├── generation      # Content generation providers
  ├── intent          # Intent routing
  ├── logging         # Structured logging with PII scrubbing
  ├── markdown        # Markdown processing
  ├── mcp             # Model Context Protocol integration
  ├── memory          # Memory storage & retrieval
  ├── metrics         # Performance telemetry
  ├── payload         # Request/response payloads
  ├── permission      # Permission management
  ├── pii             # PII detection & scrubbing
  ├── poe             # Principle-Operation-Evaluation tasks
  ├── prompt          # Prompt construction
  ├── providers       # AI provider abstraction
  ├── resilient       # Resilient task execution
  ├── routing         # Session key routing
  ├── runtimes        # Capability probe/ledger (detect & bootstrap external tools)
  ├── scheduler       # Task scheduling
  ├── search          # Search providers
  ├── secrets         # Secret management
  ├── skill           # Individual skill types
  ├── skills          # Skills registry & management
  ├── skill_evolution # Skill solidification & evolution
  ├── spec_driven     # Spec-driven development workflow
  ├── supervisor      # PTY process supervision
  ├── thinker         # LLM decision-making layer
  ├── tools           # Tool trait system
  ├── video           # Video transcript extraction
  ├── vision          # Vision/image processing
  └── wizard          # Configuration wizard flows

#[async_trait]
pub trait AlephTool: Clone + Send + Sync + 'static {
    const NAME: &'static str;
    const DESCRIPTION: &'static str;

    type Args: Serialize + DeserializeOwned + JsonSchema + Send;
    type Output: Serialize + Send;

    async fn call(&self, args: Self::Args) -> Result<Self::Output>;

    // Provided methods
    fn category(&self) -> ToolCategory { ToolCategory::Builtin }
    fn requires_confirmation(&self) -> bool { false }
    fn examples(&self) -> Option<Vec<String>> { None }
    fn definition(&self) -> ToolDefinition { /* auto-generates JSON Schema */ }
}

let tools: Vec<Box<dyn AlephToolDyn>> = vec![
    Box::new(SearchTool::new()),
    Box::new(WebFetchTool::new()),
];

pub trait AiProvider: Send + Sync {
    fn process(&self, input: &str, system_prompt: Option<&str>)
        -> Pin<Box<dyn Future<Output = Result<String>> + Send + '_>>;

    fn process_with_tools(&self, messages: Vec<Message>, tools: Vec<ToolDefinition>, ...)
        -> Pin<Box<dyn Future<Output = Result<LlmResponse>> + Send + '_>>;

    fn name(&self) -> &str;
    fn color(&self) -> &str;
    fn model_id(&self) -> &str;
}

pub trait LoopCallback: Send + Sync {
    fn on_event(&self, event: LoopEvent);
}

# Minimal library usage (no server, no channels)
alephcore = { path = "...", default-features = false }

# Gateway + Telegram only
alephcore = { path = "...", features = ["gateway", "telegram"] }

# Everything
alephcore = { path = "...", features = ["gateway", "all-channels", "cron", "plugin-all"] }

use alephcore::{
    AgentLoop, AgentLoopConfig, RequestContext,
    Thinker, ThinkerConfig, SingleProviderRegistry,
    ContextCompressor,
};
use alephcore::agent_loop::NoOpLoopCallback;
use alephcore::providers::{create_provider, ProviderConfig};
use std::sync::Arc;

#[tokio::main]
async fn main() -> alephcore::Result<()> {
    // 1. Initialize logging
    alephcore::init_logging();

    // 2. Create an AI provider
    let config = ProviderConfig::test_config("claude-sonnet-4-20250514");
    let provider = create_provider("anthropic", config)?;

    // 3. Build the Thinker (LLM layer)
    let registry = SingleProviderRegistry::new(provider);
    let thinker = Thinker::new(
        Arc::new(registry),
        ThinkerConfig::default(),
    );

    // 4. Create the Agent Loop
    let loop_config = AgentLoopConfig::default();
    let compressor = ContextCompressor;
    let agent = AgentLoop::new(thinker, compressor, loop_config);

    // 5. Run
    let result = agent.run(
        "What is the weather in Tokyo?".to_string(),
        RequestContext::empty(),
        vec![], // tools
        NoOpLoopCallback,
    ).await;

    println!("Result: {:?}", result);
    Ok(())
}

use alephcore::tools::AlephTool;
use alephcore::error::Result;
use async_trait::async_trait;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

#[derive(Clone)]
struct WeatherTool;

#[derive(Serialize, Deserialize, JsonSchema)]
struct WeatherArgs {
    /// City name to check weather for
    city: String,
    /// Temperature unit (celsius or fahrenheit)
    unit: Option<String>,
}

#[derive(Serialize)]
struct WeatherOutput {
    temperature: f64,
    condition: String,
    city: String,
}

#[async_trait]
impl AlephTool for WeatherTool {
    const NAME: &'static str = "weather";
    const DESCRIPTION: &'static str = "Get current weather for a city";

    type Args = WeatherArgs;
    type Output = WeatherOutput;

    async fn call(&self, args: Self::Args) -> Result<Self::Output> {
        // Your implementation here
        Ok(WeatherOutput {
            temperature: 22.0,
            condition: "Sunny".into(),
            city: args.city,
        })
    }

    fn examples(&self) -> Option<Vec<String>> {
        Some(vec![
            "weather(city='Tokyo')".into(),
            "weather(city='London', unit='celsius')".into(),
        ])
    }
}

match result {
    Err(AlephError::AuthenticationError { provider, message, suggestion }) => {
        eprintln!("Auth failed for {}: {}", provider, message);
        if let Some(hint) = suggestion {
            eprintln!("Hint: {}", hint);
        }
    }
    Err(AlephError::RateLimitError { .. }) => {
        tokio::time::sleep(Duration::from_secs(60)).await;
        // retry...
    }
    Err(e) => eprintln!("{}", e.user_friendly_message()),
    Ok(val) => { /* success */ }
}