hooks

type CancelResult ¶

type CancelResult struct {
	Cancel bool
	Reason string
}

type CompactEvent ¶

type CompactEvent struct {
	SessionID     string
	Trigger       string
	ContextTokens int
	ContextWindow int
}

type ContextEvent ¶

type ContextEvent struct {
	SessionID string
	Turn      int
	Messages  []*Msg
}

type ContextResult ¶

type ContextResult struct {
	Messages []*Msg
}

ContextResult replaces the whole message list; nil means unchanged.

type ErrorPolicy ¶

type ErrorPolicy uint8

const (
	ContinueOnError ErrorPolicy = iota // collect, report, keep dispatching
	FailClosed                         // first error aborts dispatch; caller must deny
)

type HandlerError ¶

type HandlerError struct {
	Source string
	Kind   Kind
	Err    error
	Panic  any
	Stack  []byte
}

HandlerError attributes a failure to the handler that produced it. Handlers are registered with a mandatory source so a hook failure never has to be traced back by hand.

func (e *HandlerError) Error() string

func (e *HandlerError) Unwrap() error

type Kind ¶

type Kind string

type Msg ¶

type Msg = aop.Message

Aliases keep event definitions readable without pulling agent in (that would be an import cycle).

type Point ¶

type Point[E any, R any] struct {
	Kind    Kind
	Reduce  Reducer[E, R] // nil => pure observation
	OnError ErrorPolicy
}

func (p Point[E, R]) Emit(ctx context.Context, r *Registry, ev E) (R, error)

func (p Point[E, R]) On(r *Registry, source string, fn func(context.Context, E) (R, error)) (unsubscribe func())

type Reducer ¶

type Reducer[E any, R any] func(acc *R, ev *E, out R) (stop bool)

Reducer folds one handler result into the accumulated result. ev is a pointer so fold-style points can let the next handler observe the previous handler's change. Returning true short-circuits the remaining handlers.

func Fold[E any, R any](apply func(acc *R, ev *E, out R)) Reducer[E, R]

func StopWhen[E any, R any](pred func(R) bool) Reducer[E, R]

type Registry ¶

type Registry struct {
	// contains filtered or unexported fields
}

func New() *Registry

func (r *Registry) AddCleanup(fn func()) (remove func())

func (r *Registry) Clear()

func (r *Registry) Has(kind Kind) bool

func (r *Registry) Len(kind Kind) int

func (r *Registry) SetErrorSink(fn func(*HandlerError))

type RunEndEvent ¶

type RunEndEvent struct {
	SessionID      string
	TurnID         string
	Stop           StopReason
	Output         string
	Messages       []*Msg
	MessageCounter int64
	Usage          *Usage
	Err            error
}

type RunStartEvent ¶

type RunStartEvent struct {
	SessionID    string
	TurnID       string
	AgentName    string
	Model        string
	Turn         int
	SystemPrompt string
	ToolNames    []string
}

RunStartEvent carries the config context a handler needs in flattened form, since the event type cannot reference *agent.Config.

type RunStartResult ¶

type RunStartResult struct {
	SystemPrompt *string
	Prepend      []*Msg
}

RunStartResult replaces the system prompt (nil = keep) and prepends messages to the turn.

type SessionEvent ¶

type SessionEvent struct {
	SessionID string
	ParentID  string
	AgentName string
	Model     string
	Reason    string
}

type StopReason ¶

type StopReason string

StopReason lives here rather than in agent because run_end events carry it; agent aliases these back.

const (
	StopReasonCompleted  StopReason = "completed"
	StopReasonTerminated StopReason = "terminated"
	StopReasonStopped    StopReason = "stopped"
	StopReasonBudget     StopReason = "budget"
	StopReasonError      StopReason = "error"
	StopReasonCanceled   StopReason = "canceled"
)

type ToolCall ¶

type ToolCall = aop.ToolCall

Aliases keep event definitions readable without pulling agent in (that would be an import cycle).

type ToolCallEvent ¶

type ToolCallEvent struct {
	SessionID        string
	TurnID           string
	AssistantMessage *Msg
	Call             *ToolCall
	SystemPrompt     string
	Messages         []*Msg
}

type ToolCallResult ¶

type ToolCallResult struct {
	Block  bool
	Reason string
}

type ToolResultEvent ¶

type ToolResultEvent struct {
	SessionID  string
	TurnID     string
	Call       *ToolCall
	Content    string
	IsError    bool
	Terminate  bool
	DurationMs int
	Full       *tool.Result
}

type ToolResultPatch ¶

type ToolResultPatch struct {
	Content   *string
	IsError   *bool
	Terminate *bool
}

ToolResultPatch patches individual fields; nil fields are left alone.

type Usage ¶

type Usage = aop.TokenUsage

Aliases keep event definitions readable without pulling agent in (that would be an import cycle).