domain

type ActionRequest struct {
	Type    string // e.g., "CLI_PRINT", "HTTP_GET"
	Payload any    // The data needed to perform the action
}

type ActionResponse struct {
	Success bool
	Data    any
	Error   error
}

type EventBase struct {
	Timestamp time.Time `json:"timestamp"`
	Type      EventType `json:"type"`
	StateID   string    `json:"state_id"` // Optional execution ID/Correlation ID? For now just keep it simple.
}

type EventType string

type ExecutionStatus string

type InputRequest struct {
	Type    InputType     `json:"type"`
	Options []string      `json:"options,omitempty"`
	Default string        `json:"default,omitempty"`
	Timeout time.Duration `json:"timeout,omitempty"` // Parsed duration (e.g. 5s)
}

type InputType string

type LifecycleHooks struct {
	OnNodeEnter  func(context.Context, *NodeEvent)
	OnNodeLeave  func(context.Context, *NodeEvent)
	OnToolCall   func(context.Context, *ToolEvent)
	OnToolReturn func(context.Context, *ToolEvent)
}

type Node struct {
	ID   string `json:"id" yaml:"id"`
	Type string `json:"type" yaml:"type"` // e.g., "text", "question", "logic", "tool"
	// Wait indicates if the engine should pause for input after rendering.
	Wait bool `json:"wait" yaml:"wait"`
	// SaveTo indicates the variable name in Context where input should be stored.
	SaveTo string `json:"save_to,omitempty" yaml:"save_to,omitempty"`

	// RequiredContext lists keys that MUST exist in the context for this node to execute.
	RequiredContext []string `json:"required_context,omitempty" yaml:"required_context,omitempty"`

	// DefaultContext provides fallback values for context keys
	DefaultContext map[string]any `json:"default_context,omitempty" yaml:"default_context,omitempty"`

	// Content holds the raw data for this node.
	// For a text node, it might be the markdown content.
	// For a logic node, it might be the script or parameters.
	Content []byte `json:"content" yaml:"content"`

	// Metadata allows for extensible key-value pairs.
	Metadata map[string]string `json:"metadata,omitempty" yaml:"metadata,omitempty"`

	// Transitions defines the possible paths from this node.
	Transitions []Transition `json:"transitions" yaml:"transitions"`

	// OnError defines the node ID to transition to if a Tool returns an error.
	OnError string `json:"on_error,omitempty" yaml:"on_error,omitempty"`

	// OnDenied defines the node ID to transition to if a Tool execution is denied by policy.
	OnDenied string `json:"on_denied,omitempty" yaml:"on_denied,omitempty"`

	// OnSignal defines transitions triggered by global signals (e.g., "interrupt").
	OnSignal map[string]string `json:"on_signal,omitempty" yaml:"on_signal,omitempty"`

	// Input Configuration (Optional)
	InputType    string   `json:"input_type,omitempty" yaml:"input_type,omitempty"`
	InputOptions []string `json:"input_options,omitempty" yaml:"input_options,omitempty"`
	InputDefault string   `json:"input_default,omitempty" yaml:"input_default,omitempty"`

	// Tool Configuration (Optional, used if Type == "tool")
	// Do defines the primary action to execute.
	Do *ToolCall `json:"do,omitempty" yaml:"do,omitempty"`

	// Tools defined within this node (e.g. for LLM context)
	Tools []Tool `json:"tools,omitempty" yaml:"tools,omitempty"`

	// Undo defines the compensating action (SAGA pattern) to revert this node's effect.
	// It is triggered if the engine enters rollback mode.
	Undo *ToolCall `json:"undo,omitempty" yaml:"undo,omitempty"`

	// Timeout defines the maximum duration (e.g. "30s") to wait for input.
	Timeout string `json:"timeout,omitempty" yaml:"timeout,omitempty"`
}

type NodeEvent struct {
	EventBase
	NodeID   string `json:"node_id"`
	NodeType string `json:"node_type"`
}

type State struct {
	// SessionID uniquely identifies the session this state belongs to.
	SessionID string `json:"session_id"`

	// CurrentNodeID is the identifier of the active node.
	CurrentNodeID string `json:"current_node_id"`

	// Status indicates if the engine is running, waiting, or done.
	Status ExecutionStatus `json:"status"`

	// PendingToolCall holds the ID of the tool call we are waiting for (if Status == WaitingForTool).
	PendingToolCall string `json:"pending_tool_call,omitempty"`

	// Context holds variable state for the session (User space).
	Context map[string]any `json:"context"`

	// SystemContext holds system-level state (Read-only for templates, Host-writable).
	// Reserved namespace: "sys".
	SystemContext map[string]any `json:"system_context"`

	// History could track the path taken (optional for now, but good for debugging)
	History []string `json:"history,omitempty"`

	// Terminated indicates if the execution has reached a sink state (no transitions).
	// Deprecated: Use Status == StatusTerminated instead. Kept for backward compat.
	Terminated bool `json:"terminated,omitempty"`
}

type Tool struct {
	Name        string         `json:"name" yaml:"name" mapstructure:"name"`
	Description string         `json:"description" yaml:"description" mapstructure:"description"`
	Parameters  map[string]any `json:"parameters,omitempty" yaml:"parameters,omitempty" mapstructure:"parameters"`
}

type ToolCall struct {
	ID             string            `json:"id" yaml:"id" mapstructure:"id"`                                       // Unique ID for this specific call (e.g. from LLM or generated)
	Name           string            `json:"name" yaml:"name" mapstructure:"name"`                                 // Function name to call
	Args           map[string]any    `json:"args,omitempty" yaml:"args,omitempty" mapstructure:"args"`             // Arguments for the function
	Metadata       map[string]string `json:"metadata,omitempty" yaml:"metadata,omitempty" mapstructure:"metadata"` // Context/Safety metadata from the Node
	IdempotencyKey string            `json:"idempotency_key,omitempty" yaml:"idempotency_key,omitempty" mapstructure:"idempotency_key"`
}

type ToolEvent struct {
	EventBase
	NodeID   string `json:"node_id"`
	ToolName string `json:"tool_name"`
	Input    any    `json:"input,omitempty"`
	Output   any    `json:"output,omitempty"`
	IsError  bool   `json:"is_error,omitempty"`
}

type ToolResult struct {
	ID       string `json:"id"` // Must match the ToolCall.ID
	Result   any    `json:"result,omitempty"`
	IsError  bool   `json:"is_error,omitempty"`
	IsDenied bool   `json:"is_denied,omitempty"`
	Error    string `json:"error,omitempty"`
}

type Transition struct {
	FromNodeID string `json:"from_node_id,omitempty" yaml:"from,omitempty"`

	ToNodeID string `json:"to_node_id" yaml:"to,omitempty"`

	// Condition is a simple expression string that must evaluate to true
	// for this transition to be valid. e.g., "user_age >= 18"
	// If empty, it's considered an "always" transition (default).
	Condition string `json:"condition,omitempty" yaml:"condition,omitempty"`
}