An immutable state object. This is the only way to interact with state in Burr.

Internal, utility class

Graph class allows you to specify actions and transitions between them. You will never instantiate this directly, just through the GraphBuilder,

An internal class that groups together all the lifecycle adapters. This allows us to call methods through a delegation pattern, enabling us to add

GraphBuilder class. This allows you to construct a graph without considering application concerns. While you can (and at first, should) use the Ap

Tracker to track locally -- goes along with the Burr UI. Writes down the following: #. The whole application + debugging information (e.g. sou

Burr ``Action`` wrapping a Haystack ``Component``. Haystack ``Component`` is the basic block of a Haystack ``Pipeline``. A ``Component`` is i

Represents a tracer factory to create tracer instances. User never instantiates this directly. Rather, this gets injected by the application. This

Action that invokes Amazon Bedrock models using the Converse API. :param model_id: Bedrock model identifier (e.g. Anthropic Claude on Bedrock).

Typing system for pydantic models. :param TypingSystem: Parameterized on the state model type.

Simple test tracking client for a recursive action

Contains a graph with information it needs to run. This is a bit more than a graph -- we have entrypoints + halt_after points. This is the cor

Container for a streaming result. This allows you to: 1. Iterate over the result as it comes in 2. Get the final result/state at the end

Container for an async streaming result. This allows you to: 1. Iterate over the result as it comes in 2. Await the final result/state at the

Streaming Bedrock action using the Converse Stream API. Parameters match :class:`BedrockAction` except the default ``name`` is ``bedrock_stre

Synchronous tracking client that logs to S3. Experimental. Errs on the side of writing many little files. General schema is: - bucket

Class for asynchronous SQLite persistence of state. This is a simple implementation. .. warning:: The synchronous persister closes the co

Does nothing, do not use this. This is for testing only.

Tracker that includes logging of OpenTelemetry events. Note you will be unlikely to instantiate this directly, rather, you will instantiate it thr

Stores pointers to unique identifiers for an application. This is used by a few different places to, say, store parent references bewteen appl

Class for SQLite persistence of state. This is a simple implementation.

Class to capture how to deserialize something. We register a key with a deserializer function. It's like single dispatch but based on a strin

Task to run a subgraph. Has runtime-specific information, like inputs, state, and the application ID. This is the lower-level component -- the use

Wraps an async coroutine that returns a persister so it can be used directly with ``async with``:: async with AsyncSQLitePersister.from_v

Application context. This is anything your node might need to know about the application. Often used for recursive tracking. Note this is als

Application logs are purely flat -- we will likely be rethinking this but for now this provides for easy parsing.

Pydantic model that represents metadata for an application. We will want to add tags here when we have them.

Does nothing asynchronously, do not use this. This is for testing only.

Class for async PostgreSQL persistence of state. .. warning:: The synchronous persister closes the connection on deletion of the class us

Represents a logged artifact

Pydantic model that represents an entry for the beginning of a step

Pydantic model that represents an entry for the beginning of a span

Broken persistor.

Stores data about a child application (either a fork or a spawned application). This allows us to link from parent -> child in the UI.

Pydantic model for the counter state.

Custom class we'll use to test custom serde

Effectively a no-op. State is backed by a dictionary, which allows every state item to... be a dictionary.

Dummy persistor.

Pydantic model that represents an entry for the end of a step

Pydantic model that represents an entry for the end of a span

Pydantic model that represents an entry for the first item of a stream

Pydantic model that represents an entry for the first item of a stream

Pydantic model that represents an entry for the beginning of a stream

Container exception to indicate that a lifecycle adapter is invalid.

Represents a span. These have action sequence IDs associated with them to put them in order.

Wrapper class to ensure that the lifecycle hooks are called before/after application calls. This is not called for streaming as there is special l

Pydantic model that represents an action for storing/visualization in the UI