Data structure for the output of reward calculations. Attributes: reward (float): The computed reward value based on the evaluation of th

A wrapper class that allows users to easily train custom agents with custom environments without having to directly interact with the underly

A simple environment for tool-based agents that provides questions and evaluates responses.

Inherits from gymnasium.envs.toy_text.frozen_lake.FrozenLakeEnv ## Description The game starts with the player at random location of the

An environment for MCP-based tools that provides questions and evaluates responses. Uses a dedicated connection manager to avoid asyncio cont

Reward function for evaluating mathematical answers. This class implements the RewardFunction protocol to process the input and determine

Context-based session for in-process LLM trace collection. Features thread-safe context propagation, nested sessions with metadata inheritance,

Reward function for evaluating code dataset answers. This class implements the RewardFunction protocol to process the input and determine

React agent adapted for AppWorld integration with rLLM. This agent implements the ReAct (Reasoning, Action) pattern specifically designed

Manages MCP connections in a dedicated thread to avoid asyncio context issues.

A math agent that solves mathematical problems step by step, following the BaseAgent interface.

An tool agent that can use tools to interact with the environment, refactored to follow the BaseAgent abstraction.

Mock reward function for testing.

Mock reward function for testing.

A unified tracking interface for logging experiment data to multiple backends. This class provides a centralized way to log experiment metrics, p

A class representing a dataset.

A trace is a dictionary with the following structure: { # Core LLM call information "name": str, # e.g., "proxy

Standalone SQLite-based trace store with fast session context queries. Uses a junction table pattern to enable efficient queries by session_

Data structure for input required to calculate rewards. Attributes: task_info (Dict): The task dictionary containing question, answer, an

Tool for executing Python code using Together Code Interpreter (TCI). This tool integrates with Together's Code Interpreter API to provide a

Simple context object returned by the store. Contains only essential fields for trace/signal storage and retrieval.

A view of a trajectory. Represents a collection of steps (each step = 1 trace) Each trace in the trajectory is automatically converted t

Parser for R1 tool call format.

RolloutEngine implementation using Tinker for model inference. Uses Tinker's renderer system for response parsing instead of ChatTemplatePar

Async OpenAI client with automatic tracing via request() override. Same as TrackedChatClient but inherits from AsyncOpenAI.

A tool for executing Python code in a sandboxed environment.

Represents the evaluation result for a single sample.

A tool for searching google.

In-memory tracer that appends traces to provided sessions. This tracer enables immediate access to LLM call traces via `session.llm_calls`

A tool for executing Python code in a sandboxed environment. This tool provides a safe way to execute Python code with timeout protection

Model class that uses rLLM's RolloutEngine for inference.

Handles policy updates via gradient descent. This class handles: - Training client management - Data processing (filtering, advantag

Dataset for Tinker SFT that loads from rLLM sources. This dataset: - Loads from parquet files OR HuggingFace Dataset objects (from Datas

Abstract base class for all tools that provides a common interface. All tools should inherit from this class and implement either: - for

Async wrapper around OpenAI AsyncStream that logs trace when fully consumed.

OpenAI client with automatic tracing via request() override. Inherits from OpenAI and overrides the request() method to intercept ALL API cal

Wrapper around OpenAI Stream that logs trace when fully consumed. This wrapper transparently passes through chunks from the underlying stream

PPO trainer for agent workflows with stepwise advantage and rejection sampling.

Environment for AppWorld integration with rLLM. AppWorld provides an environment of 9 applications (spotify, gmail, calendar etc) and 457 AP

A wrapper over CodeAgent that uses async model calls and implements rLLM trajectory interface.

Async wrapper around OpenAI AsyncStream that logs trace when fully consumed.

BM25 sparse retriever using Pyserini.

The object returned by a switch statement. When called, it will return True if the given argument equals its value, else False. It can be called with

Extended ChatCompletionResponseChoice with token IDs and compact logprobs.

Extended ChatCompletionResponse with token IDs matching native vLLM 0.10.2+ format.

Environment for competitive coding tasks that inherits from MultiTurnEnvironment.

Configuration class for retrieval server.

Dense retriever using FAISS and transformer encoder.

Encoder for query/document embeddings using transformer models.

Logger to save episodes to individual JSON files with step and data hash.

Enhanced file parsing for multiple formats.

A tool for extracting data from websites using the FireCrawl service.

Request body for flushing tracer queue.

Evaluator for Gaia dataset using StrandsAgent.

Represents a single Gaia dataset sample.

Judge for evaluating HLE responses using OpenAI API.