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

Package-level declarations

Types

ActionContext

interface ActionContext : ExecutingOperationContext

Context for actions

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.

AgentPlatformTypedOps

class AgentPlatformTypedOps(agentPlatform: AgentPlatform) : TypedOps

Typed operations over an agent platform

AgentUtils

object AgentUtils

For use from Java

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

Can be injected into components

Asyncer

interface Asyncer

Simple Java-friendly async interface.

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

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

NoSuchAgentException

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

ObjectCreator

interface ObjectCreator<T>

Create an object of the given type from a prompt or messages. Allows setting strongly typed examples.

OperationContext

interface OperationContext : Blackboard, ToolGroupConsumer

Context for any operation. Exposes blackboard and process context.

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.

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

TemplateOperations

class TemplateOperations(templateName: String, templateRenderer: <Error class: unknown class>, promptRunnerOperations: PromptRunnerOperations)

Llm operations based on a compiled template. Similar to PromptRunnerOperations, but taking a model instead of a template string. Template names will be resolved by the TemplateRenderer provided.

ToolObject

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

Holds an annotated tool object. Adds a naming strategy and a filter to the 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: <Error class: unknown class> = 0.0, value: <Error class: unknown class> = 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: <Error class: unknown class> = 0.0, value: <Error class: unknown class> = 0.0, canRerun: Boolean = false): Action

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

asAction

inline fun <I, O : Any> Agent.asAction(): Action

Expose this agent as an action of the given transformation type

asFunction

inline fun TypedOps.asFunction(): AgentFunction<I, O>

asSubProcess

inline fun <O : Any> ActionContext.asSubProcess(agentScopeBuilder: AgentScopeBuilder<O>): O

inline fun <O : Any> ActionContext.asSubProcess(agent: Agent): O

Run the given agent as a sub-process of this action context.

asTransformation

fun <I, O : Any> asTransformation(agent: Agent, outputClass: Class<O>): Transformation<I, O>

asTransformation

inline fun <I, O : Any> Agent.asTransformation(): Transformation<I, O>

Creates a transformation action from an agent

create

infix inline fun <T> PromptRunner.create(prompt: String): T

Create an object of the given type. Method overloading is evil

createObject

infix inline fun <T> PromptRunner.createObject(prompt: String): T

Create an object of the given type

inline fun <T> TemplateOperations.createObject(model: Map<String, Any>): T

createObjectIfPossible

inline fun <T> PromptRunner.createObjectIfPossible(prompt: String): T?

handleUserInput

inline fun <O> TypedOps.handleUserInput(intent: String, processOptions: ProcessOptions = ProcessOptions()): O

Turn user input into this type

transform

inline fun TypedOps.transform(input: I, processOptions: ProcessOptions = ProcessOptions()): O

Perform the magic trick of getting from A to B

fun TypedOps.transform(input: I, processOptions: ProcessOptions = ProcessOptions(), outputClass: Class<O>): O