nemo_gym.core.outcome_policy

Shared configurable outcome selection; each boundary executes its own actions.

Module Contents

Classes

Name	Description
`OutcomeAction`	Action selected for one boundary decision.
`OutcomeDecision`	One policy decision for scoring and health consumers to preserve together.
`OutcomePolicyConfig`	Select an action from explicit failure evidence; partial overrides retain boundary defaults.
`StageOutcomePolicyConfig`	Shared episode policies selected by the failure’s originating stage.
`StagePolicyConfig`	Action rules for one stage; classification is configured independently.

Functions

Name	Description
`_default_stage_policies`	-
`_require_registered_kinds`	-
`choose_action`	Select by status, kind, class, then default; execution belongs to the boundary.
`choose_stage_outcome`	Select one decision from established context, without examining causes or SDK details.
`failure_outcome_policy`	Adapt only this event’s evidence, without searching its causal chain.
`is_policy_counted_zero`	Consume a saved explicit-zero decision, independently of completion or diagnostic evidence.

API

class nemo_gym.core.outcome_policy.OutcomeAction

Bases: enum.Enum

Action selected for one boundary decision.

Each boundary restricts supported actions and enforces their prerequisites.

COUNT_AS_ZERO

= 'count_as_zero'

FAIL

= 'fail'

RETRY

= 'retry'

VERIFY

= 'verify'

class nemo_gym.core.outcome_policy.OutcomeDecision()

Bases: BaseModel

One policy decision for scoring and health consumers to preserve together.

action

OutcomeAction

attribution

FailureClass

model_config

= ConfigDict(extra='forbid', frozen=True)

class nemo_gym.core.outcome_policy.OutcomePolicyConfig()

Bases: BaseModel

Select an action from explicit failure evidence; partial overrides retain boundary defaults.

by_failure_class

dict[FailureClass, OutcomeAction] = Field(default_factory=dict)

by_failure_kind

dict[str, OutcomeAction] = Field(default_factory=dict)

by_status_code

dict[Annotated[int, Field(ge=400, le=599)], OutcomeAction] = Field(default_factory=dict)

default_action

OutcomeAction

model_config

= ConfigDict(extra='forbid')

supported_actions

frozenset[OutcomeAction] = frozenset(OutcomeAction)

nemo_gym.core.outcome_policy.OutcomePolicyConfig.merge_default_rules(
    value: dict[str | int, nemo_gym.core.outcome_policy.OutcomeAction],
    info: pydantic.ValidationInfo
) -> dict[str | int, nemo_gym.core.outcome_policy.OutcomeAction]

classmethod

Merge validated overrides so JSON status keys are normalized before replacing defaults.

nemo_gym.core.outcome_policy.OutcomePolicyConfig.require_registered_kinds(
    value: dict[str, nemo_gym.core.outcome_policy.OutcomeAction]
) -> dict[str, nemo_gym.core.outcome_policy.OutcomeAction]

classmethod

Reject misspelled failure names at configuration load, before starting an evaluation.

nemo_gym.core.outcome_policy.OutcomePolicyConfig.require_supported_actions() -> nemo_gym.core.outcome_policy.OutcomePolicyConfig

class nemo_gym.core.outcome_policy.StageOutcomePolicyConfig()

Bases: BaseModel

Shared episode policies selected by the failure’s originating stage.

Callers establish ownership and evidence before selecting a stage. A retry decision permits only safe retries within the caller’s existing budget; once that budget is exhausted, the result stays ungraded. Provider-operation retry policies remain separate from these episode decisions. Verification defaults apply to admitted inconclusive attempts, never ordinary verifier scores.

by_stage

dict[FailureStage, StagePolicyConfig] = Field(default_factory=_default_stage_policies)

classification

FailureClassificationConfig = Field(default_factory=FailureClassificationConfig)

default_policy

StagePolicyConfig = Field(default_factory=StagePolicyConfig)

model_config

= ConfigDict(extra='forbid')

nemo_gym.core.outcome_policy.StageOutcomePolicyConfig.merge_stage_defaults(
    value: object
) -> object

classmethod

Merge partial stage and rule overrides without dropping other defaults.

class nemo_gym.core.outcome_policy.StagePolicyConfig()

Bases: OutcomePolicyConfig

Action rules for one stage; classification is configured independently.

default_action

OutcomeAction = OutcomeAction.FAIL

nemo_gym.core.outcome_policy._default_stage_policies() -> dict[nemo_gym.core.failure_kinds.FailureStage, nemo_gym.core.outcome_policy.StagePolicyConfig]

nemo_gym.core.outcome_policy._require_registered_kinds(
    value: dict[str, nemo_gym.core.outcome_policy._require_registered_kinds[T]]
) -> dict[str, nemo_gym.core.outcome_policy._require_registered_kinds[T]]

nemo_gym.core.outcome_policy.choose_action(
    failure_kind: str,
    http_status: int | None,
    config: nemo_gym.core.outcome_policy.OutcomePolicyConfig,
    failure_class: nemo_gym.core.failure_kinds.FailureClass | None = None
) -> nemo_gym.core.outcome_policy.OutcomeAction

Select by status, kind, class, then default; execution belongs to the boundary.

nemo_gym.core.outcome_policy.choose_stage_outcome(
    failure_kind: str,
    http_status: int | None,
    stage: nemo_gym.core.failure_kinds.FailureStage | None,
    config: nemo_gym.core.outcome_policy.StageOutcomePolicyConfig
) -> nemo_gym.core.outcome_policy.OutcomeDecision

Select one decision from established context, without examining causes or SDK details.

Missing stages use the conservative default policy. Preserve a known origin when a failure propagates: catching an agent failure during verification does not turn it into a verifier failure.

nemo_gym.core.outcome_policy.failure_outcome_policy(
    failure: nemo_gym.core.typed_exceptions.NgFailureEvent,
    config: nemo_gym.core.outcome_policy.OutcomePolicyConfig,
    classification: nemo_gym.core.failure_kinds.FailureClassificationConfig | None = None
) -> nemo_gym.core.outcome_policy.OutcomeAction

Adapt only this event’s evidence, without searching its causal chain.

nemo_gym.core.outcome_policy.is_policy_counted_zero(
    row: collections.abc.Mapping[str, object]
) -> bool

Consume a saved explicit-zero decision, independently of completion or diagnostic evidence.

The owning boundary admits the failure and applies its policy before persisting failure_outcome_action. Readers check only consistency with the measured result; counting does not establish fault attribution.