cc-agent-ipc

┌─────────────────────────────────────────────────────────────────────┐
│                     Your Rust Application                           │
│  (Tauri, CLI tool, backend service, etc.)                           │
└──────────────────────────────┬──────────────────────────────────────┘
                               │
                               ↓
┌─────────────────────────────────────────────────────────────────────┐
│                   cc-agent-ipc (this crate)                         │
│  • Async IPC client                                                 │
│  • Streaming interface                                              │
│  • Type-safe protocol                                               │
│  • Multi-provider support                                           │
└──────────────────────────────┬──────────────────────────────────────┘
                               │ Unix Socket IPC (JSON-RPC)
                               ↓
┌─────────────────────────────────────────────────────────────────────┐
│                   cc-agent-service (Python daemon)                  │
│  • Claude (claude-agent-sdk)                                        │
│  • OpenAI (openai-agents)                                           │
│  • Multi-provider routing                                           │
│  • Tool execution & hooks                                           │
└──────────────────────────────┬──────────────────────────────────────┘
                               │
                   ┌───────────┴───────────┐
                   ↓                       ↓
┌─────────────────────────┐   ┌─────────────────────────┐
│    Anthropic API        │   │      OpenAI API         │
└─────────────────────────┘   └─────────────────────────┘

use cc_agent_ipc::{AgentClient, CreateSessionParams, Provider, MessageStream, StreamEvent};

#[tokio::main]
async fn main() -> cc_agent_ipc::Result<()> {
    let client = AgentClient::new();

    // Verify service is running
    if !client.is_available().await {
        eprintln!("cc-agent-service is not running");
        return Ok(());
    }

    // Create a Claude session (default)
    let session = client.create_session(CreateSessionParams {
        working_directory: "/path/to/project".into(),
        provider: Provider::Claude,
        ..Default::default()
    }).await?;

    // Stream responses
    let stream = client.send_prompt(&session.session_id, "List files").await?;
    let mut msg_stream = MessageStream::new(stream);

    while let Some(event) = msg_stream.next().await {
        match event? {
            StreamEvent::Text(text) => print!("{}", text),
            StreamEvent::ToolUse { name, .. } => println!("\n[Tool: {}]", name),
            StreamEvent::Done { metrics, .. } => {
                println!("\n[Tokens: {} in, {} out]",
                    metrics.input_tokens, metrics.output_tokens);
                break;
            }
            _ => {}
        }
    }

    client.close_session(&session.session_id).await?;
    Ok(())
}

let session = client.create_session(CreateSessionParams {
    working_directory: "/project".into(),
    provider: Provider::Claude,
    enable_thinking: Some(true),
    model: Some("claude-sonnet-4-20250514".into()),
    ..Default::default()
}).await?;

let session = client.create_session(CreateSessionParams {
    working_directory: "/project".into(),
    provider: Provider::OpenAI,
    model: Some("gpt-4o".into()),
    handoffs: Some(vec![
        HandoffTarget {
            name: "researcher".into(),
            description: "Hands off to research agent for deep analysis".into(),
        }
    ]),
    ..Default::default()
}).await?;

// Automatically selects best available provider
let session = client.create_session(CreateSessionParams {
    working_directory: "/project".into(),
    provider: Provider::Auto,
    routing_strategy: Some(RoutingStrategy::Capability),
    ..Default::default()
}).await?;

use cc_agent_ipc::quick_dispatch;

let response = quick_dispatch("/project", "Explain main.rs").await?;
println!("{}", response);

// Create session with options
let session = client.create_session(CreateSessionParams {
    working_directory: "/project".into(),
    provider: Provider::Claude,
    model: Some("claude-sonnet-4-20250514".into()),
    max_turns: Some(50),
    allowed_tools: Some(vec!["Read".into(), "Glob".into()]),
    project_id: Some("my-project".into()),
    ..Default::default()
}).await?;

// Resume existing session
let session = client.create_session(CreateSessionParams {
    working_directory: "/project".into(),
    resume: Some("sdk-session-id".into()),
    ..Default::default()
}).await?;

// List sessions
let sessions = client.list_sessions().await?;
for s in sessions.sessions {
    println!("{}: {} ({}) - {}", s.session_id, s.state, s.working_directory, s.provider);
}

use std::collections::HashMap;
use cc_agent_ipc::{CreateSessionParams, SubagentConfig, Provider};

let mut agents = HashMap::new();
agents.insert("explorer".into(), SubagentConfig {
    description: "Code exploration agent".into(),
    prompt: "Find and analyze code patterns".into(),
    tools: vec!["Read".into(), "Glob".into(), "Grep".into()],
});

let session = client.create_session(CreateSessionParams {
    working_directory: "/project".into(),
    provider: Provider::Claude,
    agents: Some(agents),
    ..Default::default()
}).await?;

let session = client.create_session(CreateSessionParams {
    provider: Provider::Auto,
    routing_strategy: Some(RoutingStrategy::Capability),  // Route by task type
    fallback_provider: Some(Provider::Claude),            // Fallback if primary fails
    ..Default::default()
}).await?;

use cc_agent_ipc::AgentError;

match client.ping().await {
    Ok(response) => println!("Active sessions: {}", response.active_sessions),
    Err(AgentError::ServiceUnavailable(path)) => {
        eprintln!("Service not running at {}", path);
    }
    Err(e) if e.is_retryable() => {
        // Retry logic
    }
    Err(e) => return Err(e.into()),
}