Embabel Agent Documentation/com.embabel.agent.core.support

Package-level declarations

Types

abstract class AbstractAction(val name: String, val description: String = name, val pre: List<String> = emptyList(), val post: List<String> = emptyList(), val cost: CostComputation = { 0.0 }, val value: CostComputation = { 0.0 }, val inputs: Set<IoBinding> = emptySet(), val outputs: Set<IoBinding> = emptySet(), val toolGroups: Set<ToolGroupRequirement>, val canRerun: Boolean, clearBlackboard: Boolean = false, val qos: ActionQos = ActionQos()) : Action

Abstract action implementation that computes outputs.

AbstractAgentProcess

abstract class AbstractAgentProcess(val id: String, val parentId: String?, val agent: Agent, val processOptions: ProcessOptions, val blackboard: Blackboard, platformServices: PlatformServices, val timestamp: Instant = Instant.now()) : AgentProcess, Blackboard

Abstract implementation of AgentProcess that provides common functionality

BlackboardWorldState

class BlackboardWorldState(val conditionWorldState: ConditionWorldState, val blackboard: Blackboard) : ConditionWorldState

WorldState implementation that wraps a ConditionWorldState and includes a reference to the Blackboard for accessing domain objects at planning time. This enables @Cost methods to access domain objects for dynamic cost computation.

BlackboardWorldStateDeterminer

class BlackboardWorldStateDeterminer(processContext: ProcessContext, logicalExpressionParser: LogicalExpressionParser) : WorldStateDeterminer

Determine world state for the given ProcessContext, using the blackboard.

ConcurrentAgentProcess

open class ConcurrentAgentProcess(val id: String, val parentId: String?, val agent: Agent, val processOptions: ProcessOptions, val blackboard: Blackboard, platformServices: PlatformServices, plannerFactory: PlannerFactory, val timestamp: Instant = Instant.now(), val callbacks: List<AgentProcessCallback> = emptyList()) : SimpleAgentProcess

An AgentProcess that can execute multiple actions concurrently. With each invocation of formulateAndExecutePlan(), it will attempt to execute all actions that are currently achievable towards the plan.

DefaultAgentPlatform

open class DefaultAgentPlatform(val name: String, val description: String, val processType: AgentPlatformProperties.ProcessType, llmOperations: LlmOperations, val toolGroupResolver: ToolGroupResolver, eventListener: AgenticEventListener, agentProcessIdGenerator: AgentProcessIdGenerator = AgentProcessIdGenerator.RANDOM, contextRepository: ContextRepository = InMemoryContextRepository(), agentProcessRepository: AgentProcessRepository = InMemoryAgentProcessRepository(), operationScheduler: OperationScheduler = OperationScheduler.PRONTO, blackboardProvider: BlackboardProvider = InMemoryBlackboardProvider, asyncer: Asyncer, objectMapper: <Error class: unknown class>, outputChannel: OutputChannel, templateRenderer: <Error class: unknown class>, customLogicalExpressionParser: LogicalExpressionParser? = null, applicationContext: <Error class: unknown class>? = null) : AgentPlatform

InMemoryBlackboard

class InMemoryBlackboard(val blackboardId: String = UUID.randomUUID().toString()) : Blackboard

InMemoryBlackboardProvider

object InMemoryBlackboardProvider : BlackboardProvider

InvalidLlmReturnFormatException

class InvalidLlmReturnFormatException(val llmReturn: String, val expectedType: Class<*>, cause: Throwable) : RuntimeException

The LLM returned an object of the wrong type.

InvalidLlmReturnTypeException

class InvalidLlmReturnTypeException(val returnedObject: Any, val constraintViolations: Set<<Error class: unknown class><out <Error class: unknown class>>>) : RuntimeException

Thrown the LLM returned an object that fails validation, and although we tried, we could not correct it.

LlmCall

interface LlmCall : LlmUse, ToolConsumer

Spec for calling an LLM. Optional LlmOptions, plus tool callbacks and prompt contributors.

LlmInteraction

data class LlmInteraction(val id: InteractionId, val llm: <Error class: unknown class> = LlmOptions(), val toolGroups: Set<ToolGroupRequirement> = emptySet(), val tools: List<Tool> = emptyList(), val promptContributors: List<<Error class: unknown class>> = emptyList(), val contextualPromptContributors: List<ContextualPromptElement> = emptyList(), val generateExamples: Boolean? = null, val propertyFilter: Predicate<String> = Predicate { true }, val validation: Boolean = true, val useEmbabelToolLoop: Boolean = true, val maxToolIterations: Int = 20) : LlmCall

Encapsulates an interaction with an LLM. An LlmInteraction is a specific instance of an LlmCall. The LLM must have been chosen and the call has a unique identifier.

LlmUse

interface LlmUse : ToolGroupConsumer

Spec for calling an LLM. Optional LlmOptions, plus tool groups and prompt contributors.

RenamedTool

class RenamedTool(delegate: Tool, newName: String) : Tool

Allows renaming a Tool while preserving its behavior.

RenamedToolCallback

class RenamedToolCallback(delegate: <Error class: unknown class>, newName: String)

Allows renaming a ToolCallback

Rerun

object Rerun

SimpleAgentProcess

open class SimpleAgentProcess(val id: String, val parentId: String?, val agent: Agent, val processOptions: ProcessOptions, val blackboard: Blackboard, platformServices: PlatformServices, plannerFactory: PlannerFactory, val timestamp: Instant = Instant.now()) : AbstractAgentProcess

Properties

NIRVANA

val NIRVANA: Goal

Goal available to all Utility planners. Reach nirvana, where there is nothing more to do. It's important that this goal cannot be satisfied, to prevent the plan from completing prematurely. A plan may complete by satisfying another goal, but not by reaching nirvana.

Functions

safelyGetTools

fun safelyGetTools(instances: Collection<ToolObject>): List<Tool>

Extract native Tools from ToolObject instances. Preferred over safelyGetToolCallbacks as it returns framework-agnostic Tools.

safelyGetToolsFrom

fun safelyGetToolsFrom(toolObject: ToolObject): List<Tool>

Extract native Tools from a single ToolObject. Handles Embabel @LlmTool annotations, Spring AI @Tool annotations, and direct Tool/ToolCallback instances.

toEmbabelUsage

fun <Error class: unknown class>.toEmbabelUsage(): Usage