local

type AgentLoopInput struct {
	UserPrompt       string
	ConversationID   string
	StreamingEnabled bool
	// Tools is the resolved tool list for this run.
	Tools []interfaces.Tool
	// ChannelName is the eventbus channel events are published to during this run.
	// Sub-agents receive the parent's ChannelName so their events go directly to the parent stream.
	// Empty = no event fanout.
	ChannelName string
	// EventTypes filters which events are published to ChannelName (same semantics as Temporal).
	// Empty = publish nothing; ["*"] = all types; a specific list = only those types.
	EventTypes []events.AgentEventType
	// ApprovalHandler is called when a tool requires human approval. May be nil (approval → unavailable).
	ApprovalHandler types.ApprovalHandler
	// SubAgentRoutes maps sub-agent tool name → local route. Built by the local runtime from
	// ExecuteRequest.SubAgents before executeAgentLoop is called. Mirrors AgentWorkflowInput.SubAgentRoutes.
	SubAgentRoutes map[string]subAgentRoute
	// SubAgentDepth is the current nesting depth (0 = top-level, 1 = direct sub-agent, etc.).
	SubAgentDepth int
	// MaxSubAgentDepth caps recursive delegation. Mirrors AgentWorkflowInput.MaxSubAgentDepth.
	MaxSubAgentDepth int
	// MemoryScope is resolved before the run and used for recall/store.
	MemoryScope interfaces.MemoryScope
	// RunID is the stable identifier for this agent run; passed to LLM hooks via [RunMeta].
	RunID string
	// BudgetTracker tracks per-run token and cost usage against the configured limits.
	// Nil when no budget is configured. Shared with nested subagent calls; subagent calls
	// set EnforceBudget=false so only the root run triggers OnExceeded.
	BudgetTracker *base.BudgetTracker
	// EnforceBudget controls whether the budget check runs after each LLM call.
	// True on root runs when WithBudget is configured; false on nested subagent calls
	// so the parent run's tracker accumulates child usage and enforces the limit.
	EnforceBudget bool
	// contains filtered or unexported fields
}

type AgentLoopResult struct {
	Content   string
	LLMUsage  *interfaces.LLMUsage
	Telemetry *types.AgentTelemetry
}

type LocalConfig struct {
	// Durability enables durable-go-backed execution. nil (the zero value, and the
	// implicit default when [WithLocalConfig] is never called) means true — local runtime
	// is durable by default. Set to a pointer to false (see [DurabilityOff] in
	// pkg/agent/runtime/local) to opt out and use the original pure in-memory execution path.
	Durability *bool

	// Engine, when set, is used as-is instead of constructing one from DataDir/knobs below.
	// The caller retains ownership: LocalRuntime.Close does not close a caller-supplied
	// Engine. Takes priority over every field below. Multiple agents/tasks may share one
	// Engine (see [durable.RegisterTask] — one taskID per agent name).
	Engine *durable.Engine

	// DataDir is the durable-go journal directory for an engine this runtime constructs
	// (ignored when Engine is set). Default: "./agent_data/<agent_name>" (sanitized for
	// use as a durable-go taskID), or "./agent_data/default" when the agent has no name.
	//
	// DataDir is exclusive-locked per OS process (in-process occupancy plus an OS flock) —
	// running more than one process/replica against the same DataDir will fail engine
	// construction for the second one (durable.ErrEngineLocked) or block up to LockTimeout.
	// Multi-replica deployments must set a distinct DataDir per instance (e.g. derived from
	// hostname or pod name).
	DataDir string

	// AutoPurgeAge is how long a Completed/Failed run is kept before automatic deletion.
	// Running and Waiting runs (e.g. a pending approval) are never purged regardless of age.
	// 0 uses the default (7 days). Negative disables auto-purge entirely.
	AutoPurgeAge time.Duration

	// AutoPurgeInterval is how often the purge sweep runs. 0 uses the default (1 hour).
	// Ignored when AutoPurgeAge is negative.
	AutoPurgeInterval time.Duration

	// MaxRetries is the default durable-go task retry count for this engine. 0 (default)
	// means a task body runs once; a step failure still stops task-level retries regardless
	// of this value (durable-go: step failures are not retried at the task level).
	MaxRetries int

	// Timeout bounds one run's total durable-go execution time. 0 means no timeout (the
	// durable-go default) — an un-cancelled run (or a step stuck waiting, e.g. an
	// approval nobody ever answers) can then run unbounded. Set this in production.
	Timeout time.Duration

	// LockTimeout bounds how long engine construction waits to acquire the DataDir OS
	// lock. 0 uses the durable-go default (2s).
	LockTimeout time.Duration
}

type LocalRuntime struct {
	base.Runtime
	// contains filtered or unexported fields
}

type Option func(*LocalRuntime)

type ToolsResolver func(ctx context.Context) ([]interfaces.Tool, error)