planning

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

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

type ActionConfig struct {
	// Name is the stable lower-case qualified Action identity.
	Name string

	// Description explains what the Action is expected to accomplish.
	Description string

	// Preconditions are truths required in the source WorldState.
	Preconditions []Condition

	// Effects are truths predicted in the successor WorldState after success.
	Effects []Condition

	// Cost computes the non-negative search edge cost. Nil defaults to 1.
	Cost CostFunc
}

type ActionExecutor interface {
	// Execute attempts one selected Action against the observed WorldState. A
	// valid ActionResult is definite; a non-nil error means the external outcome
	// is unknown and must not be translated into an ordinary failed Action or
	// implicitly retried under a new identity.
	Execute(ctx context.Context, request ActionRequest) (ActionResult, error)
}

type ActionExecutorFunc func(ctx context.Context, request ActionRequest) (ActionResult, error)

type ActionRequest struct {
	// EffectID is the stable identity of the prepared Action attempt.
	EffectID agent.EffectID
	// Input is the original immutable Planning Process input.
	Input agent.Input
	// ActionName is the exact frozen Action identity.
	ActionName string
	// ActionDescription is the exact frozen model-facing Action description.
	ActionDescription string
	// WorldState is the complete observation against which the Action was selected.
	WorldState WorldState
}

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

type Attempt struct {
	// ActionName is the exact Action identity selected for this attempt.
	ActionName string `json:"action_name" jsonschema:"pattern=^[a-z][a-z0-9._-]{0\\,127}$"`
	// Status is the observed semantic outcome of this attempt.
	Status AttemptStatus `json:"status" jsonschema:"enum=succeeded,enum=failed,enum=unconfirmed"`
	// Diagnostic explains failed or unconfirmed attempts and is empty on success.
	Diagnostic string `json:"diagnostic,omitempty" jsonschema:"minLength=1,maxLength=4096"`
}

type AttemptStatus string

type ChildBindingConfig struct {
	// Action is the immutable predictive behavior delegated to a child Process.
	Action Action
	// DeploymentRef identifies the exact child behavior binding.
	DeploymentRef agent.DeploymentRef
	// Input deterministically derives child input; nil reuses Process input.
	Input ChildInputFunc
	// Budget is permanently allocated to each child attempt.
	Budget agent.Budget
	// Capabilities is the attenuated authority granted to each child attempt.
	Capabilities agent.CapabilitySet
}

type ChildInputFunc func(processInput agent.Input, worldState WorldState) (agent.Input, error)

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

type CostFunc func(source WorldState) (float64, error)

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

type DefinitionConfig struct {
	// Name is the stable qualified Definition name.
	Name string

	// Description states the managed goal-directed behavior for discovery.
	Description string

	// InputSchema is the authoritative schema for opaque task input passed to
	// Observer, ActionExecutor, and child input functions.
	InputSchema agent.Schema

	// Goal is the immutable target state.
	Goal Goal

	// Actions binds every predictive Action to exactly one execution mechanism.
	Actions []ActionBinding

	// Planner selects Actions from each newly observed WorldState.
	Planner Planner

	// MaxActionAttempts bounds external Action attempts. It must be positive.
	MaxActionAttempts uint32
}

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

type DispatcherBindingConfig struct {
	// Action is the immutable predictive behavior bound to a dispatcher target.
	Action Action
	// RequiredCapabilities is the authority required before dispatch.
	RequiredCapabilities []agent.Capability
}

type DispatcherConfig struct {
	// Observer supplies each complete WorldState observation.
	Observer Observer
	// ActionExecutors maps dispatcher-bound Action names to exact executors.
	ActionExecutors map[string]ActionExecutor
}

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

type GoalConfig struct {
	// Name is the stable lower-case qualified goal identity.
	Name string

	// Description explains the desired state to a human consumer.
	Description string

	// Conditions are the known truths the final WorldState must establish.
	Conditions []Condition
}

type ObservationRequest struct {
	// EffectID is the stable identity of the prepared observation attempt.
	EffectID agent.EffectID
	// Input is the original immutable Planning Process input.
	Input agent.Input
}

type Observer interface {
	// Observe obtains one complete immutable WorldState for the original Process
	// input. It must honor ctx and must not cause externally visible side effects,
	// because the same EffectID may be replayed after an unknown observation.
	Observe(ctx context.Context, request ObservationRequest) (WorldState, error)
}

type ObserverFunc func(ctx context.Context, request ObservationRequest) (WorldState, error)

type Outcome string

type Output struct {
	// Outcome is the Planning-owned semantic completion reason.
	Outcome Outcome `json:"outcome" jsonschema:"enum=achieved,enum=unreachable,enum=stuck"`
	// WorldState is the final complete observation.
	WorldState WorldState `json:"world_state"`
	// Attempts preserves Action-attempt order.
	Attempts []Attempt `json:"attempts"`
	// PlanningPasses counts calls to Planner.
	PlanningPasses uint32 `json:"planning_passes" jsonschema:"maximum=4294967295"`
}

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

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

type Planner interface {
	// Plan searches one immutable Problem without mutating it or performing I/O.
	// found=false with nil error is reserved for an exhausted complete search;
	// cancellation, resource limits, invalid costs, and internal failure return
	// errors. Equivalent Problems must produce an equivalent ordered Plan.
	Plan(ctx context.Context, problem Problem) (plan Plan, found bool, err error)
}

type PlannerFunc func(ctx context.Context, problem Problem) (plan Plan, found bool, err error)

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

type Truth string

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