Determinishtic

determinishtic

Blend deterministic Rust code with LLM-powered reasoning.

*Hat tip to [Dave Herman](https://github.com/dherman) for the name.*

Philosophy

**Do things deterministically that are deterministic.** File discovery, iteration, and I/O happen in Rust. Summarization, analysis, and judgment happen via the LLM.

use determinishtic::Determinishtic;
use agent_client_protocol_tokio::AcpAgent;

#[tokio::main]
async fn main() -> Result<(), determinishtic::Error> {
    let d = Determinishtic::new(AcpAgent::zed_claude_code()).await?;

    // Rust handles the deterministic parts
    let files = std::fs::read_dir("./docs")?
        .filter_map(|e| e.ok())
        .filter(|e| e.path().extension() == Some("md".as_ref()))
        .collect::>();

    for entry in files {
        let contents = std::fs::read_to_string(entry.path())?;

        // LLM handles the non-deterministic reasoning
        let summary: String = d.think()
            .text("Summarize in one sentence:")
            .display(&contents)
            .await?;

        println!("{}: {}", entry.path().display(), summary);
    }

    Ok(())
}

Installation

Add to your `Cargo.toml`:

[dependencies]
determinishtic = "0.1"
agent-client-protocol = "0.11"

[dev-dependencies]
agent-client-protocol-tokio = "0.11"
tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }

Core Concepts

`Determinishtic`

The main entry point. Wraps a connection to an LLM agent and provides the `think()` method.

// Connect to an agent
let d = Determinishtic::new(AcpAgent::zed_claude_code()).await?;

// Or use an existing connection (e.g., inside a proxy)
let d = Determinishtic::from_connection(cx.connection_to());

`ThinkBuilder`

A builder for composing prompts with embedded tools. Created via `d.think()`.

let result: MyOutput = d.think()
    .text("Analyze this data:")
    .display(&data)
    .textln("")
    .text("Focus on trends and anomalies