solutions_backend.processor.manager

Durable Processor dispatcher and least-authority business operation manager.

Classes

`ClassificationRuns`

Bases: Protocol

`get`

get(classification_id: UUID) -> ClassificationRunState

`GovernedEffects`

Bases: Protocol

Provider-specific execute-then-fresh-verify authority.

`accept`

accept(request: ProcessorWorkflowRequest, command: AcceptWorkOrderCommand, operation_id: UUID) -> GovernedActionProof | ObservedActionProof

`acknowledge`

acknowledge(request: ProcessorWorkflowRequest, message: RenderedAcknowledgement, operation_id: UUID) -> AcknowledgementDelivery

`verify_acceptance`

verify_acceptance(request: ProcessorWorkflowRequest, command: AcceptWorkOrderCommand, operation_id: UUID) -> ObservedActionProof

Recover an uncertain acceptance by fresh read only; never execute.

`verify_acknowledgement_delivery`

verify_acknowledgement_delivery(request: ProcessorWorkflowRequest, message: RenderedAcknowledgement, operation_id: UUID) -> AcknowledgementDelivery

Recover uncertain delivery by exact idempotency lookup only; never send.

`verify_correspondence`

verify_correspondence(request: ProcessorWorkflowRequest, command: RecordCorrespondenceCommand, delivery: AcknowledgementDelivery, message: RenderedAcknowledgement, operation_id: UUID) -> ObservedActionProof

`GovernedProofs`

Bases: Protocol

Durable immutable authority for external-action proof chains.

`admit`

admit(proof: GovernedActionProof) -> GovernedActionProof

`ObservedUpdateVerifier`

Bases: Protocol

Freshly re-read one source and bind it to an exact canonical command.

`verify`

verify(request: ProcessorWorkflowRequest, command, operation_id: UUID) -> ObservedActionProof

`ProcessorAgents`

Bases: Protocol

`execute_processor`

execute_processor(request: ProcessorWorkflowRequest) -> ProcessorWorkflowResult

`ProcessorCapacityError`

Bases: RuntimeError

Processor dispatch has reached its explicit concurrency bound.

`ProcessorConflictError`

Bases: RuntimeError

Stable Processor identity, stage, or WorkOrder version conflicted.

`ProcessorExecution`

Durable dispatch receipt.

`ProcessorManager`

Own dispatch leases and exact callback operations for ProcessorWorkflow.

`admit_intake`

admit_intake(operation: AdmitIntakeOperation) -> ProcessorOperationResult

Admit a validated plan as one canonical version-one WorkOrder operation.

`advance_acceptance`

advance_acceptance(operation: AdvanceWorkOrderOperation) -> ProcessorOperationResult

Apply exact policy; execute and verify only when explicitly allowed.

`advance_acknowledgement`

advance_acknowledgement(operation: AdvanceWorkOrderOperation) -> ProcessorOperationResult

Apply acknowledgement policy independently; never infer delivery success.

`apply_update`

apply_update(operation: ApplyUpdateOperation) -> ProcessorOperationResult

Admit inbound correspondence plus one exact semantic update with fresh proof.

`execute`

execute(request: ProcessorWorkflowRequest) -> ProcessorExecution

Claim durably, execute Agents once, and return admitted callback-finalized state.

`finalize`

finalize(operation: FinalizeProcessorOperation) -> ProcessorWorkflowResult

Atomically admit the compact terminal result and transactional outbox event.

`get`

get(processor_id: UUID) -> ProcessorRunState

`request_for_classification`

request_for_classification(classification_id: UUID) -> ProcessorWorkflowRequest | None

Return the immutable first-admitted request for replay-safe redispatch.

`ProcessorNotFoundError`

Bases: LookupError

No durable Processor run exists for the supplied identity.

`ProcessorRuns`

Bases: Protocol

`claim`

claim(request: ProcessorWorkflowRequest, input_digest: str, lease_owner: UUID, now: datetime, lease_expires_at: datetime) -> ProcessorRunClaim

`claim_operation`

claim_operation(processor_id: UUID, operation_id: UUID, kind: str, input_digest: str, expected_stage: str, expected_stage_version: int, now: datetime) -> ProcessorOperationClaim

`complete_operation`

complete_operation(result: ProcessorOperationResult, completed_stage: str, completed_at: datetime) -> ProcessorOperationResult

`complete_recovered_operation`

complete_recovered_operation(result: ProcessorOperationResult, completed_stage: str, completed_at: datetime) -> ProcessorOperationResult

`finalize`

finalize(result: ProcessorWorkflowResult, operation_id: UUID, completed_at: datetime) -> ProcessorWorkflowResult

`find_request_by_classification`

find_request_by_classification(classification_id: UUID) -> ProcessorWorkflowRequest | None

`get`

get(processor_id: UUID) -> ProcessorRunState

`mark_operation_unknown`

mark_operation_unknown(operation_id: UUID, safe_code: str) -> None

`ProcessorUnavailableError`

Bases: RuntimeError

A dependency failed before a safe terminal result was observed.

`WorkOrders`

Bases: Protocol

`apply`

apply(before: WorkOrder, after: WorkOrder, history: HistoryEntry) -> WorkOrder

`apply_many`

apply_many(transitions) -> WorkOrder

`create_intake`

create_intake(candidate, decision, work_order, history) -> WorkOrder

`find_command`

find_command(command_id: UUID)

`get`

get(work_order_id: WorkOrderId) -> WorkOrder