deep

type BackgroundConfig = TypedBackgroundConfig[*schema.Message]

type Config = TypedConfig[*schema.Message]

type DurableSubAgentConfig = TypedDurableSubAgentConfig[*schema.Message]

type LocalShellConfig struct {
	Shell          filesystem.Shell
	StreamingShell filesystem.StreamingShell
	OutputDir      string
}

type RecoverableShellConfig struct {
	Shell              backgroundshell.RecoverableShell
	OutputMaterializer backgroundtool.OutputMaterializer
}

type TODO struct {
	Content    string `json:"content"`
	ActiveForm string `json:"activeForm"`
	Status     string `json:"status" jsonschema:"enum=pending,enum=in_progress,enum=completed"`
}

type TypedBackgroundConfig[M adk.MessageType] struct {
	// Manager is the single lifecycle authority shared by every enabled capability.
	Manager *backgroundtask.Manager
	// Executors is the registry configured on Manager and shared by every capability.
	Executors *backgroundtask.ExecutorRegistry
	// SubAgents enables reconstructable sub-agent runs.
	SubAgents *TypedDurableSubAgentConfig[M]
	// RecoverableShell enables task-ID-keyed commands that workers can recover.
	RecoverableShell *RecoverableShellConfig
	// LocalShell enables managed process-local Shell or StreamingShell runs.
	LocalShell *LocalShellConfig
	// ForegroundTimeoutMs and ShouldAutoBackground apply to every enabled capability.
	ForegroundTimeoutMs  *int
	ShouldAutoBackground func(context.Context, *foreground.CandidateInfo) bool
	// TranscriptFormat customizes durable sub-agent session views.
	TranscriptFormat subagent.TranscriptFormat[M]
}

type TypedConfig[M adk.MessageType] struct {
	// Name is the identifier for the Deep agent.
	Name string
	// Description provides a brief explanation of the agent's purpose.
	Description string

	// ChatModel is the model used by DeepAgent for reasoning and task execution.
	// If the agent uses any tools, this model must support the model.WithTools call option,
	// as that's how the agent configures the model with tool information.
	ChatModel model.BaseModel[M]
	// Instruction contains the system prompt that guides the agent's behavior.
	// When empty, a built-in default system prompt will be used, which includes general assistant
	// behavior guidelines, security policies, coding style guidelines, and tool usage policies.
	Instruction string
	// SubAgents are specialized agents that can be invoked by the agent.
	// For M = *schema.AgenticMessage, only agentic sub-agents are accepted.
	SubAgents []adk.TypedAgent[M]
	// ToolsConfig provides the tools and tool-calling configurations available for the agent to invoke.
	ToolsConfig adk.ToolsConfig
	// MaxIteration limits the maximum number of reasoning iterations the agent can perform.
	MaxIteration int

	// Backend provides filesystem operations used by tools and offloading.
	// If set, filesystem tools (read_file, write_file, edit_file, glob, grep) will be registered.
	// For advanced filesystem middleware configuration, leave Backend, Shell, and StreamingShell empty
	// and pass a manually constructed filesystem middleware through Handlers.
	// Optional.
	Backend filesystem.Backend
	// Shell provides shell command execution capability.
	// If set, an execute tool will be registered to support shell command execution.
	// For advanced filesystem middleware configuration, leave Backend, Shell, and StreamingShell empty
	// and pass a manually constructed filesystem middleware through Handlers.
	// Optional. Mutually exclusive with StreamingShell and Background.LocalShell.
	Shell filesystem.Shell
	// StreamingShell provides streaming shell command execution capability.
	// If set, a streaming execute tool will be registered to support streaming shell command execution.
	// For advanced filesystem middleware configuration, leave Backend, Shell, and StreamingShell empty
	// and pass a manually constructed filesystem middleware through Handlers.
	// Optional. Mutually exclusive with Shell and Background.LocalShell.
	StreamingShell filesystem.StreamingShell
	// Background configures selected background-task capabilities for the
	// top-level agent under one task-ID space, and injects task_output/task_stop
	// once. Background is intentionally NOT propagated to the general or user
	// sub-agents: their shell runs stay foreground/buffered and they cannot launch
	// background work, so background orchestration is a top-level concern only. When
	// nil, the top-level agent has no background-task support. See BackgroundConfig.
	Background *TypedBackgroundConfig[M]

	// WithoutWriteTodos disables the built-in write_todos tool when set to true.
	WithoutWriteTodos bool
	// WithoutGeneralSubAgent disables the general-purpose subagent when set to true.
	WithoutGeneralSubAgent bool
	// TaskToolDescriptionGenerator allows customizing the description for the task tool.
	// If provided, this function generates the tool description based on available subagents.
	TaskToolDescriptionGenerator func(ctx context.Context, availableAgents []adk.TypedAgent[M]) (string, error)

	Middlewares []adk.AgentMiddleware

	// Handlers configures interface-based handlers for extending agent behavior.
	// Unlike Middlewares (struct-based), Handlers allow users to:
	//   - Add custom methods to their handler implementations
	//   - Return modified context from handler methods
	//   - Centralize configuration in struct fields instead of closures
	//
	// Handlers are processed after Middlewares, in registration order.
	// See adk.ChatModelAgentMiddleware documentation for when to use Handlers vs Middlewares.
	Handlers []adk.TypedChatModelAgentMiddleware[M]

	ModelRetryConfig *adk.TypedModelRetryConfig[M]
	// ModelFailoverConfig configures failover behavior for the ChatModel.
	// When set, the agent will automatically fail over to alternative models on errors.
	// This config is also propagated to the general sub-agent.
	ModelFailoverConfig *adk.ModelFailoverConfig[M]
	// OutputKey stores the agent's response in the session.
	// Optional. When set, stores output via AddSessionValue(ctx, outputKey, msg.Content).
	OutputKey string
}

type TypedDurableSubAgentConfig[M adk.MessageType] struct {
	// Executor owns durable sub-agent session dependencies.
	Executor *durablesubagent.Executor[M]
	// RunOptionsFactories reconstructs deployment-owned options on every worker
	// attempt and is forwarded to the durable sub-agent middleware. Equivalent
	// configuration must remain available for the full lifetime of resumable tasks.
	RunOptionsFactories map[string]durablesubagent.RunOptionsFactory
}