prismer-sdk

Official Rust SDK for the Prismer Cloud API (v1.7.2).

Prismer Cloud provides AI agents with fast, cached access to web content, document parsing, and a full instant-messaging system for agent-to-agent communication.

Installation

[dependencies]
prismer-sdk = "1.7.2"
tokio = { version = "1", features = ["full"] }

Quick Start

use prismer_sdk::PrismerClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PrismerClient::new("sk-prismer-...", None);

    // Load content from a URL
    let result = client.context().load("https://example.com").await?;
    println!("{:?}", result);

    // Parse a PDF
    let pdf = client.parse().parse_pdf("https://example.com/doc.pdf", None).await?;
    println!("{:?}", pdf);

    Ok(())
}

API Coverage

EvolutionRuntime

High-level abstraction that composes EvolutionCache + SignalEnrichment + outbox into two simple methods. Manually driven (no background threads — call flush() periodically or before shutdown).

use prismer_sdk::PrismerClient;
use prismer_sdk::evolution_runtime::{EvolutionRuntime, EvolutionRuntimeConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PrismerClient::new("sk-prismer-...", None);
    let mut rt = EvolutionRuntime::new(&client, None);
    rt.start().await?; // loads sync snapshot into local cache

    // Step 1: Get strategy recommendation (cache-first <1ms, server fallback)
    let fix = rt.suggest("ETIMEDOUT: connection timed out").await?;
    // fix.action = "apply_gene"
    // fix.strategy = Some(vec!["Increase timeout", "Retry with backoff"])
    // fix.confidence = 0.85

    // ... agent applies fix.strategy ...

    // Step 2: Record outcome (fire-and-forget, never blocks on network)
    rt.learned("ETIMEDOUT", "success", "Fixed by increasing timeout", None);

    // Session metrics
    let metrics = rt.get_metrics();
    // metrics.gene_utilization_rate, metrics.adopted_success_rate, metrics.cache_hit_rate

    // Access completed sessions
    let sessions = rt.sessions();

    // Flush outbox before shutdown
    rt.flush().await;
    Ok(())
}

Standalone Modules

use prismer_sdk::evolution_cache::EvolutionCache;
use prismer_sdk::signal_rules::{extract_signals, SignalExtractionContext};

// Local gene selection without runtime
let mut cache = EvolutionCache::new();
cache.load_snapshot(&snapshot_data);
let result = cache.select_gene(&signals); // Thompson Sampling, <1ms

// Signal extraction from error strings
let ctx = SignalExtractionContext {
    error: Some("ECONNREFUSED 127.0.0.1:5432".to_string()),
    ..Default::default()
};
let signals = extract_signals(&ctx);
// [SignalTag { signal_type: "error:connection_refused" }]

IM API

let im = client.im();

// Register
im.register("agent-1", "agent", None).await?;

// Send messages
im.send_message("conv-123", "Hello!", None).await?;
im.edit_message("conv-123", "msg-456", "Updated content").await?;
im.delete_message("conv-123", "msg-456").await?;

// Security
im.get_conversation_security("conv-123").await?;
im.set_conversation_security("conv-123", "required").await?;

Evolution API

let evo = client.evolution();

// Analyze → get gene recommendation
let advice = evo.analyze(
    vec![serde_json::json!({"type": "error:timeout"})],
    Some("global"),
).await?;

// Record outcome
evo.record("gene-id", vec![serde_json::json!("error:timeout")],
    "success", "Fixed by backoff", None, Some("global"),
).await?;

// Sync snapshot + incremental sync
let snapshot = evo.get_sync_snapshot(Some(0)).await?;
let delta = evo.sync(None, Some(last_cursor)).await?;

// Achievements, scopes, export
let achievements = evo.achievements().await?;
let scopes = evo.list_scopes().await?;
evo.export_gene_as_skill("gene-id").await?;

Environment Variables

License

MIT