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

Package-level declarations

Types

class AgentBuilder(val name: String, val provider: String = "embabel", val version: <Error class: unknown class> = Semver(), val description: String, promptContributors: List<<Error class: unknown class>> = emptyList())

Instances of this are usually created via the convenient agent() function.

AgentScopeBuilder

data class AgentScopeBuilder<O>(val name: String, val provider: String = "embabel", val actions: List<Action> = emptyList(), val goals: Set<Goal> = emptySet(), val conditions: Set<Condition> = emptySet(), val opaque: Boolean = false)

AgentScopeBuilder that emits actions and can be built on further.

BiInputActionContext

data class BiInputActionContext<A1, A2>(val input1: A1, val input2: A2, val actionContext: ActionContext) : InputsActionContext, ActionContext

ConditionPredicate

typealias ConditionPredicate = (context: OperationContext) -> Boolean?

Functions

agent

fun agent(name: String, provider: String = "embabel", version: <Error class: unknown class> = Semver(), description: String, promptContributors: List<<Error class: unknown class>> = emptyList(), block: AgentBuilder.() -> Unit): Agent

Surface area of DSL for creating an agent.

aggregate

inline fun <A, B, C> aggregate(transforms: List<(context: InputActionContext<A>) -> B>, noinline merge: (list: List, context: OperationContext) -> C): AgentScopeBuilder<C>

Run all the transforms and merge the results.

fun <A, B, C> aggregate(transforms: List<(context: InputActionContext<A>) -> B>, merge: (list: List, context: OperationContext) -> C, aClass: Class<A>, bClass: Class, cClass: Class<C>): AgentScopeBuilder<C>

andThen

inline fun <A, B, C> Function<A, B>.andThen(that: Function<InputActionContext, C>): AgentScopeBuilder<C>

infix inline fun <A, B, C> (A) -> B.andThen(crossinline that: (B) -> C): AgentScopeBuilder<C>

fun <A, B, C> Function<InputActionContext<A>, B>.andThen(that: Function<InputActionContext, C>, aClass: Class<A>, bClass: Class, cClass: Class<C>): AgentScopeBuilder<C>

andThenDo

infix inline fun <A, B, C> (A) -> B.andThenDo(crossinline that: (InputActionContext) -> C): AgentScopeBuilder<C>

biAggregate

inline fun <A1, A2, B : Any, C> biAggregate(transforms: List<(context: BiInputActionContext<A1, A2>) -> B>, noinline merge: (list: List) -> C): AgentScopeBuilder<C>

fun <A1, A2, B : Any, C> biAggregate(transforms: List<(context: BiInputActionContext<A1, A2>) -> B>, merge: (list: List) -> C, a1Class: Class<A1>, a2Class: Class<A2>, bClass: Class, cClass: Class<C>): AgentScopeBuilder<C>

Aggregate taking 2 inputs

branch

inline fun <A, B, C> branch(noinline a: (context: InputActionContext<A>) -> Branch<B, C>): AgentScopeBuilder<Branch<B, C>>

Convenience method to branch from A to B or C using Kotlin reified types.

fun <A, B, C> branch(a: (context: InputActionContext<A>) -> Branch<B, C>, aClass: Class<A>, bClass: Class, cClass: Class<C>): AgentScopeBuilder<Branch<B, C>>

Branch from A to B or C using Kotlin reified types. Makes conditionals easy to express.

chain

inline fun <A, B, C> chain(noinline a: (context: InputActionContext<A>) -> B, noinline b: (context: InputActionContext) -> C): AgentScopeBuilder<C>

Convenience method to chain A to B via C using Kotlin reified types.

fun <A, B, C> chain(a: (context: InputActionContext<A>) -> B, b: (context: InputActionContext) -> C, aClass: Class<A>, bClass: Class, cClass: Class<C>): AgentScopeBuilder<C>

Creates a chain from A to B via C. Emits actions.

doSplit

inline fun <A, B : Any> doSplit(noinline splitter: (InputActionContext<A>) -> List): AgentScopeBuilder<Unit>

fun <A, B : Any> doSplit(splitter: (InputActionContext<A>) -> List, aClass: Class<A>, bClass: Class): AgentScopeBuilder<Unit>

javaAndThen

inline fun <A, B, C> Function<InputActionContext<A>, B>.javaAndThen(that: Function<InputActionContext, C>): AgentScopeBuilder<C>

mapAsync

suspend fun <T, R> Collection<T>.mapAsync(context: OperationContext, concurrencyLevel: Int = 10, dispatcher: <Error class: unknown class> = Dispatchers.IO, transform: suspend (T) -> R): List<R>

Map async, using the agent process

parallelMap

fun <T, R> Collection<T>.parallelMap(context: OperationContext, concurrencyLevel: Int = 10, dispatcher: <Error class: unknown class> = Dispatchers.IO, transform: suspend (T) -> R): List<R>

Map parallel. Block on all results

repeat

inline fun <C> repeat(noinline what: () -> AgentScopeBuilder<C>, noinline until: (c: C, context: OperationContext) -> Boolean): AgentScopeBuilder<C>

fun <C> repeat(what: () -> AgentScopeBuilder<C>, until: (c: C, context: OperationContext) -> Boolean, cClass: Class<C>): AgentScopeBuilder<C>

repeatableAggregate

inline fun <A, B : Any, C> repeatableAggregate(startWith: C, transforms: List<(context: BiInputActionContext<A, C>) -> B>, noinline merge: (list: List) -> C): AgentScopeBuilder<C>

Special aggregate that works like an accumulator. If the condition is not satisfied, your transformer methods will be called again with the latest updated context.

runAgent

inline fun <I, O : Any> runAgent(agent: Agent, context: TransformationActionContext<I, O>): O

split

inline fun <A, B : Any> split(noinline splitter: (a: A) -> List): AgentScopeBuilder<Unit>