agentkit

package module

Go to main page

Versions in this module

v0

v0.4.2

Oct 13, 2026

Changes in this version

type GenerateResult

+ Refusal *gollem.Refusal

v0.4.1

Oct 6, 2026

Changes in this version

type GenerateResult

+ FinishReason string

v0.4.0

Sep 17, 2026

Changes in this version

type SpawnRequest

+ InheritedHistory *InheritedHistory

v0.3.3

Sep 10, 2026

Changes in this version

type ServeOption

+ func WithSettleTimeout(d time.Duration) ServeOption

v0.3.2

Aug 30, 2026

Changes in this version

type GenerateResult

+ Model string

v0.3.1

Aug 25, 2026

v0.3.0

Aug 17, 2026

Changes in this version

type ServeOption

+ func WithMaxCancelDeferrals(n int) ServeOption

v0.2.0

Aug 6, 2026

Changes in this version

type GenerateResult

+ CacheCreationInputTokens int

+ CacheReadInputTokens int

type Metrics

+ CacheCreationInputTokens int64

+ CacheReadInputTokens int64

v0.1.0

Aug 3, 2026

Changes in this version

+ var ErrAwaitClosed = goerr.New("await closed")

+ var ErrAwaitNotFound = goerr.New("await not found")

+ var ErrConflict = goerr.New("conflict")

+ var ErrEventNotFound = goerr.New("event not found")

+ var ErrHistoryNotConfigured = goerr.New("history store not configured")

+ var ErrHistoryVersionMissing = goerr.New("history version missing")

+ var ErrInvalidAgentDef = goerr.New("invalid agent definition")

+ var ErrInvalidConfig = goerr.New("invalid config")

+ var ErrInvalidRequest = goerr.New("invalid request")

+ var ErrLimitExceeded = goerr.New("limit exceeded")

+ var ErrProcessFinished = goerr.New("process finished")

+ var ErrProcessNotFound = goerr.New("process not found")

+ var ErrRepositoryIndeterminate = goerr.New("repository indeterminate")

+ var ErrServeActive = goerr.New("serve already active")

+ var ErrSubjectBusy = goerr.New("subject busy")

+ var ErrSuspendWithoutAwait = goerr.New("suspend without await")

+ var ErrToolNotFound = goerr.New("tool not found")

+ var ErrUnknownAgent = goerr.New("unknown agent")

+ func InitInput[I any](req *InitRequest) (I, bool)

+ func InitState[S any](res *InitResult) (S, bool)

+ func ResultState[S any](res *StepResult) (S, bool)

+ func SpawnInput[I any](req *SpawnRequest) (I, bool)

+ func StepState[S any](req *StepRequest) (S, bool)

+ type Agent struct

+ func Register[S, I, O any](r *Registry, name AgentName, version int, s Strategy[S, I, O], ...) (Agent[I], error)

+ func (a Agent[I]) Name() AgentName

+ func (a Agent[I]) Spawn(ctx context.Context, k *Kernel, input I, opts ...SpawnOption) (ProcessID, error)

+ func (a Agent[I]) SpawnChild(ctx context.Context, sys Syscalls, input I, opts ...SpawnOption) (ProcessID, error)

+ type AgentName string

+ type AttemptInfo struct

+ Errors int

+ UncleanReclaims int

+ func (a AttemptInfo) IsReplay() bool

+ type Await struct

+ Children []ProcessID

+ CreatedAt time.Time

+ Deadline *time.Time

+ Fired bool

+ Key AwaitKey

+ Kind AwaitKind

+ ProcessID ProcessID

+ Question []byte

+ RespondedAt *time.Time

+ RespondedBy string

+ Response []byte

+ Results []ChildResult

+ Status AwaitStatus

+ type AwaitKey string

+ type AwaitKind string

+ const AwaitChildren

+ const AwaitQuestion

+ const AwaitTimer

+ type AwaitOption func(*awaitConfig)

+ func WithDeadline(t time.Time) AwaitOption

+ type AwaitSpec struct

+ func Question(key AwaitKey, payload []byte, opts ...AwaitOption) AwaitSpec

+ func Timer(key AwaitKey, until time.Time) AwaitSpec

+ func WaitChildren(key AwaitKey, children ...ProcessID) AwaitSpec

+ type AwaitStatus string

+ const AwaitCancelled

+ const AwaitExpired

+ const AwaitOpen

+ const AwaitResponded

+ type ChangeSet struct

+ Awaits []*Await

+ Events []*Event

+ Guards []ProcessGuard

+ Processes []*Process

+ type ChildResult struct

+ Failure *Failure

+ Metrics Metrics

+ Output []byte

+ ProcessID ProcessID

+ Status ProcessStatus

+ type ClaimHandler func(ctx context.Context, req *ClaimRequest) (ClaimOutcome, error)

+ type ClaimMiddleware func(next ClaimHandler) ClaimHandler

+ type ClaimOutcome string

+ const ClaimAbandoned

+ const ClaimFinished

+ const ClaimRefused

+ const ClaimReleased

+ const ClaimRequeued

+ const ClaimSuspended

+ type ClaimRequest struct

+ Process *Process

+ type Decision struct

+ func Continue[O any]() Decision[O]

+ func Done[O any](output O) Decision[O]

+ func Fail[O any](code FailureCode, message string) Decision[O]

+ func ResultDecision[O any](res *StepResult) (Decision[O], bool)

+ func Suspend[O any](specs ...AwaitSpec) Decision[O]

+ type DecisionKind string

+ const DecisionContinue

+ const DecisionDone

+ const DecisionFail

+ const DecisionSuspend

+ func DecisionKindOf(res *StepResult) DecisionKind

+ type EffectContext struct

+ Agent AgentName

+ Attempt AttemptInfo

+ Limit LimitDecision

+ Metadata map[string]string

+ ProcessID ProcessID

+ RootID ProcessID

+ StateSeq int

+ type Event struct

+ At time.Time

+ ID EventID

+ Key AwaitKey

+ Payload []byte

+ ProcessID ProcessID

+ Type EventType

+ type EventID string

+ type EventQuery struct

+ After EventID

+ Limit int

+ type EventType string

+ const EventAwaitCreated

+ const EventProcessCreated

+ const EventProcessFinished

+ type Failure struct

+ Code FailureCode

+ Message string

+ type FailureCode string

+ const FailureLimitExceeded

+ const FailureRetryExhausted

+ const FailureStrategyError

+ const FailureUncleanReclaim

+ type FinishHandler func(ctx context.Context, pid ProcessID, res FinishResult[O]) error

+ type FinishResult struct

+ Failure *Failure

+ Output *O

+ Status ProcessStatus

+ type GenerateHandler func(ctx context.Context, req *GenerateRequest) (*GenerateResult, error)

+ type GenerateMiddleware func(next GenerateHandler) GenerateHandler

+ type GenerateOption func(*GenerateRequest)

+ func WithHistory(h *gollem.History) GenerateOption

+ func WithLLMOptions(o ...gollem.GenerateOption) GenerateOption

+ func WithLLMSessionOptions(o ...gollem.SessionOption) GenerateOption

+ func WithRole(r ModelRole) GenerateOption

+ func WithSchema(p *gollem.Parameter) GenerateOption

+ func WithSystemPrompt(p string) GenerateOption

+ func WithTools(tools ...gollem.Tool) GenerateOption

+ type GenerateRequest struct

+ Effect EffectContext

+ History *gollem.History

+ Input []gollem.Input

+ LLMOptions []gollem.GenerateOption

+ LLMSessionOptions []gollem.SessionOption

+ Role ModelRole

+ Schema *gollem.Parameter

+ SystemPrompt string

+ Tools []gollem.Tool

+ type GenerateResult struct

+ FunctionCalls []*gollem.FunctionCall

+ History *gollem.History

+ InputTokens int

+ OutputTokens int

+ Texts []string

+ Thoughts []string

+ type HistoryRef string

+ type HistoryStore interface

+ Discard func(ctx context.Context, pid ProcessID, ref HistoryRef)

+ Load func(ctx context.Context, pid ProcessID, ref HistoryRef) (*gollem.History, error)

+ Save func(ctx context.Context, pid ProcessID, h *gollem.History) (HistoryRef, error)

+ type InheritedHistory struct

+ Process ProcessID

+ Ref HistoryRef

+ type InitHandler func(ctx context.Context, req *InitRequest) (*InitResult, error)

+ type InitMiddleware func(next InitHandler) InitHandler

+ type InitRequest struct

+ Agent AgentName

+ Parent *EffectContext

+ ProcessID ProcessID

+ func NewInitRequest[I any](req *InitRequest, input I) *InitRequest

+ type InitResult struct

+ func NewInitResult[S any](state S) *InitResult

+ type Kernel struct

+ func New(repo Repository, model gollem.LLMClient, agents *Registry, ...) (*Kernel, error)

+ func (k *Kernel) Cancel(ctx context.Context, pid ProcessID, reason string) error

+ func (k *Kernel) GetProcess(ctx context.Context, pid ProcessID) (*Process, error)

+ func (k *Kernel) ListAwaits(ctx context.Context, pid ProcessID) ([]*Await, error)

+ func (k *Kernel) ListEvents(ctx context.Context, pid ProcessID, opts ...ListEventsOption) ([]*Event, error)

+ func (k *Kernel) Respond(ctx context.Context, pid ProcessID, key AwaitKey, response []byte, ...) error

+ func (k *Kernel) Serve(ctx context.Context, opts ...ServeOption) error

+ type KernelOption func(*kernelConfig)

+ func WithClaimMiddleware(mw ...ClaimMiddleware) KernelOption

+ func WithClock(fn func() time.Time) KernelOption

+ func WithGenerateMiddleware(mw ...GenerateMiddleware) KernelOption

+ func WithInitMiddleware(mw ...InitMiddleware) KernelOption

+ func WithLogger(l *slog.Logger) KernelOption

+ func WithModelRole(role ModelRole, client gollem.LLMClient) KernelOption

+ func WithSpawnMiddleware(mw ...SpawnMiddleware) KernelOption

+ func WithStepMiddleware(mw ...StepMiddleware) KernelOption

+ func WithToolCallMiddleware(mw ...ToolCallMiddleware) KernelOption

+ func WithToolFactory(f ToolFactory) KernelOption

+ type LimitDecision struct

+ func LimitNotice(msg string) LimitDecision

+ func LimitPass() LimitDecision

+ func LimitStop(reason string) LimitDecision

+ func (d LimitDecision) Kind() LimitKind

+ func (d LimitDecision) Message() string

+ type LimitKind string

+ const LimitKindNotice

+ const LimitKindPass

+ const LimitKindStop

+ type Limiter func(ctx context.Context, proc *Process, metrics Metrics) LimitDecision

+ type ListEventsOption func(*EventQuery)

+ func WithAfterEvent(id EventID) ListEventsOption

+ func WithEventLimit(n int) ListEventsOption

+ type Metrics struct

+ InputTokens int64

+ LLMCalls int64

+ OutputTokens int64

+ Spawns int64

+ Steps int64

+ ToolCalls int64

+ type ModelRole interface

+ String func() string

+ func DefineModelRole(name string) ModelRole

+ type Process struct

+ Agent AgentName

+ CancelReason string

+ CancelRequested bool

+ CreatedAt time.Time

+ Failure *Failure

+ HistoryRef HistoryRef

+ ID ProcessID

+ IdempotencyKey string

+ InheritedHistory *InheritedHistory

+ LeaseOwner string

+ LeaseToken string

+ LeaseUntil *time.Time

+ Metadata map[string]string

+ Metrics Metrics

+ Output []byte

+ ParentID *ProcessID

+ Rev int64

+ RootID ProcessID

+ State []byte

+ StateSeq int

+ StateVersion int

+ Status ProcessStatus

+ StepAttempts int

+ Subject *SubjectRef

+ UncleanReclaims int

+ UpdatedAt time.Time

+ WakeAt *time.Time

+ type ProcessGuard struct

+ ProcessID ProcessID

+ Rev int64

+ type ProcessID string

+ type ProcessStatus string

+ const ProcessCancelled

+ const ProcessFailed

+ const ProcessPending

+ const ProcessRunning

+ const ProcessSucceeded

+ const ProcessWaiting

+ func (s ProcessStatus) Terminal() bool

+ type RegisterOption func(*registerConfig[O])

+ func WithHistoryStore[O any](hs HistoryStore) RegisterOption[O]

+ func WithOnFinish[O any](h FinishHandler[O]) RegisterOption[O]

+ type Registry struct

+ func NewRegistry() *Registry

+ type Repository interface

+ Apply func(ctx context.Context, cs ChangeSet) error

+ ClaimNextProcess func(ctx context.Context, workerID string, leaseUntil time.Time, now time.Time) (*Process, error)

+ FindOpenProcessBySubject func(ctx context.Context, subject SubjectRef) (*Process, error)

+ FindProcessByIdempotencyKey func(ctx context.Context, key string) (*Process, error)

+ GetProcess func(ctx context.Context, pid ProcessID) (*Process, error)

+ ListAwaits func(ctx context.Context, pid ProcessID) ([]*Await, error)

+ ListEvents func(ctx context.Context, pid ProcessID, q EventQuery) ([]*Event, error)

+ type RespondOption func(*respondConfig)

+ func WithRespondedBy(id string) RespondOption

+ type RetryBackoff func(attempts int) time.Duration

+ type ServeOption func(*serveConfig)

+ func WithLease(d time.Duration) ServeOption

+ func WithMaxConcurrent(n int) ServeOption

+ func WithMaxStepAttempts(n int) ServeOption

+ func WithMaxStepsPerClaim(n int) ServeOption

+ func WithMaxUncleanReclaims(n int) ServeOption

+ func WithPollConcurrency(n int) ServeOption

+ func WithPollInterval(d time.Duration) ServeOption

+ func WithRetryBackoff(fn RetryBackoff) ServeOption

+ func WithWorkerID(id string) ServeOption

+ type Session interface

+ CallTool func(ctx context.Context, call gollem.FunctionCall) (map[string]any, error)

+ Generate func(ctx context.Context, input []gollem.Input, opts ...GenerateOption) (*GenerateResult, error)

+ History func(ctx context.Context) (*gollem.History, error)

+ type SpawnHandler func(ctx context.Context, req *SpawnRequest) (ProcessID, error)

+ type SpawnMiddleware func(next SpawnHandler) SpawnHandler

+ type SpawnOption func(*spawnConfig)

+ func WithIdempotencyKey(key string) SpawnOption

+ func WithInheritedHistory(from ProcessID) SpawnOption

+ func WithMetadata(m map[string]string) SpawnOption

+ func WithSubject(ref SubjectRef) SpawnOption

+ type SpawnRequest struct

+ Agent AgentName

+ Effect EffectContext

+ Metadata map[string]string

+ OnCommit func(fn func(err error))

+ Subject *SubjectRef

+ func NewSpawnRequest[I any](req *SpawnRequest, input I) *SpawnRequest

+ type StepHandler func(ctx context.Context, req *StepRequest) (*StepResult, error)

+ type StepMiddleware func(next StepHandler) StepHandler

+ type StepRequest struct

+ Effect EffectContext

+ Process *Process

+ Sys Syscalls

+ func NewStepRequest[S any](req *StepRequest, state S) *StepRequest

+ type StepResult struct

+ func NewStepResult[S, O any](state S, dec Decision[O]) *StepResult

+ type Strategy interface

+ DecodeState func(version int, raw []byte) (S, error)

+ EncodeOutput func(out O) ([]byte, error)

+ EncodeState func(state S) ([]byte, error)

+ Init func(input I) (S, error)

+ Limit func(ctx context.Context, proc *Process, metrics Metrics) LimitDecision

+ Step func(ctx context.Context, sys Syscalls, state S) (S, Decision[O], error)

+ Version func() int

+ type StrategyBinding struct

+ func BindStrategy[S, I, O any](s Strategy[S, I, O], opts ...RegisterOption[O]) StrategyBinding

+ type SubjectRef struct

+ ID string

+ Kind string

+ type Syscalls interface

+ Agent func() AgentName

+ Attempt func() AttemptInfo

+ Await func(key AwaitKey) (*Await, bool)

+ CallTool func(ctx context.Context, call gollem.FunctionCall) (map[string]any, error)

+ Emit func(ctx context.Context, typ EventType, payload []byte) error

+ Generate func(ctx context.Context, input []gollem.Input, opts ...GenerateOption) (*GenerateResult, error)

+ LimitStatus func() LimitDecision

+ Metadata func() map[string]string

+ Metrics func() Metrics

+ Now func() time.Time

+ ParentID func() (ProcessID, bool)

+ ProcessID func() ProcessID

+ RootID func() ProcessID

+ Session func() Session

+ Tools func() []gollem.Tool

+ type ToolCallHandler func(ctx context.Context, req *ToolCallRequest) (map[string]any, error)

+ type ToolCallMiddleware func(next ToolCallHandler) ToolCallHandler

+ type ToolCallRequest struct

+ Call gollem.FunctionCall

+ Effect EffectContext

+ type ToolFactory func(ctx context.Context, proc *Process) ([]gollem.Tool, error)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL