Embabel Agent Documentation/com.embabel.agent.api.common

Package-level declarations

Types

interface ActionContext : ExecutingOperationContext

Context for actions

open class Actor<T> constructor(val persona: T, val llm: <Error class: unknown class>, val toolGroups: Set<String> = emptySet())

Core abstraction for an LLM with tools and a persona. An Actor plays a role: Convenient way to combine a PromptContributor with an LLM and tools. Open to allow subclasses to add tools via @Tool methods

AgentFunction

interface AgentFunction<I, O> : BiFunction<I, ProcessOptions, O>

Reusable AgentFunction. Allows use of AgentPlatform as a function from I to O, with different process options.

AgentImage

data class AgentImage(val mimeType: String, val data: ByteArray)

Represents an image for Agent API operations. Provides convenient constructors for common image sources.

AgentPlatformTypedOps

class AgentPlatformTypedOps(agentPlatform: AgentPlatform) : TypedOps

Typed operations over an agent platform

Aggregation

interface Aggregation

Tag interface to indicate that an implementing type should be built from the context from its bound fields. Provides a strongly typed way to wait on combined results. Makes a megazord! An aggregation should have multiple non-nullable fields, each of which will be bound to the blackboard. An aggregation is used as an input to the action.

interface Ai

Gateway to AI functionality in the context of an operation. This includes both LLM and embedding models.

AiBuilder

interface AiBuilder : LlmVerbosity

Builder that can be injected into components to obtain Ai instances. Use when you want custom configuration.

Asyncer

interface Asyncer

Simple Java-friendly async interface.

ContextualPromptElement

interface ContextualPromptElement

Make a dynamic prompt contribution based on the operation context.

Embedding

typealias Embedding = FloatArray

ExecutingOperationContext

interface ExecutingOperationContext : OperationContext

OperationContext that execute actions. An ExecutingOperationContext can execute agents as sub-processes.

InputActionContext

interface InputActionContext : InputsActionContext

ActionContext with a single input

InputsActionContext

interface InputsActionContext : ActionContext

ActionContext with multiple inputs

InteractionId

value class InteractionId(val value: String)

All prompt interactions through the platform need a unique id This allows LLM interactions to be optimized by an AgentPlatform

LlmReference

interface LlmReference

An LLmReference exposes tools and is a prompt contributor. The prompt contribution might describe how to use the tools or can include relevant information directly. Consider, for example, a reference to an API which is so small it's included in the prompt, versus a large API which must be accessed via tools. The reference name is used in a strategy for tool naming, so should be fairly short. Description may be more verbose. If you want a custom naming strategy, use a ToolObject directly, and add the PromptContributor separately.

MulticastStuckHandler

class MulticastStuckHandler(stuckHandlers: List<StuckHandler>) : StuckHandler

Try to resolve a stuck agent process by trying all handlers in order

MultimodalContent

data class MultimodalContent(val text: String, val images: List<AgentImage> = emptyList())

Represents multimodal content for Agent API operations. This is a higher-level abstraction over the Chat API's ContentPart system designed specifically for use in Agent actions and prompt runners.

MultimodalContentBuilder

class MultimodalContentBuilder

Builder for creating multimodal content fluently

NoSuchAgentException

class NoSuchAgentException(val agentName: String, val knownAgents: String) : IllegalArgumentException

OperationContext

interface OperationContext : Blackboard, ToolGroupConsumer

Context for any operation. Exposes blackboard and process context.

PlannerType

enum PlannerType : Enum<PlannerType>

Specifies the type of planner that an agent uses.

PlatformServices

interface PlatformServices

Services used by the platform and available to user-authored code.

PromptRunner

interface PromptRunner : LlmUse, PromptRunnerOperations

User code should always use this interface to execute prompts. Typically obtained from an OperationContext or ActionContext parameter, via OperationContext.ai A PromptRunner is immutable once constructed, and has determined LLM and hyperparameters. Use the "with" methods to evolve the state to your desired configuration before executing createObject, generateText or other LLM invocation methods. Thus, a PromptRunner can be reused within an action implementation. A contextual facade to LlmOperations.

PromptRunnerOperations

interface PromptRunnerOperations

User-facing interface for executing prompts. These are what are executed on a finally configured PromptRunner.

SomeOf

interface SomeOf

Tag interface used as an action return type. Indicates that some of the fields will be bound to the blackboard. Fields are usually nullable.

StuckHandler

fun interface StuckHandler

Attempts to resolve stuck processes

StuckHandlerResult

class StuckHandlerResult(val message: String, val handler: StuckHandler?, val code: StuckHandlingResultCode, val agentProcess: AgentProcess) : AbstractAgentProcessEvent

StuckHandlingResultCode

enum StuckHandlingResultCode : Enum<StuckHandlingResultCode>

Subagent

class Subagent

Define a handoff to a subagent.

SupplierActionContext

class SupplierActionContext<O>(val processContext: ProcessContext, val action: Action, val outputClass: Class<O>) : ActionContext, Blackboard, AgenticEventListener

ToolObject

data class ToolObject(val objects: List<Any>, val namingStrategy: StringTransformer = StringTransformer.IDENTITY, val filter: (String) -> Boolean = { true })

Holds one or more annotated tool objects. Adds a naming strategy and a filter to the overall object.

ToolsStats

interface ToolsStats

Tool statistics, indexed by tool name.

ToolStats

open class ToolStats(val name: String, val calls: Int, val averageResponseTime: Long = 0, val failures: Int = 0)

Stats around tool calls to a particular tool. Open to allow implementations to extend if they wish

Transformation

fun interface Transformation<I, O>

Transformation function signature

TransformationActionContext

data class TransformationActionContext<I, O>(val input: I, val processContext: ProcessContext, val action: Action, val inputClass: Class, val outputClass: Class<O>) : InputActionContext , Blackboard, AgenticEventListener

TypedOps

interface TypedOps

Enables typed operations using agentic systems

Functions

agentTransformer

inline fun <I, O : Any> agentTransformer(agent: Agent): Action

fun <I, O : Any> agentTransformer(agent: Agent, pre: List<String> = emptyList(), post: List<String> = emptyList(), cost: CostComputation = { 0.0 }, value: CostComputation = { 0.0 }, canRerun: Boolean = false, inputClass: Class, outputClass: Class<O>): Action

asAction

inline fun <I, O : Any> asAction(agentName: String): Action

fun <I, O : Any> asAction(agentName: String, inputClass: Class, outputClass: Class<O>, pre: List<String> = emptyList(), post: List<String> = emptyList(), cost: CostComputation = { 0.0 }, value: CostComputation = { 0.0 }, canRerun: Boolean = false): Action

Expose the named agent as an action of the given transformation type

asAction