Rig v0.43.0 Released !!!

[gold-silver-copper]

117 PRs merged since 0.42. The tag-to-tag diff is +2.88M/−0.33M lines, mostly recorded fixtures; excluding them it is +379k/−192k. The provider cassette corpus grew from 1,793 to 2,995 recordings, plus 2,058 replayable effect-log goldens, and there are seven new crates. Big thank you to all our contributors 🫡

0.43 highlights:

• Rig no longer enforces a runtime. rig-core no longer hard depends on tokio or reqwest.
• Bevy. An experimental Bevy runtime lives alongside the classic tokio-based agent runtime.
• Effects. Every model call, tool call and retrieval is an effect that can be served, observed, recorded and replayed, by the classic agent loop or by a Bevy ECS world.
• One model type. Models are defined by their associated types; users can easily implement novel model types such as Jev or pose estimation models.
• Long Horizon Cassettes Cassettes that span 100 turns, with multiple tool calls, verifying caching and id passing for real world tasks.
• Better Docs Doc comments have all been completely rewritten, focusing on succinctness.
• Caching Tokens ain't cheap,so caching accuracy has been improved across all providers.
• TypeSafe AI My name is Jev.

New Crates

crate	what it is
rig-reqwest	The bundled reqwest transport. On by default through the facade's reqwest feature.
rig-http	Transport contracts
rig-tungstenite	Bundled websocket backend (native targets). Facade feature websocket.
rig-rmcp	MCP tool support, moved out of rig-agent.
rig-ecs	Rig's effect bus and agent runtime in a Bevy World.
rig-cassette	Effect logs, runtime replay adapters and the provider cassette engine.
rig-typesafeai	TypeSafe AI "Jev" typed judgments. Facade feature typesafeai.

Effects

An effect is the result of an action. An action can be a model call, a tool call, an embedding, a memory operation, database retrieval, etc. Previously, most of these were neither directly observable nor serializable in Rig. The new effect system makes all actions observable, recordable and replayable. This allows us to augment our cassette system with an effect-log system, very useful for debugging provider contracts and the functioning of coding agents.

Two runtimes consume the same effect protocol: the classic rig-agent loop, and the new rig-ecs.

rig-ecs: Rig Inside a Bevy World

rig-ecs is a reimagining of the agent runtime on top of the Bevy runtime. It is very promising but is still experimental, and will likely go through many changes in the future, consider it a pre-alpha. If you want a more stable Rig experience, use the classic agent runtime.

• Effects, handlers, agents, runs, turns, utterances and content parts are entities.
• Relationships carry causality and conversation structure.
• Outcomes are components you can query and observe.
• Steering is just systems in named sets: rewrite a folded request in RigSet::Patch, judge a turn in RigSet::Judge, save in RigSet::Checkpoint.
• Checkpoints are the world as reflected data (checkpoint::save_world / load_world), including your own registered components. hold_after_tool_turn pauses a run at a durable tool-turn boundary so you can resume it in a fresh world.

rig-cassette: Record and Replay

The engine behind Rig's own test corpus is now a published crate, re-exported as rig::cassette.
Recording a classic agent is one builder call:

use rig::cassette::effect_log::EffectLogRecorder;
use rig::prelude::*;
use rig::providers::openai::{self, OpenAI};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let recorder = EffectLogRecorder::new();
    let agent = AgentBuilder::new(OpenAI::from_env()?.completion(openai::GPT_5_2))
        .record_to(recorder.clone())
        .build();

    agent.prompt("What is 2 + 2?").await?;

    // Every model call, tool call and retrieval the run made, as a replayable log.
    let log = recorder.take();
    std::fs::write("run.effects.json", serde_json::to_vec_pretty(&log)?)?;
    Ok(())
}

TypeSafe AI: typed judgments

rig-typesafeai adds a different kind of provider. Instead of free text, Jev returns typed, calibrated judgments:

• Choice picks one of your enum variants, with a probability distribution.
• Score grades on a rubric.
• Noul answers yes/no as a probability.
• DynamicScore and maps of questions cover rubrics defined at runtime.

A query is one generic struct used for both questions and answers, so routing and triage decisions come back as ordinary Rust types. examples/typesafeai_chat routes between agents, and examples/typesafeai_triage classifies support tickets.

use rig::typesafeai::{Evaluate, Jev, Noul};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let jev = Jev::from_env()?.evaluation();
    let ticket = serde_json::json!({
        "message": "My card shows two $49 charges after upgrading.",
        "recent_events": ["One $49 charge is settled; another $49 authorization is pending"],
    });

    // A typed yes/no judgment: the answer is a probability, not free text.
    let result = jev
        .evaluate(&ticket, Noul::new("The customer has two settled charges for the same purchase.")?)
        .await?;
    println!("P(duplicate settled charge) = {:.3}", result.answers.noul);
    Ok(())
}

Local Pose Estimation in rig-candle

rig_candle::pose::CandlePoseModel runs YOLOv8 pose estimation locally from a safetensors checkpoint you supply, in any size from n to x. It serves a custom PoseEstimation operation: RGB frames in, one FramePoses per frame out (bounding box, confidence and the 17 COCO keypoints), folded into a PoseTrack. It is the first real model built on the out-of-tree operation path. Streaming, unary calls, erasure to DynModel<PoseEstimation> and custom transports all work as they do for any other Rig model:

use futures::StreamExt;
use rig::candle::pose::{BodyPart, CandlePoseModel, ImageFrame, PoseRequest};
use rig::streaming::Item;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Any YOLOv8 pose checkpoint (n..x), as safetensors bytes.
    let weights = std::fs::read("yolov8n-pose.safetensors")?;
    let model = CandlePoseModel::from_safetensors_async(weights).await?.pose();

    // One RGB frame (or many: a video); here a blank 640x480 image.
    let frames: PoseRequest = [ImageFrame::from_rgb8(640, 480, vec![0; 640 * 480 * 3])?].into_iter().collect();

    let mut stream = model.stream(frames)?;
    while let Some(item) = stream.next().await {
        let Item::Event(frame) = item? else { continue };
        for person in &frame.people {
            let wrist = person.keypoint(BodyPart::LeftWrist);
            println!("person at {:.0}% confidence, left wrist at ({:.0}, {:.0})", person.confidence * 100., wrist.x, wrist.y);
        }
    }
    Ok(())
}

Caching

Caching got its own verification harness this cycle. It uses a three-turn probe that measures the cache hit ratio rather than just "cached > 0", plus 100-turn long-run recordings on Anthropic (claude-opus-5-5), OpenAI (gpt-6-sol) and Gemini. The harness found bugs on its first run. Gemini tool schemas and Cohere documents were serialized from a HashMap in a different key order on every request, so the cacheable prefix changed every time and those requests could never hit.

Gemini explicit context caching: gemini::cached_content creates, gets, lists, updates and deletes cachedContents resources, and with_cached_content points a request at one. CacheExpiry makes a TTL and an absolute expiry mutually exclusive. The request rejects the combinations Gemini rejects (a cache owns the system instruction, tools and tool config), naming every conflict. An expired handle is ProviderError::CacheExpired.

Automatic caching for long Gemini runs: wrap a Gemini model with .caching(&book) and a shared CacheBook manages explicit caches for you. It reads the longest live cache a request starts with, rolls a new cache when the input premium already paid would cover it, stays inline where implicit caching serves, shares prefixes across sub-agents, extends and deletes caches on schedule, and resumes from checkpointed leases(). ThoughtReplay::CurrentTurn stops re-sending old thought signatures, which Gemini 3 would otherwise re-bill as input. In the recordings, a 100-turn support chat on gemini-3.8-flash went from about 1% of input cached (implicit caching only) to 93% cached and a 78.6% input-cost saving with a book and current-turn replay. With the default thought replay, the same chat was 55% cached, a 46% saving.

use rig::prelude::*;
use rig::providers::gemini::caching::{AutoCache, CacheBook};
use rig::providers::gemini::{self, Gemini};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // One book can be shared by many models and agents (e.g. sub-agents with a common prefix).
    let book = CacheBook::new(AutoCache::default());
    let model = Gemini::from_env()?
        .completion(gemini::completion::GEMINI_2_5_FLASH)
        .caching(&book);

    let agent = AgentBuilder::new(model)
        .preamble("You are a support agent. <a very long policy document goes here>")
        .build();
    let mut history = Vec::new();
    for question in ["Where is my order?", "Can I change the address?"] {
        let answer = agent.chat(question, &mut history).await?;
        println!("{}", answer.output);
    }
    println!("{:?}", book.report());
    Ok(())
}

Providers Are Clients, and Models Are Values

In 0.42 a provider was a generic Client<Ext, H>. Everything that could be built from it went through a family of capability traits (CompletionClient, EmbeddingsClient, …), and every model was its own type implementing one of eight model traits (CompletionModel, EmbeddingModel, …). Most of that is gone in 0.43. A provider is now two types:

• A config (OpenAIConfig, AnthropicConfig, GeminiConfig, …): the settings. It is serializable, and its credential is never serialized.
• A client (OpenAI, Anthropic, Gemini, Cohere, Ollama, Copilot, VoyageAi): the settings bound to a transport. This is what you normally hold.

Every model, for every operation and every backend, is one type: Model<W, T>, a wire (what to send and how to read the reply) on a transport (how the bytes travel). You call it with call(..) or stream(..). erase() turns it into a cloneable DynModel<Op> when you want to store models of different providers side by side. AgentBuilder::new, ExtractorBuilder::new and every vector store accept anything that converts into the matching DynModel.

Models from a string. The new rig::providers::registry module makes provider selection data. ProviderRef::parse("vendor/format:model") accepts the canonical form or the vendor:model shorthand, and completion_model() builds a DynModel<Completion> with credentials from the environment. completion_model_with(key, http) takes explicit credentials and a transport. This is useful for config files, CLIs and routers:

use rig::prelude::*;
use rig::providers::registry::ProviderRef;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // `vendor/format:model`, or the `vendor:model` shorthand; credentials come from the environment.
    let model = ProviderRef::parse("deepseek:deepseek-v4-flash")?.completion_model()?;
    let agent = AgentBuilder::new(model).build();
    println!("{}", agent.prompt("Hello!").await?.output);
    Ok(())
}

rig-core Without reqwest or tokio

rig-core is now transport-agnostic all the way down. Its hot paths no longer touch tokio primitives (streaming, the tool server, the Copilot and ChatGPT auth caches), and reqwest is gone from its dependencies and its public error types. The transports are separate crates:

crate	what it is
rig-http	The transport contracts: HttpClientExt, DynHttpClient, HttpMiddleware, framing and multipart; ws_client (WebSocketClientExt, WebSocketConnection); wasm_compat. rig-core re-exports all of them at the old rig_core::http_client and rig_core::ws_client paths.
rig-reqwest	The bundled reqwest transport: ReqwestClient, whose Default is a process-wide shared client, plus ReqwestMiddlewareClient (the reqwest-middleware* features), shared(), from_reqwest and multipart_form.
rig-tungstenite	The bundled tokio-tungstenite websocket backend (TungsteniteClient), native targets only, with rustls or native-tls.

The rig facade turns the bundled transport on by default (feature reqwest), so OpenAI::from_env() just works. If you depend on rig-core directly, enable its reqwest feature; without it, bring your own transport with OpenAIConfig::from_env()?.connect(http) (every config has connect).

Websockets. The OpenAI Responses websocket protocol moved into rig-core, and the socket lives in rig-tungstenite. With the facade's websocket feature, a Responses model opens a session directly. Without it, pass any WebSocketClientExt to connect_with(..):

use rig::completion::CompletionRequest;
use rig::providers::openai::{self, OpenAI};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // With the `websocket` feature, a Responses model opens a session on the bundled backend.
    let model = OpenAI::from_env()?.responses(openai::GPT_6_1_SOL);
    let mut session = model.responses_websocket().connect().await?;
    let reply = session.completion(CompletionRequest::new("Hello over a websocket!")).await?;
    println!("{}", reply.text());
    session.close().await?;
    Ok(())
}

One Error Type

CompletionError, EmbeddingError, RerankError, TranscriptionError, ImageGenerationError, AudioGenerationError, VerifyError and ModelListingError are now one enum: rig::ProviderError, also in both preludes. The variant is the classification (kind()).

Usage Means One Thing Everywhere

Absent is not zero. All seven Usage counters are Option<u64>: None means the provider didn't report that counter, and Some(0) is a reported zero. Usage::new() is gone (Usage::default() is all-None), and has_values() is now is_reported().

One contract on every provider. This release decoded every one of the 7,178 recorded replies in the corpus and made the numbers agree:

cached_input_tokens + cache_creation_input_tokens <= input_tokens
reasoning_tokens <= output_tokens
total_tokens == input_tokens + output_tokens

Reasoning, Signatures and Tool-Call Ids That Survive the Round Trip

Providers hand Rig values that only they can interpret and expect back on the next turn: thinking signatures, encrypted reasoning, reasoning item ids, tool-call ids and cache handles. This cycle started recording those values verbatim. An oracle now checks all 1,655 continuation pairs in the corpus: every delivered value must come back, in its exact slot, on the next request.

Hooks: Run Lifecycle, Durable State and Effects

AgentHook gains the start and end of a run, durable state, and one pair of hooks for everything the run does:

• on_run_start fires once before the first model call. It can continue, rewrite the prompt, or stop the run.
• on_run_settled fires exactly once, on success or failure, with the messages the run actually committed.
• on_dispatch / on_outcome fire for every effect the run issues (model calls, tool calls, retrieval, memory) and replace on_tool_call, on_tool_result and the completion-response hooks. OutcomeEvent::completion() gives you the model reply when that's what landed.
• Durable hook state. HookContext::append_entry(kind, &value) appends to a RunEntry log carried inside the serialized AgentRun, and entries(kind) / last_entry(kind) read it back. A resumed run replays the log, so there is no manual export step. Entries never reach a provider request.
• Malformed tool arguments are recoverable. A streamed tool call whose arguments aren't JSON used to end the run. It now reaches on_invalid_tool_call with InvalidToolCallReason::MalformedArguments and the raw text, so a hook can Retry, Skip or Stop.

Providers

New Models

• Anthropic: CLAUDE_OPUS_5_5 and CLAUDE_SONNET_5_5, plus the Claude 5 family CLAUDE_FABLE_5_1, CLAUDE_FABLE_5, CLAUDE_OPUS_5 and CLAUDE_SONNET_5 (requested by @scadoshi). All have 128K output limits. Model ids are now also exported at rig::providers::anthropic directly.
• OpenAI: GPT_6_ASTRA, GPT_6_1_SOL, GPT_6_SOL, GPT_6_LUNA, GPT_5_4, GPT_5_4_MINI, GPT_5_4_NANO and GPT_5_2_PRO.
• Each new Anthropic and OpenAI model is backed by one long recorded session that exercises tools, structured output, streaming, documents and caching. Every provider 400 that Rig itself caused was fixed along the way (see Bug Fixes).
• Groq: the current catalog: LLAMA_3_3_70B_VERSATILE, GPT_OSS_120B, GPT_OSS_20B, GPT_OSS_SAFEGUARD_20B, QWEN3_8_27B and MINIMAX_M2_7. The retired constants are removed (reported by @Muhammad-Owais-Warsi).
• Moonshot: KIMI_K3, KIMI_K2_7_CODE, KIMI_K2_7_CODE_HIGHSPEED and KIMI_K2_6. The discontinued MOONSHOT_CHAT, KIMI_K2 and KIMI_K2_5 are removed (reported by @loony-lisa and @Parikalp-Bhardwaj).
• Ollama: current completion constants (Llama 3.1/3.3/4, Gemma 3/4, Qwen 3/3.5/3.6/3.8/coder, DeepSeek R1/V3.1, gpt-oss, Phi-4, Mistral Small 3.2) and embedding constants with known dimensions (MXBAI_EMBED_LARGE, BGE_M3, EMBEDDINGGEMMA, QWEN3_EMBEDDING).

llama.cpp Replaces llamafile

providers::llamafile is gone. providers::llamacpp targets llama-server, the upstream everyone actually runs; a .llamafile serves the same API. It supports completion, embeddings and, new this release, rerank and model listing. It sends images in tool results, which llama.cpp honours and OpenAI does not; that capability was first attempted by @inqode-lars. A specific-function tool_choice, which llama-server silently served as auto, is now refused before sending. Construct it with llamacpp::from_env() or llamacpp::new(key).

Huge thank you to everyone who made 0.43 happen:

• @0xMochan
• @allenrchan
• @BANG404
• @inqode-lars
• @jackthepunished
• @KumaCrypto
• @loony-lisa
• @Muhammad-Owais-Warsi
• @mzdora
• @Parikalp-Bhardwaj
• @scadoshi
• @tiswas247

We build Rig, Rig builds us!

Full changelog: v0.42.0...v0.43.0

[sergiomeneses]

Congratulations guys, great work 🚀 🚀 🚀

[Muhammad-Owais-Warsi]

Congratulations, amazing work 🔥🔥

[JOSHMT0744]

whooppp