steploop

type BackScanResult struct {
	LastUser      *msgmodel.User
	LastAssistant *msgmodel.Assistant
	LastFinished  *msgmodel.Assistant
	Tasks         []msgmodel.Part
}

type LLMClient interface {
	Stream(ctx context.Context, params orclient.RequestParams) (PartStream, error)
}

type Loop struct {
	Store    Store
	Client   LLMClient
	Models   ModelResolver
	Executor ToolExecutor
	Tasks    TaskController

	// ProcessorWaitTimeout bounds the tool drain after an aborted stream.
	// Zero means 250ms.
	ProcessorWaitTimeout time.Duration
}

type Model struct {
	Message msgmodel.Model
	Calc    calc.Model
	Request orclient.RequestParams
}

type ModelResolver interface {
	Resolve(ctx context.Context, user msgmodel.User) (Model, error)
}

type ModelResolverFunc func(context.Context, msgmodel.User) (Model, error)

type PartStream interface {
	Next() (orclient.StreamPart, error)
	Close() error
}

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

type ProcessorOptions struct {
	Store       Store
	Assistant   msgmodel.Assistant
	Model       Model
	Tools       []ToolDefinition
	Executor    ToolExecutor
	WaitTimeout time.Duration
}

type Result string

type RunOptions struct {
	SessionID string
	ParentID  string
	Workspace string
	Worktree  string

	// MaxSteps is agent.steps. Nil means Infinity.
	MaxSteps *float64
	Tools    []ToolDefinition

	// InjectReminders may add in-memory-only reminder parts to the prompt
	// before each request. It must return fresh values.
	InjectReminders func(context.Context, []msgmodel.WithParts, msgmodel.User) ([]msgmodel.WithParts, error)

	// AfterAssistant runs after each processor turn, including stop and
	// error turns, with the assistant message ID; the instruction tracker
	// uses it to release the claims made for that message.
	AfterAssistant func(context.Context, string)

	// AfterTurn observes a fully persisted assistant turn and may stop the loop
	// before another provider call.
	AfterTurn func(context.Context, msgmodel.Assistant, msgmodel.Parts) error
}

type SliceStream struct {
	Parts   []orclient.StreamPart
	Failure error
	// contains filtered or unexported fields
}

type Store interface {
	Messages(ctx context.Context, sessionID string) ([]msgmodel.WithParts, error)
	UpdateMessage(ctx context.Context, info msgmodel.Info) error
	UpdatePart(ctx context.Context, part msgmodel.Part) error
}

type TaskController interface {
	ProcessCompaction(ctx context.Context, input TaskInput, task msgmodel.CompactionPart) (Result, error)
	IsOverflow(ctx context.Context, assistant msgmodel.Assistant, model Model) (bool, error)
	CreateCompaction(ctx context.Context, sessionID string, user msgmodel.User, overflow bool) error
	Prune(ctx context.Context, sessionID string) error
}

type TaskInput struct {
	SessionID string
	Messages  []msgmodel.WithParts
	User      msgmodel.User
	Model     Model
}

type ToolCall struct {
	ID        string          `json:"id"`
	Name      string          `json:"name"`
	Input     json.RawMessage `json:"input"`
	SessionID string          `json:"sessionID"`
	MessageID string          `json:"messageID"`
	Agent     string          `json:"agent,omitempty"`
	ModelID   string          `json:"modelID,omitempty"`
}

type ToolDefinition struct {
	Provider      orclient.Tool
	Validate      func(input json.RawMessage) error
	WaitForResult bool
}

type ToolExecutor interface {
	Execute(ctx context.Context, call ToolCall) (ToolResult, error)
}

type ToolResult struct {
	Title       string
	Metadata    msgmodel.RawObject
	Output      string
	Attachments *[]msgmodel.FilePart
}