SDK API

The nenjo crate is the core SDK. It turns manifest resources into executable agents and routines.

The SDK is intentionally small at the top level. A caller supplies manifests, a model factory, tools, knowledge packs, and optional memory. The SDK handles prompt assembly, agent lookup, the turn loop, streaming events, delegation support, routine execution, knowledge tools, and memory tooling.

Provider

A Provider is the root runtime object. It owns a loaded Manifest plus the factories needed to create models and tools.

use nenjo::Provider;

let provider = Provider::builder()
    .with_loader(my_manifest_loader)
    .with_model_factory(my_model_factory)
    .with_tool_factory(my_tool_factory)
    .with_memory(my_memory)
    .build()
    .await?;

The builder requires at least one manifest source and a model factory. If no tool factory is provided, agents run without external tools.

Multiple loaders are merged in order. This lets the worker combine platform manifests with local context sources.

Agents

Agents are resolved from the manifest by ID or name. The provider creates an AgentBuilder, then the builder produces an AgentRunner.

let runner = provider
    .agent_by_name("coder")
    .await?
    .build()
    .await?;

let output = runner.chat("Summarize the current project").await?;
println!("{}", output.text);

An AgentBuilder can add execution context before build():

Streaming

The SDK has both simple and streaming execution. Use chat() when only the final answer matters. Use chat_stream() when the caller needs tool events, transcript messages, pause/resume state, or completion output.

let mut handle = runner.chat_stream("Refactor the auth module").await?;

while let Some(event) = handle.recv().await {
    match event {
        nenjo::TurnEvent::ToolCallStart { calls, .. } => {
            println!("starting {} tool call(s)", calls.len());
        }
        nenjo::TurnEvent::Done { .. } => break,
        _ => {}
    }
}

let output = handle.output().await?;

TurnOutput contains the final text, token counts, tool call count, and messages that can be persisted as conversation history.

Routines

Routines are resolved from the same manifest and run through the provider.

let result = provider
    .routine_by_id(routine_id)?
    .run(task)
    .await?;

Use run_stream() for routine events and final output handling. Routine steps use the same provider-owned agent, model, tool, prompt, and memory machinery as normal agent runs.

Key Traits

Public Modules