Build the result dict and ensure each ``writes`` key maps to the right value.

Utility function to parse a list of actions/tags into a list of actions and a list of tags.

Simple wrapper around the OpenAI API.

Simple wrapper around the OpenAI API.

Utility function to decide what to return for iterate/arun. Note that run() will delegate to the return value of iterate, whereas arun cannot

Converts a python function into a specification for function calling. This is a little hacky. But it works. It takes a function, introspects

Updates all application with associate metadata and graph files :param all_applications: All applications that are relevant :param pa

Upload artifacts to Apache SVN distribution repository.

Verify wheel contents are correct.

Verify wheel metadata and package validity using twine.

Yields actions to run in parallel. These will be merged with the states as a cartesian product. :param state: Input state at the time of runn

At the update state of a Hamilton Action, call state.append to the key field of state. Used with outputs= parameter of Hamilton(...) :param k

Builds the application

Build the kwargs dict for ``converse`` / ``converse_stream`` from current state.

Builds the streaming application -- this uses the generate_post_streaming action

Builds the async streaming application -- uses the generate_post_streaming_async action

Copies a function. This is used internally to bind parameters to a function so we don't accidentally overwrite them. :param f: Function to co

Helper function to create an agent with a system message and tools.

Create a fully-configured Burr UI FastAPI application. This factory creates a new FastAPI instance with all Burr UI routes, demo routers, and

Create a key for the Redis database.

Create a key for the Redis database.

Returns the default state and entry point for the application.

Returns the default state and entry point for the application.

Returns the default state and entry point for the application.

Returns the default state and entry point for the application.

Creates an ActionModel from an action. :param action: Action to create the model from :return:

Creates a backend from settings, of the type of settings_model above This defaults to assuming the constructor takes in settings parameters

Builds a new instance of the PostgreSQLPersister from the provided values. :param db_name: the name of the PostgreSQL database. :para

* Get State * Get the current state of the application * * :param project_id: ID of the project (used by telemetry tracking/storage) * :pa

Return the Bedrock runtime client, creating it lazily if not injected.

Gives the next node to execute given state + prior step.

Initialize the agent DAG with the tracer. Right now there is no difference between the agents, but this is here for future use.

Initializes the tracer for OpenTel. Note this sets it globally. TODO -- ensure that it is initialized properly/do this in a cleaner manner. Op

Check if the persister has been initialized appropriately.

This checks to see if the table has been created in the database or not. It defaults to using the initialized field, else queries the database

Quick tool to allow plugin to the app's lifecycle. This is fine given that it's an internal API, but if we open it up more we should m

List the app ids for a given partition key.

Merges two states together, overwriting the values in self with those in other.

Reduces the states from the tasks into a single state. :param states: State outputs from the subtasks :return: Reduced state

Reduces the task's results :param results: :return:

Register a custom serde for a field

Substack blog entries retrieved from a RSS feed

Performs a run/update at the same time. :param state: State to run the action on :param run_kwargs: Additional arguments to the funct

Save the state data to the Redis database. :param partition_key: :param app_id: :param sequence_id: :param position:

Default method if all the hamilton nodes are using the same driver. Will set globally, so be careful. Note that the driver must have

State initializer for the action -- what initializer does the sub-application use? This can either be: - "cascade": inherit from pare

Persister for the action -- what persister does the sub-application use? This can either be: - "cascade": inherit from parent

Yields states to run in parallel. These will be merged with the actions as a cartesian product. :param state: Input state at the time of runn