Embabel Agent Documentation/com.embabel.agent.core.hitl/SimpleAwaitableTypedTool

SimpleAwaitableTypedTool

class SimpleAwaitableTypedTool<I : Any, O : Any, P : Any> constructor(name: String, description: String, inputType: Class<I>, outputType: Class<O>, awaitableFactory: AwaitableFactory<I, P>, executor: (I) -> O, metadata: Tool.Metadata = Tool.Metadata.DEFAULT, objectMapper: <Error class: unknown class> = jacksonObjectMapper()) : TypedTool<I, O>

Simple implementation of AwaitableTypedTool using functional factories.

Example:

val tool = SimpleAwaitableTypedTool(
    name = "delete_file",
    description = "Delete a file",
    inputType = DeleteRequest::class.java,
    outputType = DeleteResult::class.java,
    awaitableFactory = { input ->
        ConfirmationRequest(input, "Delete ${input.path}?")
    },
    executor = { input ->
        DeleteResult(deleted = true, path = input.path)
    }
)

Constructors

SimpleAwaitableTypedTool

constructor(name: String, description: String, inputType: Class<I>, outputType: Class<O>, awaitableFactory: AwaitableFactory<I, P>, executor: (I) -> O, metadata: Tool.Metadata = Tool.Metadata.DEFAULT, objectMapper: <Error class: unknown class> = jacksonObjectMapper())

Properties

definition

open override val definition: Tool.Definition

Tool definition for LLM

metadata

open override val metadata: Tool.Metadata

Functions

call

open fun call(input: String, context: ToolCallContext): Tool.Result

Execute the tool with JSON input and out-of-band context.

open override fun call(input: String): Tool.Result

Executes the tool by deserializing input JSON, calling typedCall, and serializing the result.

requireType

inline fun <T : Any> Tool.requireType(message: String? = null): Tool

Wrap this tool to require a value of type T before execution (reified).

fun <T : Any> Tool.requireType(type: Class<T>, messageProvider: (String) -> String? = { null }): Tool

Wrap this tool to require a value of type T before execution.

toSpringToolCallback

fun Tool.toSpringToolCallback(): <Error class: unknown class>

Extension function to convert an Embabel Tool to a Spring AI ToolCallback.

typedCall

open fun typedCall(input: I): O

Execute the tool with strongly typed input. Calls the function provided at construction time. Can be overridden in subclasses for custom behavior.

unwrapAs

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

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

withAwaiting

fun Tool.withAwaiting(decider: AwaitDecider): Tool

Wrap this tool to conditionally await before execution.

withConfirmation

fun Tool.withConfirmation(messageProvider: (String) -> String): Tool

fun Tool.withConfirmation(message: String): Tool

Wrap this tool to always require confirmation before execution.

withDefinitionMetadata

open fun withDefinitionMetadata(entries: Map<String, Any>): Tool

Create a new tool with additional definition metadata entries merged in. Existing keys are overwritten by the new values.

open fun withDefinitionMetadata(key: String, value: Any): Tool

Create a new tool with a single definition metadata entry added.

withDescription

open fun withDescription(newDescription: String): Tool

Create a new tool with a different description. Useful for providing context-specific descriptions while keeping the same functionality.

withEventPublication

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

Extension function to wrap a Tool with event publication.

withName

open fun withName(newName: String): Tool

Create a new tool with a different name. Useful for namespacing tools when combining multiple tool sources.

withNote

open fun withNote(note: String): Tool

Create a new tool with an additional note appended to the description. Useful for adding context-specific hints to an existing tool.