spi

type AnyResult interface {
	GetNodeID() string
	GetDisplayName() string
	GetNodeType() Kind
	GetInputs() map[string]any
	GetOutputs() map[string]any
	GetError() error
	GetExecutedAt() time.Time
	// contains filtered or unexported methods
}

type AssertionResult struct {
	Index     int    `json:"index"`
	Extractor string `json:"extractor"`
	Operator  string `json:"operator"`
	Expected  any    `json:"expected"`
	Actual    any    `json:"actual"`
	Passed    bool   `json:"passed"`
	Error     string `json:"error,omitempty"`
}

type BaseExecutionResult struct {
	NodeID        string         `json:"node_id"`
	DisplayName   string         `json:"display_name"`
	NodeType      Kind           `json:"node_type"`
	RunWhen       RunWhen        `json:"run_when,omitempty"`
	Inputs        map[string]any `json:"inputs"`
	Outputs       map[string]any `json:"outputs"`
	Error         error          `json:"-"` // Don't serialize Go error
	ErrorCode     *string        `json:"error_code,omitempty"`
	ErrorMsg      *string        `json:"error_message,omitempty"`
	SkipReason    *string        `json:"skip_reason,omitempty"`
	MissingInputs []string       `json:"missing_inputs,omitempty"`
	ExecutedAt    time.Time      `json:"executed_at"`

	// AssertionResults records every assertion evaluated on this node (pass or
	// fail). It lives on the shared base so the engine-level assertion pass fills
	// it uniformly for every node kind. The JSON tag is a wire contract consumed
	// by echopoint.
	AssertionResults []AssertionResult `json:"assertion_results,omitempty"`
}

type DynamicResolver interface {
	Resolve(name string, args []string) (string, error)
}

type EventType string

type ExecutionContext struct {
	// Ctx is the request-scoped context for the execution. Nodes use it for
	// cancellation and deadlines (e.g. the HTTP request honors it). May be nil,
	// in which case callers should treat it as context.Background().
	Ctx context.Context
	// Inputs contains all the data this node declared it needs in InputSchema().
	// Keys are in format "nodeId.outputKey" (e.g., "create-user.userId").
	Inputs map[string]any
	// FlowInputs contains the full effective inputs for the current flow execution,
	// including inherited inputs, static overrides, and any initial input values.
	FlowInputs map[string]any
	// AllOutputs exposes a read-only snapshot of outputs from nodes that completed
	// before the current scheduling batch started.
	AllOutputs OutputView
	// ModuleResolver exposes the additional flow definitions available to module
	// nodes during nested execution.
	ModuleResolver ModuleResolver
	// ModuleExecutor runs nested flows for module nodes.
	ModuleExecutor ModuleExecutor
	// DynamicVars resolves {{$name}} template variables (fake-data generators).
	// May be nil, in which case {{$...}} references are left untouched.
	DynamicVars DynamicResolver
}

type ExtractorType string

type FlowExecutionResult struct {
	ExecutionResults map[string]AnyResult `json:"execution_results"` // Polymorphic results!
	FinalOutputs     map[string]any       `json:"final_outputs"`     // All outputs flattened ("nodeId.outputKey": value)
	Success          bool                 `json:"success"`
	Error            error                `json:"-"`
	ErrorCode        *string              `json:"error_code,omitempty"`
	ErrorMsg         *string              `json:"error_message,omitempty"`
	DurationMS       int64                `json:"duration_ms"`
}

type Kind string

type ModuleExecutionRequest struct {
	FlowID         string
	FlowDefinition []byte
	Inputs         map[string]any
}

type ModuleExecutor interface {
	ExecuteModule(request ModuleExecutionRequest) (*FlowExecutionResult, error)
}

type ModuleResolver interface {
	ResolveFlow(flowID string) (ResolvedModuleFlow, bool)
}

type Node interface {
	GetID() string
	GetDisplayName() string
	GetType() Kind
	GetRunWhen() RunWhen
	InputSchema() []string

	// OutputSchema defines what this node produces
	// Examples: []string{"statusCode", "userId", "responseBody"}
	OutputSchema() []string

	// Execute performs the node's action with provided inputs and returns the
	// polymorphic result. Error indicates execution failure.
	Execute(ctx ExecutionContext) (AnyResult, error)
}

type OutputView interface {
	HasNode(nodeID string) bool
	Get(nodeID, outputKey string) (any, bool)
	// Node returns a defensive copy of the requested node outputs.
	Node(nodeID string) map[string]any
}

type ResolvedModuleFlow struct {
	FlowDefinition []byte
	InputOverrides map[string]any
}

type RoutingResult interface {
	AnyResult
	// RoutedTargets returns the successor node IDs this result routes execution
	// to. An empty slice means no successor was chosen (every successor edge is
	// dead).
	RoutedTargets() []string
}

type RunWhen string

type UserError struct {
	Code    string
	Message string
	Cause   error
}