handlers

func DefaultAggregator ¶ added in v0.0.5

func DefaultAggregator(results []HandlerResult) (minds.ThreadContext, error)

DefaultAggregator combines results by merging contexts in order. Merging is done by starting with the first successful context and merging all subsequent successful contexts into it. If no successful contexts are found, an error is returned.

Metadata merging is done with the minds.KeepNew strategy, which overwrites existing values with new values. Messages are appended in order.

Parameters:

• results: List of handler results to aggregate.

Returns:

• A single thread context that combines all successful results.

func First ¶ added in v0.0.3

func First(name string, handlers ...minds.ThreadHandler) *firstHandler

First creates a handler that runs multiple handlers in parallel and returns on first success.

Handlers are executed concurrently and the first successful result is returned. If all handlers fail, an error containing all handler errors is returned. Processing is canceled for remaining handlers once a successful result is obtained. If no handlers are provided, the thread context is passed to the next handler.

Parameters:

• name: Identifier for this parallel handler group.
• handlers: Variadic list of handlers to execute in parallel.

Returns:

• A handler that implements parallel execution with first-success semantics.

Example:

first := handlers.First("validation",
    validateA,
    validateB,
    validateC,
)

func For ¶ added in v0.0.3

func For(name string, iterations int, handler minds.ThreadHandler, fn ForConditionFn) *looper

For creates a handler that repeats processing based on iterations and conditions.

A continuation function can optionally control the loop based on the ThreadContext and iteration count. The handler runs either until the iteration count is reached, the continuation function returns false, or infinitely if iterations is 0.

Parameters:

• name: Identifier for this loop handler.
• iterations: Number of iterations (0 for infinite).
• handler: The handler to repeat.
• fn: Optional function controlling loop continuation.

Returns:

• A handler that implements controlled repetition of processing.

Example:

loop := handlers.For("validation", 3, validateHandler, func(tc ThreadContext, i int) bool {
    return tc.ShouldContinue()
})

func Must ¶

func Must(name string, agg ResultAggregator, handlers ...minds.ThreadHandler) *mustHandler

Must returns a handler that runs multiple handlers in parallel with all-success semantics.

All handlers execute concurrently and must complete successfully. If any handler fails, remaining handlers are canceled and the first error encountered is returned. The timing of which error is returned is nondeterministic due to parallel execution.

Parameters:

• name: Identifier for this parallel handler group.
• handlers: Variadic list of handlers that must all succeed.

Returns:

• A handler that implements parallel execution with all-success semantics.

Example:

must := handlers.Must("validation",
    validateA,
    validateB,
    validateC,
)

func Policy ¶ added in v0.0.3

func Policy(llm minds.ContentGenerator, name, systemPrompt string, resultFn PolicyResultFunc) *policyValidator

Policy creates a new policy validator handler.

The handler uses an LLM to validate thread content against a given policy. A system prompt is used to guide the validation process, and the result is processed by the optional result function. If the result function is nil, the handler defaults to checking the `Valid` field of the validation result.

Parameters:

• llm: A content generator for generating validation responses.
• name: The name of the policy validator.
• systemPrompt: A prompt describing the policy validation rules.
• resultFn: (Optional) Function to process validation results.

Returns:

• A thread handler that validates thread content against a policy.

func Range ¶ added in v0.0.2

func Range(name string, handler minds.ThreadHandler, values ...interface{}) *ranger

Range creates a handler that processes a thread with a series of values.

For each value in the provided list, the handler executes with the value stored in the thread context's metadata under the key "range_value". An optional middleware handler can be used to wrap each iteration.

Parameters:

• name: Identifier for this range handler.
• handler: The handler to execute for each value.
• values: Variadic list of values to iterate over.

Returns:

• A handler that processes the thread once for each value.

Example:

range := handlers.Range("process",
    processHandler,
    "value1", "value2", "value3",
)

func Sequential ¶

func Sequential(name string, handlers ...minds.ThreadHandler) *sequential

Sequential creates a ThreadHandler that executes a series of handlers in sequence. If any handler returns an error, the sequence stops, and the error is returned. You can add handlers to the sequence after construction using AddHandler or AddHandlers. Optionally, you can specify a handler as middleware with the `Use` method.

Example:

this := DoThisHandler()
that := DoThatHandler()
llm := LLMHandler()

// Sequentially run `this` -> `llm` -> `that` handlers
seq := Sequential("example", this, llm, that)
finalThread, err := seq.HandleThread(initialThread, nil)
if err != nil {
    log.Fatalf("Error handling thread: %v", err)
}
fmt.Println("Final thread:", finalThread.Messaages.Last().Content)

func Summarize ¶ added in v0.0.4

func Summarize(provider minds.ContentGenerator, systemMsg string) *summarize

Summarize creates a handler that maintains a running summary of thread messages.

The handler prompts an LLM to generate a concise summary of all messages in the thread, focusing on key information. The summary is appended to the system message in XML tags and persists across handler invocations.

Parameters:

• provider: LLM content generator for creating summaries.
• systemMsg: Initial system message to prepend to summaries.

Returns:

• A handler that maintains thread summaries via LLM generation.

Note: The original thread context is not modified; a new context with the updated system message is created.

func Switch ¶ added in v0.0.4

func Switch(name string, defaultHandler minds.ThreadHandler, cases ...SwitchCase) *switcher

)

func WithDescription ¶

func WithDescription(description string) func(*HandlerOption)

func WithName ¶

func WithName(name string) func(*HandlerOption)

func WithPrompt ¶

func WithPrompt(prompt minds.Prompt) func(*HandlerOption)