stepkind

type CallInvocation struct {
	Spec    graph.CallSpec        `json:"spec"`
	Lineage []graph.DefinitionRef `json:"lineage"`
}

type Canceler interface {
	Cancel(ctx context.Context, ref ExternalOperationRef) error
}

type CancellationMode string

type CancellationSpec struct {
	Mode CancellationMode `json:"mode"`
}

type CompensationReceipt struct {
	Operation  string          `json:"operation"`
	Values     values.ValueSet `json:"values"`
	ChildRunID string          `json:"child_run_id,omitempty"`
}

type CompensationSupport string

type DuplicateRegistrationError struct {
	Name    string
	Version string
}

type ExecutionError struct {
	Code           string              `json:"code"`
	Message        string              `json:"message"`
	Classification RetryClassification `json:"retry_classification"`
	Details        map[string]string   `json:"details,omitempty"`
	Cause          error               `json:"-"`
}

type ExternalOperationRef struct {
	Kind     string            `json:"kind"`
	ID       string            `json:"id"`
	Metadata map[string]string `json:"metadata,omitempty"`
}

type Finalization struct {
	Invocation     PreparedInvocation
	Result         StepResult
	ExecutionError error
}

type Finalizer interface {
	Finalize(ctx context.Context, finalization Finalization) error
}

type Heartbeater interface {
	Heartbeat(ctx context.Context, ref ExternalOperationRef) error
}

type Invocation struct {
	Identity     InvocationIdentity     `json:"identity"`
	Config       graph.Config           `json:"config"`
	Inputs       values.ValueSet        `json:"inputs"`
	Call         *CallInvocation        `json:"call,omitempty"`
	Continuation *WaitContinuation      `json:"continuation,omitempty"`
	Service      *ServiceBinding        `json:"service,omitempty"`
	Compensation *ReversibilityEvidence `json:"compensation,omitempty"`
	// Verification is the immutable graph modifier carried through durable
	// external-operation recovery. Activity is a runtime-issued, process-local
	// recorder; it is deliberately excluded from durable invocation JSON.
	Verification   *graph.VerificationSpec        `json:"verification,omitempty"`
	Activity       *verification.ActivityRecorder `json:"-"`
	IdempotencyKey string                         `json:"idempotency_key,omitempty"`
	Deadline       time.Time                      `json:"deadline,omitempty"`
}

type InvocationIdentity struct {
	RunID     string `json:"run_id"`
	NodeID    string `json:"node_id"`
	Iteration string `json:"iteration,omitempty"`
	Attempt   int    `json:"attempt"`
}

type LifecycleSpec struct {
	Prepare  bool `json:"prepare,omitempty"`
	Finalize bool `json:"finalize,omitempty"`
	// Service routes polling, heartbeat, and explicit stop through the durable
	// ServiceController lane instead of the generic external-operation lane.
	Service bool `json:"service,omitempty"`
}

type MemoizationSupport string

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

type Observation struct {
	State    ObservationState  `json:"state"`
	Progress map[string]string `json:"progress,omitempty"`
	Result   *StepResult       `json:"result,omitempty"`
	Failure  *ExecutionError   `json:"failure,omitempty"`
}

type ObservationMode string

type ObservationSpec struct {
	Mode      ObservationMode `json:"mode"`
	Heartbeat bool            `json:"heartbeat,omitempty"`
}

type ObservationState string

type Observer interface {
	Observe(ctx context.Context, ref ExternalOperationRef) (Observation, error)
}

type PreparedInvocation struct {
	Invocation Invocation `json:"invocation"`
	// State is process-local adapter state. Runtimes never persist, serialize,
	// compare, or expose it outside the adapter lifecycle.
	State any `json:"-"`
}

type Preparer interface {
	Prepare(ctx context.Context, invocation Invocation) (PreparedInvocation, error)
}

type Registry interface {
	Register(kind StepKind) error
	Lookup(name, version string) (StepKind, bool)
	List() []StepKindSpec
}

type ResolutionError struct {
	Name      string
	Version   string
	Available []string
	Cause     error
}

type RetryClassification string

type RetryClassifier interface {
	RetryClassification() RetryClassification
}

type RetrySafety string

type ReversibilityEvidence struct {
	Operation     string       `json:"operation"`
	ReceiptSchema graph.Schema `json:"receipt_schema"`
}

type ReversibilityProvider interface {
	DescribeReversibility(context.Context, ReversibilityRequest) (ReversibilityEvidence, error)
}

type ReversibilityRequest struct {
	Config graph.Config    `json:"config"`
	Call   *graph.CallSpec `json:"call,omitempty"`
}

type ServiceBinding struct {
	Phase           ServicePhase         `json:"phase"`
	StartInvocation InvocationIdentity   `json:"start_invocation"`
	Ref             ExternalOperationRef `json:"ref"`
	// Absent is set only by the runtime when the start node never materialized
	// provider work. It lets the generated finalizer succeed as an exact no-op.
	Absent bool `json:"absent,omitempty"`
}

type ServiceController interface {
	ObserveService(context.Context, ExternalOperationRef) (ServiceObservation, error)
	RequestStop(context.Context, ExternalOperationRef, string) error
}

type ServiceObservation struct {
	State     ServiceObservationState `json:"state"`
	Progress  map[string]string       `json:"progress,omitempty"`
	Outputs   values.ValueSet         `json:"outputs,omitempty"`
	Failure   *ExecutionError         `json:"failure,omitempty"`
	Heartbeat bool                    `json:"heartbeat,omitempty"`
}

type ServiceObservationState string

type ServicePhase string

type SpecError struct {
	Diagnostics []diagnostic.Diagnostic
}

type StepKind interface {
	Spec() StepKindSpec
	ValidateConfig(ctx context.Context, config graph.Config) []diagnostic.Diagnostic
	Execute(ctx context.Context, invocation PreparedInvocation) (StepResult, error)
}

type StepKindSpec struct {
	Name                  string                `json:"name"`
	Version               string                `json:"version"`
	ConfigSchema          graph.Schema          `json:"config_schema"`
	InputSchema           graph.Schema          `json:"input_schema"`
	OutputSchema          graph.Schema          `json:"output_schema"`
	Effects               graph.EffectSet       `json:"effects"`
	RequiredCapabilities  []string              `json:"required_capabilities,omitempty"`
	Idempotency           graph.IdempotencyMode `json:"idempotency"`
	RetrySafety           RetrySafety           `json:"retry_safety"`
	Cancellation          CancellationSpec      `json:"cancellation"`
	Observation           ObservationSpec       `json:"observation"`
	Lifecycle             LifecycleSpec         `json:"lifecycle,omitempty"`
	Memoization           MemoizationSupport    `json:"memoization,omitempty"`
	Compensation          CompensationSupport   `json:"compensation,omitempty"`
	CanSuspend            bool                  `json:"can_suspend,omitempty"`
	EmbeddedModeSupported bool                  `json:"embedded_mode_supported,omitempty"`
}

type StepOutcome string

type StepResult struct {
	Outcome  StepOutcome           `json:"outcome"`
	Outputs  values.ValueSet       `json:"outputs,omitempty"`
	Wait     *WaitResult           `json:"wait,omitempty"`
	External *ExternalOperationRef `json:"external,omitempty"`
	// Compensation is durable proof that the forward effect was applied and
	// carries the exact typed receipt required by its dormant handler.
	Compensation *CompensationReceipt `json:"compensation,omitempty"`
}

type WaitContinuation struct {
	ID     string              `json:"id"`
	Record workflowwait.Record `json:"record"`
	Values values.ValueSet     `json:"values"`
}

type WaitResult struct {
	ID          string              `json:"id"`
	Record      workflowwait.Record `json:"record"`
	ResumeToken string              `json:"-"`
}