agent

type BacktrackConfig struct {
	Enabled           bool // Enable backtrack mode
	MaxRetries        int  // Max retries at same history point (default: 5)
	InjectUserMessage bool // On limit reached: backtrack + inject user message instead of error-in-history
}

type BacktrackEvent struct {
	ToolName string
	Reason   string
}

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

type DiscardedStats struct {
	TotalPromptTokens     int
	TotalCompletionTokens int
	TotalCost             float64
	DiscardCount          int
}

type Episode struct {
	Trigger       string // one of the Trigger* constants
	Key           string // dedup key - interrogation fires once per episode
	TriggerCount  int    // e.g. how many consecutive identical calls
	OffendingTool string
	OffendingArgs string // raw JSON arguments of the offending call
	PriorResult   string // the previous tool result the model saw
	PendingDiff   string // for pending-edit triggers: the pending diff
	Turn          int
	ContextTokens int
}

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

type LLMClient interface {
	Chat(context.Context, llm.ChatRequest) (*llm.ChatResponse, error)
	GetGenerationStats(context.Context, string) (*llm.GenerationStats, error)
}

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

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

type LoopInfo struct {
	ToolName  string
	Count     int
	IsError   bool // All calls in the loop were errors
	IsSuccess bool // All calls in the loop were successes (still a loop!)
}

type RunConfig struct {
	Messages  []llm.Message
	QuietMode bool
}

type RunResult struct {
	Stats         *stats.AgentStats
	FinalMessages []llm.Message
	Cancelled     bool
	// TimedOut is set when the loop stopped because the context passed to Run
	// hit its deadline, as opposed to being cancelled by the user. Callers that
	// impose a time budget (the thinkbench executor) use it to report the
	// budget rather than the bare "context deadline exceeded".
	TimedOut bool
	// BudgetExhausted is set when the loop ran out of iterations
	// (agent.max_tool_iterations) while the model still wanted to keep going.
	// The run produced no final answer, and without this the caller could not
	// tell that apart from a model that simply finished.
	BudgetExhausted bool
	// Failure is what ended the turn without an answer: a model call that
	// could not be retried into working, or a response with nothing usable in
	// it. It has already been reported to the user by the time Run returns;
	// it is here so the caller can set the process's exit status from it.
	Failure error
}

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

type RunnerOptions struct {
	Cfg       *config.Config
	LLMClient LLMClient
	Registry  *tools.Registry
	Writer    *ui.Writer
	Logger    *Logger
	ToolCtx   *tools.ToolContext
	// Inbox is where anything that arrives mid-turn waits: a line typed at
	// the terminal, a file dropped by "kvit-coder steer", a background
	// process exiting. The loop drains it once per iteration. Optional.
	Inbox *inbox.Inbox
	// Procs owns the processes that outlive a turn. The loop asks it once per
	// iteration what has happened and puts the answer in the inbox. Optional.
	Procs *procs.Registry
	// Persist, when set, is handed each message as the loop produces it, so a
	// turn's work reaches the session as it happens: a crash costs one message
	// rather than the turn, and "tail -f" on the history has something to
	// follow while the turn is still running.
	Persist func([]llm.Message) error
	// Rollback, when set, is told that the last n persisted messages were
	// discarded, which is how backtracking appears in a file that is only ever
	// appended to.
	Rollback func(n int) error
}