composition

type DispatcherInput struct {
	// Registry is the tool registry the dispatcher registers handlers
	// against.
	Registry *tools.Registry

	MaxDepth, MaxRetries, MaxInputBytes, MaxOutputBytes int
	MaxBudget                                           int
	// Allow is the per-Kind, per-name allow map. Nil allows every
	// registered handler, the same default runtime.Policy carries today.
	Allow map[runtime.Kind]map[string]bool
	// Sink, when set, receives one runtime.Event per invocation lifecycle
	// step.
	Sink func(runtime.Event)

	// WorkspaceRoot is the directory lifecycle hooks execute in. Empty
	// means no hooks are wired at all, the same as HooksConfigured false.
	WorkspaceRoot string
	// HooksConfigured reports whether this session has any hook armed,
	// evaluated once at build time. False (or an empty WorkspaceRoot)
	// means Policy.PreInvokeHook/PostInvokeHook stay nil: one nil compare
	// per invocation, no hook overhead at all - the same contract
	// internal/cli/hooks_runner.go's hookPolicyFuncs held before this
	// move.
	HooksConfigured bool
	// HookGroups returns the runnable hook groups for the current session.
	// It is read fresh on every hook invocation rather than closed over at
	// build time, so what the caller's session state lists is what the
	// next tool call runs without a dispatcher rebuild. Required when
	// HooksConfigured is true.
	HookGroups func() []hooks.Group
	// NoteHookWarnings receives runtime diagnostics from hooks that
	// actually executed, for the caller to surface (e.g. a /hooks
	// listing). Nil is safe: warnings are simply dropped.
	NoteHookWarnings func([]string)
}

type RegistryInput struct {
	Workspace *workspace.Root

	RunAllowlist, RunAllowlistOnly, RunBlocklist, DisableTools                                   []string
	RunTimeoutSec, MaxReadBytes, MaxEditFileBytes, MaxOutputBytes, MaxWriteKB, MaxListDirEntries int

	MaxToolResultBytes                           int
	MaxTavilyResponseBytes                       int
	MaxFetchKB                                   int
	MemoryBackstopBytes                          int
	TavilyAPIKey                                 string
	EnvAllowlist, EnvAllowlistOnly, EnvBlocklist []string
	EnvAllowKeywordBlocklist                     []string
	SecretPathPatterns, SecretPathExceptions     []string

	WritePathDenylist    []string
	SearchIgnorePatterns []string

	MaxInspectRepositoryBytes int

	DiagnosticsCommands map[string][]string

	WorkflowTools []tools.Tool

	Memory memory.Store
}

type SessionInput struct {
	// Config is the resolved workspace configuration. Required:
	// chat.NewSession reads it for the model, prompt, and token budgets.
	Config *config.Resolved
	// Completer is the provider completer the session's initial binding
	// uses. May be nil (chat.NewSession accepts a nil completer for
	// construction), but a nil completer cannot run a turn.
	Completer provider.Completer

	// Registry configures the tool registry BuildRegistry builds. Its
	// Workspace field may be nil, which yields a registry with no
	// filesystem tools.
	Registry RegistryInput
	// PrebuiltRegistry, when non-nil, skips BuildRegistry(in.Registry)
	// entirely and assigns sess.Tools = in.PrebuiltRegistry directly. Use
	// this when the caller has already merged additional tools (e.g. MCP
	// wrappers via AttachMCPServers) into a registry it owns. The dispatcher's
	// view matches regardless of the path taken: dispatcher.Registry is set
	// to whatever sess.Tools ends up as.
	PrebuiltRegistry *tools.Registry
	// Dispatcher configures the dispatcher BuildDispatcher builds.
	// Dispatcher.Registry is overwritten with the registry BuildSession just
	// built, so the caller does not need to set it.
	Dispatcher DispatcherInput

	// EventBus is the session's event bus. Nil mints a fresh events.New().
	EventBus *events.Bus

	// StorePath is the SQLite file BuildSession opens for the session's
	// checkpoint store. Required: chat.Session has no durable checkpoint
	// history without one.
	StorePath string
	// WorkspaceID identifies the checkpoint principal's workspace scope.
	// Ignored when Principal is already bound.
	WorkspaceID string
	// SubjectID identifies the checkpoint principal's subject scope. Empty
	// defaults to the session's own SessionID. Ignored when Principal is
	// already bound.
	SubjectID string
	// Principal, when bound (IsBound() true), is used as-is instead of
	// minting a fresh one from WorkspaceID/SubjectID. A caller that needs to
	// read its own checkpoint back later (contextstate.Principal's capability
	// is random per mint - see contextstate.NewPrincipal - and store.Load
	// rejects a principal whose capability does not match what was written)
	// must supply the same Principal value it will read with.
	Principal contextstate.Principal
}