Mixtape CLI

Session storage and REPL utilities for mixtape agents.

Session Persistence

Store conversations in SQLite so they survive restarts:

use mixtape_core::{Agent, ClaudeSonnet4_5};
use mixtape_cli::SqliteStore;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let store = SqliteStore::default_location()?;  // .mixtape/sessions.db

    let agent = Agent::builder()
        .bedrock(ClaudeSonnet4_5)
        .with_session_store(store)
        .build()
        .await?;

    agent.run("Remember this for later").await?;
    Ok(())
}

Sessions are scoped to the current working directory. Each directory gets its own conversation history.

Custom Location

let store = SqliteStore::new("/path/to/sessions.db")?;

Parent directories are created automatically.

Interactive REPL

Run a full-featured CLI for your agent:

use mixtape_core::{Agent, ClaudeSonnet4_5};
use mixtape_cli::run_cli;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let agent = Agent::builder()
        .bedrock(ClaudeSonnet4_5)
        .build()
        .await?;

    run_cli(agent).await?;
    Ok(())
}

The REPL provides:

• Command history with up/down arrows
• Reverse search with Ctrl+R
• Multi-line input with Ctrl+J
• Special commands (/help, /clear, !shell)
• Rich tool output formatting
• Context usage display

Tool Permissions

For agents that need user confirmation before running tools, use .interactive() with a grant store:

use mixtape_core::{Agent, ClaudeSonnet4_5, MemoryGrantStore};
use mixtape_cli::run_cli;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a grant store and pre-approve safe tools
    let store = MemoryGrantStore::new();
    store.grant_tool("read_file").await?;  // Trust entire tool

    let agent = Agent::builder()
        .bedrock(ClaudeSonnet4_5)
        .interactive()  // Enable permission prompting
        .with_grant_store(store)
        .build()
        .await?;

    run_cli(agent).await?;
    Ok(())
}

The .interactive() builder method configures the agent to emit PermissionRequired events for tools without a matching grant. The run_cli() function automatically handles these events by prompting the user for approval.

Approval Prompters

The CLI provides pluggable approval UX via the ApprovalPrompter trait:

use mixtape_cli::{prompt_for_approval, PermissionRequest};

let request = PermissionRequest {
    tool_name: "write_file".to_string(),
    tool_use_id: "toolu_123".to_string(),
    params_hash: "abc123".to_string(),
    formatted_display: None,
};

let choice = prompt_for_approval(&request);

The default prompter offers four options:

• y - approve once (don't remember)
• e - trust this exact call (session)
• t - trust entire tool (session)
• n - deny

Implement ApprovalPrompter for custom approval UX (e.g., GUI dialogs, web interfaces).

Custom Event Presentation

For building custom UIs that handle tool output and permissions, use the event queue pattern:

use mixtape_cli::{new_event_queue, EventPresenter, PresentationHook, Verbosity};
use std::sync::{Arc, Mutex};

// Create shared event queue
let event_queue = new_event_queue();

// Add presentation hook to agent
agent.add_hook(PresentationHook::new(Arc::clone(&event_queue)));

// Create presenter to render events
let verbosity = Arc::new(Mutex::new(Verbosity::Normal));
let presenter = EventPresenter::new(
    Arc::clone(&agent),
    verbosity,
    Arc::clone(&event_queue),
);

// Call presenter.flush() periodically to render queued events

See the permissions example for a complete implementation.

Exports