agentcore

type ActStage struct {
	Executor *tools.Executor
}

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

type ApprovalStage struct {
	Approver ToolApprover
}

type Budget struct {
	MaxInputTokens  int
	MaxOutputTokens int
	MaxTotalTokens  int
}

type BudgetDecision struct {
	Allowed bool
	Reason  string
}

type BudgetGuard interface {
	Check(ctx context.Context, state *RunState) BudgetDecision
}

type BudgetStage struct {
	Guard BudgetGuard
}

type CheckpointRequest struct {
	Input              string              `json:"input"`
	UserID             string              `json:"user_id,omitempty"`
	SessionID          string              `json:"session_id,omitempty"`
	Metadata           map[string]any      `json:"metadata,omitempty"`
	AllowedPermissions []policy.Permission `json:"allowed_permissions,omitempty"`
	PolicyContext      ports.PolicyContext `json:"policy_context"`
}

type ContextProjectionRequest struct {
	Messages []Message
	Budget   Budget
	Metadata map[string]any
}

type ContextProjectionResult struct {
	Messages []Message
	Metadata map[string]any
}

type ContextProjectionStage struct {
	Projector ContextProjector
	Budget    Budget
}

type ContextProjector interface {
	Project(ctx context.Context, req ContextProjectionRequest) (*ContextProjectionResult, error)
}

type ContextStage struct{}

type Event struct {
	RunID     RunID
	Type      EventType
	Stage     string
	Iteration int
	Message   string
	Metadata  map[string]any
}

type EventSink interface {
	Emit(ctx context.Context, event Event) error
}

type EventType string

type ExecutionSummary struct {
	LLMCalls    int
	ToolCalls   int
	UsedTools   []string
	Duration    time.Duration
	AbortReason string
}

type FinalizeStage struct {
	OutputFormat    OutputFormat
	OutputValidator OutputValidator
}

type InputGuard interface {
	ValidateInput(context.Context, InputGuardRequest) error
}

type InputGuardFunc func(context.Context, InputGuardRequest) error

type InputGuardRequest struct {
	RunID         RunID
	Input         string
	Metadata      map[string]any
	PolicyContext ports.PolicyContext
}

type InputGuardStage struct {
	Guard InputGuard
}

type MemoryLoadStage struct {
	Provider ports.MemoryProvider
}

type Message struct {
	Role       string
	Content    string
	ToolCallID string
	ToolCalls  []ports.ToolCall
}

type ModelDelta struct {
	Iteration int
	Content   string
}

type Module interface {
	SystemPromptProvider
	SkillProvider
	ToolProvider
}

type MutableToolRegistry interface {
	ports.ToolRegistry
	Register(tool tools.Tool)
}

type ObserveStage struct{}

type Option func(*Agent)

type OutputFormat struct {
	Name         string
	Description  string
	Instructions string
	JSONSchema   json.RawMessage
}

type OutputFormatStage struct {
	Format OutputFormat
}

type OutputValidationRequest struct {
	RunID    RunID
	Content  string
	Format   OutputFormat
	Metadata map[string]any
}

type OutputValidationResult struct {
	Structured json.RawMessage
	Metadata   map[string]any
}

type OutputValidator interface {
	ValidateOutput(context.Context, OutputValidationRequest) (*OutputValidationResult, error)
}

type OutputValidatorFunc func(context.Context, OutputValidationRequest) (*OutputValidationResult, error)

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

type PolicyStage struct {
	Engine       ports.PolicyEngine
	ToolRegistry ports.ToolRegistry
}

type PromptStage struct {
	Compiler ports.PromptCompiler
	Blocks   []prompt.Block
}

type ReActConfig struct {
	LLM                  ports.LLMClient
	PromptCompiler       ports.PromptCompiler
	PromptBlocks         []prompt.Block
	ToolRegistry         MutableToolRegistry
	PolicyEngine         ports.PolicyEngine
	MemoryProvider       ports.MemoryProvider
	SkillProvider        SkillProvider
	SystemPromptProvider SystemPromptProvider
	ToolProvider         ToolProvider
	ContextProjector     ContextProjector
	InputGuard           InputGuard
	ToolApprover         ToolApprover
	OutputFormat         OutputFormat
	OutputValidator      OutputValidator
	BudgetGuard          BudgetGuard
	MaxIterations        int
	// MaxOutputTokens caps generated tokens per model call; zero leaves it to the provider.
	MaxOutputTokens int
}

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

type ResolvedApprovalStage struct {
	Resolutions []ToolApprovalResolution
}

type RunCheckpoint struct {
	Version            int                 `json:"version"`
	RunID              string              `json:"run_id"`
	Request            CheckpointRequest   `json:"request"`
	Iteration          int                 `json:"iteration"`
	Messages           []Message           `json:"messages"`
	Usage              Usage               `json:"usage"`
	LLMCalls           int                 `json:"llm_calls"`
	ToolCalls          int                 `json:"tool_calls"`
	UsedTools          []string            `json:"used_tools,omitempty"`
	StartedAt          time.Time           `json:"started_at"`
	Metadata           map[string]any      `json:"metadata"`
	AllowedPermissions []policy.Permission `json:"allowed_permissions"`
	PendingCalls       []ports.ToolCall    `json:"pending_calls"`
	PromptBlocks       []prompt.Block      `json:"prompt_blocks"`
}

type RunID uuid.UUID

type RunRequest struct {
	RunID              RunID
	Input              string
	UserID             string
	SessionID          string
	Metadata           map[string]any
	AllowedPermissions []policy.Permission
	PolicyContext      ports.PolicyContext
}

type RunResult struct {
	RunID            RunID
	Content          string
	StructuredOutput json.RawMessage
	OutputMetadata   map[string]any
	Usage            Usage
	ExecutionSummary ExecutionSummary
	Interruption     *ToolApprovalInterruption
}

type RunState struct {
	RunID     RunID
	Input     RunRequest
	Iteration int
	Messages  []Message
	Final     *RunResult
	Usage     Usage
	Metadata  map[string]any
	EventSink EventSink

	PromptBlocks       []prompt.Block
	CompiledPrompt     *prompt.Compiled
	ContextProjection  *ContextProjectionResult
	LastResponse       *ports.ChatResponse
	PendingCalls       []tools.Call
	ToolResults        []tools.Execution
	AllowedPermissions []policy.Permission
	// contains filtered or unexported fields
}

type RunStream struct {
	Events <-chan RunStreamEvent
	// contains filtered or unexported fields
}

type RunStreamEvent struct {
	Event  Event
	Delta  *ModelDelta
	Result *RunResult
	Error  error
	Done   bool
}

type Skill struct {
	Name        string
	Description string
	Content     string
	Priority    int
	Cacheable   bool
}

type SkillProvider interface {
	Skills(ctx context.Context, req RunRequest) ([]Skill, error)
}

type SkillStage struct {
	Provider SkillProvider
}

type Stage interface {
	Name() string
	Run(ctx context.Context, state *RunState) (StageResult, error)
}

type StageResult int

type SystemPromptProvider interface {
	SystemPrompt(ctx context.Context, req RunRequest) ([]prompt.Block, error)
}

type SystemPromptStage struct {
	Provider SystemPromptProvider
}

type ThinkStage struct {
	LLM             ports.LLMClient
	ToolRegistry    ports.ToolRegistry
	MaxOutputTokens int
}

type ToolApprovalDecision struct {
	Allowed bool
	// Pending takes precedence over Allowed so an ambiguous decision cannot execute a tool.
	Pending bool
	Reason  string
}

type ToolApprovalInterruption struct {
	Checkpoint RunCheckpoint `json:"checkpoint"`
}

type ToolApprovalRequest struct {
	RunID     RunID
	UserID    string
	SessionID string
	Tool      string
	Input     json.RawMessage
	Metadata  map[string]any
}

type ToolApprovalResolution struct {
	Index      int    `json:"index"`
	ToolCallID string `json:"tool_call_id"`
	Tool       string `json:"tool"`
	Allowed    bool   `json:"allowed"`
	Reason     string `json:"reason,omitempty"`
}

type ToolApprover interface {
	ApproveTool(ctx context.Context, req ToolApprovalRequest) ToolApprovalDecision
}

type ToolProvider interface {
	Tools(ctx context.Context, req RunRequest) ([]tools.Tool, error)
}

type ToolProviderStage struct {
	Provider ToolProvider
	Registry interface {
		Register(tool tools.Tool)
	}
}

type Usage struct {
	InputTokens  int
	OutputTokens int
}