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

Package-level declarations

Types

abstract class AbstractLlmOperations(toolDecorator: ToolDecorator, modelProvider: ModelProvider, validator: <Error class: unknown class>, validationPromptGenerator: ValidationPromptGenerator = DefaultValidationPromptGenerator(), autoLlmSelectionCriteriaResolver: AutoLlmSelectionCriteriaResolver, dataBindingProperties: LlmDataBindingProperties, promptsProperties: LlmOperationsPromptsProperties = LlmOperationsPromptsProperties()) : LlmOperations

Convenient superclass for LlmOperations implementations, which should normally extend this Find all tool callbacks and decorate them to be aware of the platform Also emits events.

AgenticEventListenerToolsStats

class AgenticEventListenerToolsStats : AgenticEventListener, ToolsStats

AgentProcessBindingTool

class AgentProcessBindingTool(val delegate: Tool, agentProcess: AgentProcess) : DelegatingTool

Tool decorator that binds AgentProcess to thread-local for tool execution.

AgentScanningBeanPostProcessorEvent

class AgentScanningBeanPostProcessorEvent(source: Any)

Event to signal that AgentScanningBeanPostProcessor has completed processing all beans.

DefaultPlannerFactory

object DefaultPlannerFactory : PlannerFactory

PlannerFactory that knows about GOAP and Utility planners

DefaultProcessIdGeneratorProperties

class DefaultProcessIdGeneratorProperties(platformProperties: AgentPlatformProperties)

DelegatingTool

interface DelegatingTool : Tool

Interface for tool decorators that wrap another tool. Enables unwrapping to find the underlying tool implementation.

EventPublishingTool

class EventPublishingTool(val delegate: Tool, agentProcess: AgentProcess, action: Action?, llmOptions: <Error class: unknown class>) : DelegatingTool

Tool decorator that publishes events for tool calls.

ExceptionSuppressingTool

class ExceptionSuppressingTool(val delegate: Tool) : DelegatingTool

Tool decorator that suppresses exceptions and returns a warning message instead.

ExecutorAsyncer

class ExecutorAsyncer(executor: Executor) : Asyncer

InMemoryAgentProcessRepository

class InMemoryAgentProcessRepository(properties: ProcessRepositoryProperties = ProcessRepositoryProperties()) : AgentProcessRepository

In-memory implementation of AgentProcessRepository with configurable window size to prevent memory overflow by evicting the oldest entries when the limit is reached.

InMemoryContext

class InMemoryContext(var id: String) : Context

Simple in-memory implementation of Context.

InMemoryContextRepository

class InMemoryContextRepository(properties: ContextRepositoryProperties = ContextRepositoryProperties()) : ContextRepository

In-memory implementation of ContextRepository with configurable window size to prevent memory overflow by evicting the oldest entries when the limit is reached.

LlmDataBindingProperties

class LlmDataBindingProperties(val maxAttempts: Int = 10, val fixedBackoffMillis: Long = 30, val sendValidationInfo: Boolean = true) : RetryTemplateProvider

We want to be more forgiving with data binding. This can be important for smaller models.

LlmOperationsPromptsProperties

class LlmOperationsPromptsProperties

Properties for the ChatClientLlmOperations operations

MetadataEnrichedTool

class MetadataEnrichedTool(val delegate: Tool, val toolGroupMetadata: ToolGroupMetadata?) : DelegatingTool

Tool decorator that adds metadata about the tool group.

ObservabilityTool

class ObservabilityTool(val delegate: Tool, observationRegistry: <Error class: unknown class>? = null) : DelegatingTool

Tool decorator that adds Micrometer Observability.

ObservabilityToolCallback

class ObservabilityToolCallback(delegate: <Error class: unknown class>, observationRegistry: <Error class: unknown class>? = null)

Decorator that adds Observability to a ToolCallback.

OutputConverter

interface OutputConverter<T>

Output converter abstraction for parsing LLM output. Framework-agnostic interface that can be implemented by Spring AI converters or others.

OutputTransformingTool

class OutputTransformingTool(val delegate: Tool, outputTransformer: StringTransformer) : DelegatingTool

Tool decorator that transforms the output using a provided StringTransformer.

OutputTransformingToolCallback

class OutputTransformingToolCallback(delegate: <Error class: unknown class>, outputTransformer: StringTransformer)

Transforms the output of a tool callback using a provided StringTransformer.

ProcessOptionsOperationScheduler

class ProcessOptionsOperationScheduler(val operationDelays: Map<Delay, Long> = mapOf( Delay.NONE to 0L, Delay.MEDIUM to 400L, Delay.LONG to 2000L, ), val toolDelays: Map<Delay, Long> = mapOf( Delay.NONE to 0L, Delay.MEDIUM to 400L, Delay.LONG to 2000L, )) : OperationScheduler

Operation scheduler driven from process options

RankingProperties

data class RankingProperties(val llm: String? = null, val maxAttempts: Int = 5, val backoffMillis: Long = 100, val backoffMultiplier: Double = 5.0, val backoffMaxInterval: Long = 180000) : RetryProperties

Properties for the ranking service. Optional LLM selection, plus normal retry properties.

RegistryToolGroupResolver

class RegistryToolGroupResolver(val name: String, val toolGroups: List<ToolGroup>) : ToolGroupResolver

Resolves ToolGroups based on a list. The list is normally Spring-injected, with ToolGroup instances being Spring beans.

SpringContextPlatformServices

data class SpringContextPlatformServices(val agentPlatform: AgentPlatform, val llmOperations: LlmOperations, val eventListener: AgenticEventListener, val operationScheduler: OperationScheduler, val agentProcessRepository: AgentProcessRepository, val asyncer: Asyncer, val objectMapper: <Error class: unknown class>, val outputChannel: OutputChannel, val templateRenderer: <Error class: unknown class>, val customLogicalExpressionParser: LogicalExpressionParser? = null, applicationContext: <Error class: unknown class>?) : PlatformServices

Uses Spring ApplicationContext to resolve some beans for platform services. If a custom LogicalExpressionParser is provided, it will be used, otherwise all LogicalExpressionParsers in the context will be combined. A SpelLogicalExpressionParser will be added if not already present.

ToolLoopLlmOperations

open class ToolLoopLlmOperations(modelProvider: ModelProvider, toolDecorator: ToolDecorator, validator: <Error class: unknown class>, validationPromptGenerator: ValidationPromptGenerator = DefaultValidationPromptGenerator(), dataBindingProperties: LlmDataBindingProperties = LlmDataBindingProperties(), autoLlmSelectionCriteriaResolver: AutoLlmSelectionCriteriaResolver = AutoLlmSelectionCriteriaResolver.DEFAULT, promptsProperties: LlmOperationsPromptsProperties = LlmOperationsPromptsProperties(), objectMapper: <Error class: unknown class> = jacksonObjectMapper().registerModule(JavaTimeModule()), observationRegistry: <Error class: unknown class> = ObservationRegistry.NOOP) : AbstractLlmOperations

LlmOperations implementation that uses Embabel's framework-agnostic tool loop.

Properties

PROMPT_ELEMENT_SEPARATOR

const val PROMPT_ELEMENT_SEPARATOR: String

Functions

unwrap

fun Tool.unwrap(): Tool

Unwrap a tool to find the innermost implementation. Recursively unwraps DelegatingTool wrappers.

unwrapAs

inline fun <T : Tool> Tool.unwrapAs(): T?

Unwrap a tool to find a specific type, or return null if not found.

withEventPublication

fun Tool.withEventPublication(agentProcess: AgentProcess, action: Action?, llmOptions: <Error class: unknown class>): Tool

Extension function to wrap a Tool with event publication.