Package-level declarations

Represents the context for handling an after LLM call event.

Represents a functional interface for handling operations or logic that should occur after a call to a large language model (LLM) is made. The implementation of this interface provides a mechanism to perform custom logic or processing based on the provided inputs, such as the prompt, tools, model, and generated responses.

Handler for intercepting node execution after it completes.

Represents the context passed to the handler that is executed before an agent is closed.

Functional interface for handling logic that needs to be executed before an agent is closed.

Handler for creating a feature instance in a stage context.

Functional interface for handling logic that needs to be executed before an agent is closed.

Handler for transforming an instance of AgentEnvironment.

Provides the context for handling events specific to AI agents. This interface extends the foundational event handling context, EventHandlerContext, and is specialized for scenarios involving agents and their associated workflows or features.

Represents the context for handling the completion of an agent's execution.

Functional interface for handling the completion of an agent's operation. This handler is executed when an agent has finished its work, and it provides the name of the strategy that was executed along with an optional result.

Feature implementation for agent and strategy interception.

Represents the context for handling errors that occur during the execution of an agent run.

Functional interface for handling errors that occur during the execution of an agent run.

Represents the context available during the start of an AI agent.

Provides a context for executing transformations and operations within an AI agent's environment.

Functional interface to define a handler that is invoked before an agent starts. This handler allows custom pre-start logic to be executed with access to the provided agent start context and associated feature.

Represents the context for handling a before LLM call event.

A functional interface implemented to handle logic that occurs before invoking a large language model (LLM). It allows preprocessing steps or validation based on the provided prompt, available tools, targeted LLM model, and a unique run identifier.

Handler for intercepting node execution before it starts.

Represents the context in which event handlers operate, providing a foundational interface for all event handling activities within the AI Agent framework.

A handler responsible for managing the execution flow of a Large Language Model (LLM) call. It allows customization of logic to be executed before and after the LLM is called.

Container for node execution handlers. Holds both before and after node execution handlers.

Handler for executing tools with customizable behaviors for tool calls, validation errors, failures, and results.

Represents the context for handling LLM-specific events within the framework.

Represents the context for handling an after node execution event.

Represents the context for handling a before node execution event.

Represents the context for handling node-specific events within the framework.

Defines the context specifically for handling strategy-related events within the AI agent framework. Extends the base event handler context to include functionality and behavior dedicated to managing the lifecycle and operations of strategies associated with AI agents.

Represents the context associated with the completion of an AI agent strategy execution.

Functional interface representing a handler invoked when a strategy execution is finished.

A handler class for managing strategy-related events, providing callbacks for when strategies are started or finished. It is designed to operate on a specific feature type and delegate event handling to the assigned handlers.

Represents the context for updating AI agent strategies during execution.

A functional interface for handling start events of an AI agent strategy.

Represents the context for handling a tool call event.

Represents the context provided to handle a failure during the execution of a tool.

Functional interface for handling failures that occur during the execution of a tool. This interface provides a mechanism to manage errors resulting from tool operations, including access to the tool, its arguments, and the associated error.

Functional interface representing a handler for tool calls. This interface allows the implementation of custom logic to handle the execution of tools and their associated arguments.

Represents the context used when handling the result of a tool call.

A functional interface designed for handling the result of tool executions in a structured manner. Implementations can define custom logic for processing the result of a tool based on the provided tool instance, its arguments, and the execution result.

Represents the context for handling tool-specific events within the framework.

Represents the context for handling validation errors that occur during the execution of a tool.

A functional interface to handle validation errors that occur during the execution or configuration of a tool. This interface provides a mechanism for processing or logging errors associated with tools and their arguments.