hooks

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

type CWDEvent struct {
	OldCWD string `json:"old_cwd"`
	NewCWD string `json:"new_cwd"`
}

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

type CommandHook struct {
	Name    string
	Event   EventName
	Command []string
	Timeout time.Duration
	Env     map[string]string
}

type Config struct {
	DefaultTimeout time.Duration
	EnvAllowlist   []string
}

type Decision struct {
	Allow  bool
	Reason string // human-readable; surfaced to the model when denied
}

type EventName string

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

type FileChangeKind string

type FileEvent struct {
	Path string         `json:"file_path"`
	Kind FileChangeKind `json:"event"`
}

type HookOutput struct {
	Decision   string            `json:"decision,omitempty"`
	Reason     string            `json:"reason,omitempty"`
	Message    string            `json:"message,omitempty"`
	Env        map[string]string `json:"env,omitempty"`
	WatchPaths []string          `json:"watch_paths,omitempty"`
}

type Invocation struct {
	Event EventName       `json:"event"`
	Input json.RawMessage `json:"input,omitempty"`
	Tool  *ToolCall       `json:"tool,omitempty"`
}

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

type Result struct {
	HookName string
	Event    EventName
	ExitCode int
	Stdout   string
	Stderr   string
	Output   HookOutput
	Blocked  bool
	Reason   string
	Skipped  bool
}

type RetryStrategy string

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

type ToolApprover interface {
	ApproveTool(ctx context.Context, call ToolCall) Decision
}

type ToolCall struct {
	CallID string
	Name   string
	Args   json.RawMessage
	Addr   protocol.MessageAddress
}

type ToolObserver interface {
	ToolStarted(ctx context.Context, call ToolCall)
	ToolFinished(ctx context.Context, call ToolCall, isError bool, err error)
}

type ToolResultObserver interface {
	ToolResult(ctx context.Context, call ToolCall, result tools.Result, err error)
}

type TurnEvent struct {
	Phase     TurnPhase
	Addr      protocol.MessageAddress
	Iteration int    // tool-loop round: 0 before the first model call
	Model     string // model in use for this step, when known
	Err       error  // set on model_call_finished / turn_finished on error
	MessageID string // stable transcript message reference, when known
	// OperationID distinguishes repeated reference/recovery events within one
	// branch. Reference points at an authority-owned record without copying it.
	OperationID string
	Reference   *tools.ResultReference

	// Attempt is the 1-based ordinal of the retry about to be made, within its
	// own strategy's budget. Set on PhaseProviderRetry.
	Attempt int
	// RetryIn is the wait the runner will observe before retrying. Zero for
	// strategies that retry immediately. Set on PhaseProviderRetry.
	RetryIn time.Duration
	// Strategy is what the runner is about to do about the failure. Set on
	// PhaseProviderRetry.
	Strategy RetryStrategy
	// FailureKind is the classified provider failure ("rate_limit",
	// "context_overflow", …), empty when the error was not a classified
	// ProviderError. Set on PhaseProviderRetry.
	FailureKind string
	// NextModel is the model the runner is switching to. Set only for
	// RetryFallbackModel.
	NextModel string
}

type TurnObserver interface {
	ObserveTurn(ctx context.Context, ev TurnEvent)
}

type TurnPhase string