graph

type AppendReducer[S State, V any] struct{}

type BarrierMerger[S State] func(original S, branchOutputs map[string]S) S

type BranchConfig[S State] struct {
	// Condition 分支条件
	Condition func(S) bool

	// Target 目标节点
	Target string
}

type BranchInfo struct {
	ID                 string    `json:"id"`
	Name               string    `json:"name"`
	ThreadID           string    `json:"thread_id"`
	BaseCheckpointID   string    `json:"base_checkpoint_id"`
	LatestCheckpointID string    `json:"latest_checkpoint_id"`
	CheckpointCount    int       `json:"checkpoint_count"`
	CreatedAt          time.Time `json:"created_at"`
	UpdatedAt          time.Time `json:"updated_at"`
}

type BulkheadConfig struct {
	// MaxConcurrent 最大并发数
	MaxConcurrent int
	// MaxWait 最大等待时间（毫秒）
	MaxWait int64
}

type CacheStats struct {
	// Hits 命中次数
	Hits int64 `json:"hits"`

	// Misses 未命中次数
	Misses int64 `json:"misses"`

	// Size 当前缓存条目数
	Size int `json:"size"`

	// Evictions 驱逐次数
	Evictions int64 `json:"evictions"`
}

type Channel[V any] struct {
	// Name 通道名称（对应状态字段）
	Name string

	// Default 默认值
	Default V

	// Reducer 合并函数
	Reducer func(current V, new V) V
}

type ChannelConfig struct {
	// Type 通道类型: "overwrite", "append", "custom"
	Type string `json:"type"`

	// Default 默认值
	Default any `json:"default,omitempty"`
}

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

type Checkpoint struct {
	// ID 检查点 ID
	ID string `json:"id"`

	// ThreadID 线程 ID（用于区分不同的执行实例）
	ThreadID string `json:"thread_id"`

	// GraphName 图名称
	GraphName string `json:"graph_name"`

	// CurrentNode 当前节点
	CurrentNode string `json:"current_node"`

	// State 状态快照
	State json.RawMessage `json:"state"`

	// PendingNodes 待执行的节点
	PendingNodes []string `json:"pending_nodes"`

	// CompletedNodes 已完成的节点
	CompletedNodes []string `json:"completed_nodes"`

	// Metadata 元数据
	Metadata map[string]any `json:"metadata,omitempty"`

	// InterruptAddrs 中断点地址映射（中断 ID -> 序列化的地址）
	// 用于持久化 InterruptSignal 树中各中断点的层级地址
	InterruptAddrs map[string]json.RawMessage `json:"interrupt_addrs,omitempty"`

	// InterruptStates 中断点状态映射（中断 ID -> 序列化的组件状态）
	// 用于持久化 StatefulInterrupt 保存的组件内部状态
	InterruptStates map[string]json.RawMessage `json:"interrupt_states,omitempty"`

	// CreatedAt 创建时间
	CreatedAt time.Time `json:"created_at"`

	// UpdatedAt 更新时间
	UpdatedAt time.Time `json:"updated_at"`

	// ParentID 父检查点 ID（用于构建历史链）
	ParentID string `json:"parent_id,omitempty"`
}

type CheckpointQuery struct {
	ThreadID  string           `json:"thread_id,omitempty"`
	GraphName string           `json:"graph_name,omitempty"`
	Status    CheckpointStatus `json:"status,omitempty"`
	BranchID  string           `json:"branch_id,omitempty"`
	Tags      []string         `json:"tags,omitempty"`
	StartTime *time.Time       `json:"start_time,omitempty"`
	EndTime   *time.Time       `json:"end_time,omitempty"`
	Metadata  map[string]any   `json:"metadata,omitempty"`
	Limit     int              `json:"limit,omitempty"`
	Offset    int              `json:"offset,omitempty"`
}

type CheckpointRunner[S State] struct {
	// contains filtered or unexported fields
}

type CheckpointRunnerConfig struct {
	// AutoSave 是否自动保存检查点
	AutoSave bool
	// SaveInterval 保存间隔（每执行多少个节点保存一次）
	SaveInterval int
	// SaveOnError 错误时是否保存检查点
	SaveOnError bool
	// SaveOnInterrupt 中断时是否保存检查点
	SaveOnInterrupt bool
	// MaxRetries 最大重试次数
	MaxRetries int
	// RetryDelay 重试延迟
	RetryDelay time.Duration
}

type CheckpointSaver interface {
	// Save 保存检查点
	Save(ctx context.Context, checkpoint *Checkpoint) error

	// Load 加载检查点
	Load(ctx context.Context, threadID string) (*Checkpoint, error)

	// LoadByID 根据 ID 加载检查点
	LoadByID(ctx context.Context, id string) (*Checkpoint, error)

	// List 列出线程的所有检查点
	List(ctx context.Context, threadID string) ([]*Checkpoint, error)

	// Delete 删除检查点
	Delete(ctx context.Context, id string) error

	// DeleteThread 删除线程的所有检查点
	DeleteThread(ctx context.Context, threadID string) error
}

type CheckpointStats struct {
	StepCount     int                      `json:"step_count"`               // 步骤计数
	TotalDuration time.Duration            `json:"total_duration"`           // 总耗时
	NodeDurations map[string]time.Duration `json:"node_durations,omitempty"` // 各节点耗时
	LLMTokens     int                      `json:"llm_tokens,omitempty"`     // LLM Token 数
	ToolCalls     int                      `json:"tool_calls,omitempty"`     // 工具调用次数
}

type CheckpointStatus string

type CheckpointVersion struct {
	Major int `json:"major"` // 主版本号（不兼容变更）
	Minor int `json:"minor"` // 次版本号（向后兼容变更）
	Patch int `json:"patch"` // 补丁版本号
}

type CircuitBreakerConfig struct {
	// FailureThreshold 失败阈值（连续失败多少次后熔断）
	FailureThreshold int
	// SuccessThreshold 成功阈值（连续成功多少次后恢复）
	SuccessThreshold int
	// Timeout 熔断超时时间（毫秒）
	Timeout int64
	// HalfOpenRequests 半开状态允许的请求数
	HalfOpenRequests int
}

type CleanupPolicy struct {
	// MaxAge 最大保留时间
	MaxAge time.Duration `json:"max_age,omitempty"`
	// MaxCount 最大保留数量（每个线程）
	MaxCount int `json:"max_count,omitempty"`
	// KeepCompleted 是否保留已完成的检查点
	KeepCompleted bool `json:"keep_completed,omitempty"`
	// KeepBranchHeads 是否保留分支头
	KeepBranchHeads bool `json:"keep_branch_heads,omitempty"`
	// KeepTagged 是否保留有标签的检查点
	KeepTagged bool `json:"keep_tagged,omitempty"`
}

type Command[S State] struct {
	// contains filtered or unexported fields
}

type CommandHandler[S State] func(ctx context.Context, state S) (*Command[S], error)

type CompiledGraph[S State] struct {
	*Graph[S]

	// ExecutionPlan 执行计划
	ExecutionPlan *ExecutionPlan

	// Stats 执行统计
	Stats *ExecutionStats
}

type ConditionalHandler[S State] func(ctx context.Context, state S) string

type DebugView struct {
	// TotalSnapshots 总快照数
	TotalSnapshots int `json:"total_snapshots"`

	// CurrentIndex 当前索引
	CurrentIndex int `json:"current_index"`

	// Branches 分支列表
	Branches []string `json:"branches"`

	// Errors 错误数量
	Errors int `json:"errors"`

	// TotalDuration 总耗时
	TotalDuration time.Duration `json:"total_duration"`

	// NodeExecutions 节点执行统计
	NodeExecutions map[string]int `json:"node_executions"`
}

type DefaultPregelMerger[S State] struct{}

type DynamicGraph[S State] struct {
	*Graph[S]
	// contains filtered or unexported fields
}

type Edge struct {
	// From 源节点名称
	From string

	// To 目标节点名称
	To string

	// Type 边类型
	Type EdgeType

	// Condition 条件（仅用于条件边）
	// 返回 true 时边才有效
	Condition func(state State) bool

	// Label 边标签（用于条件路由的匹配）
	Label string

	// Priority 优先级（数值越小优先级越高）
	Priority int
}

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

type EdgeSnapshot struct {
	From string
	To   string
	Type EdgeType
}

type EdgeType int

type EnhancedCheckpoint struct {
	// 基本信息
	ID        string            `json:"id"`
	ThreadID  string            `json:"thread_id"`
	GraphName string            `json:"graph_name"`
	Version   CheckpointVersion `json:"version"`
	Status    CheckpointStatus  `json:"status"`

	// 执行状态
	CurrentNode    string   `json:"current_node"`
	PendingNodes   []string `json:"pending_nodes"`
	CompletedNodes []string `json:"completed_nodes"`
	VisitedNodes   []string `json:"visited_nodes"` // 所有访问过的节点（含重复）

	// 状态数据
	State     json.RawMessage `json:"state"`
	StateDiff json.RawMessage `json:"state_diff,omitempty"` // 与父检查点的差异
	StateHash string          `json:"state_hash,omitempty"` // 状态哈希，用于快速比较

	// 分支支持
	ParentID   string   `json:"parent_id,omitempty"`   // 父检查点 ID
	BranchID   string   `json:"branch_id,omitempty"`   // 分支 ID
	BranchName string   `json:"branch_name,omitempty"` // 分支名称
	ChildIDs   []string `json:"child_ids,omitempty"`   // 子检查点 ID 列表

	// 元数据
	Metadata    map[string]any `json:"metadata,omitempty"`
	Tags        []string       `json:"tags,omitempty"`
	Description string         `json:"description,omitempty"`

	// 时间戳
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`

	// 执行统计
	Stats *CheckpointStats `json:"stats,omitempty"`
}

type EnhancedCheckpointSaver interface {
	CheckpointSaver // 继承基础接口

	// SaveEnhanced 保存增强检查点
	SaveEnhanced(ctx context.Context, checkpoint *EnhancedCheckpoint) error

	// LoadEnhanced 加载最新的增强检查点
	LoadEnhanced(ctx context.Context, threadID string) (*EnhancedCheckpoint, error)

	// LoadEnhancedByID 根据 ID 加载增强检查点
	LoadEnhancedByID(ctx context.Context, id string) (*EnhancedCheckpoint, error)

	// ListEnhanced 列出线程的所有增强检查点
	ListEnhanced(ctx context.Context, threadID string, opts *ListOptions) ([]*EnhancedCheckpoint, error)

	// GetHistory 获取检查点历史链
	GetHistory(ctx context.Context, checkpointID string, limit int) ([]*EnhancedCheckpoint, error)

	// GetBranches 获取分支列表
	GetBranches(ctx context.Context, threadID string) ([]*BranchInfo, error)

	// CreateBranch 从检查点创建分支
	CreateBranch(ctx context.Context, checkpointID string, branchName string) (*EnhancedCheckpoint, error)

	// MergeBranch 合并分支
	MergeBranch(ctx context.Context, sourceBranchID, targetBranchID string, strategy MergeStrategy) (*EnhancedCheckpoint, error)

	// Search 搜索检查点
	Search(ctx context.Context, query *CheckpointQuery) ([]*EnhancedCheckpoint, error)

	// Cleanup 清理旧检查点
	Cleanup(ctx context.Context, policy *CleanupPolicy) (int, error)
}

type ErrorHandler[S State] func(ctx context.Context, state S, err error) (S, bool, error)

type EventType int

type Executable interface {
	// ExecuteNode 执行单个节点
	ExecuteNode(ctx context.Context, nodeID string, state map[string]any) (output any, nextNode string, err error)

	// GetEntryPoint 获取入口节点
	GetEntryPoint() string

	// GetNodeName 获取节点名称
	GetNodeName(nodeID string) string
}

type ExecutionPlan struct {
	// TopologicalOrder 拓扑排序后的节点顺序
	TopologicalOrder []string

	// ParallelGroups 可并行执行的节点组
	ParallelGroups [][]string

	// CriticalPath 关键路径
	CriticalPath []string

	// Dependencies 节点依赖关系
	Dependencies map[string][]string
}

type ExecutionResult struct {
	// StartTime 开始时间
	StartTime time.Time

	// EndTime 结束时间
	EndTime time.Time

	// Duration 总耗时
	Duration time.Duration

	// NodeTiming 每个节点的耗时
	NodeTiming map[string]time.Duration

	// Error 错误
	Error error
}

type ExecutionStats struct {
	// TotalExecutions 总执行次数
	TotalExecutions int64

	// TotalDuration 总执行时间
	TotalDuration time.Duration

	// NodeStats 节点统计
	NodeStats map[string]*NodeStats

	// LastExecution 最后一次执行时间
	LastExecution time.Time
}

type ExecutionTrace struct {
	Steps []TraceStep
}

type ExportFormat int

type ExportOption func(*exportConfig)

type FieldValidation struct {
	// Min 最小值（用于 number）
	Min *float64 `json:"min,omitempty"`
	// Max 最大值（用于 number）
	Max *float64 `json:"max,omitempty"`
	// MinLength 最小长度（用于 text）
	MinLength *int `json:"min_length,omitempty"`
	// MaxLength 最大长度（用于 text）
	MaxLength *int `json:"max_length,omitempty"`
	// Pattern 正则表达式
	Pattern string `json:"pattern,omitempty"`
}

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

type Graph[S State] struct {
	// Name 图名称
	Name string

	// Nodes 节点映射
	Nodes map[string]*Node[S]

	// Edges 边列表
	Edges []*Edge

	// EntryPoint 入口点
	EntryPoint string

	// Checkpointer 检查点保存器
	Checkpointer CheckpointSaver

	// Metadata 元数据
	Metadata map[string]any
	// contains filtered or unexported fields
}

type GraphBuilder[S State] struct {
	// contains filtered or unexported fields
}

type GraphComposer[S State] struct {
	// contains filtered or unexported fields
}

type GraphSnapshot[S State] struct {
	// Name 图名称
	Name string

	// NodeNames 节点名称列表
	NodeNames []string

	// Edges 边列表
	Edges []EdgeSnapshot

	// Version 版本号
	Version int64

	// Metadata 元数据
	Metadata map[string]any
}

type HITLCallback func(ctx context.Context, request *HITLRequest) (*HITLResponse, error)

type HITLHandler interface {
	// Handle 处理人工介入请求
	// 阻塞直到收到响应或超时
	Handle(ctx context.Context, request *HITLRequest) (*HITLResponse, error)
}

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

type HITLManagerConfig struct {
	// MaxPendingRequests 最大待处理请求数
	MaxPendingRequests int

	// DefaultTimeout 默认超时
	DefaultTimeout time.Duration

	// HistoryLimit 历史记录上限
	HistoryLimit int
}

type HITLNode[S State] struct {
	// ID 节点 ID
	ID string

	// Name 节点名称
	Name string

	// Type 介入类型
	Type HITLType

	// Handler 处理器
	Handler HITLHandler

	// RequestBuilder 请求构建器
	RequestBuilder func(state S) *HITLRequest

	// ResponseHandler 响应处理器
	ResponseHandler func(state S, response *HITLResponse) S

	// Condition 触发条件（可选）
	Condition func(state S) bool
}

type HITLNodeOption[S State] func(*HITLNode[S])

type HITLOption struct {
	// ID 选项 ID
	ID string `json:"id"`

	// Label 显示标签
	Label string `json:"label"`

	// Description 选项描述
	Description string `json:"description,omitempty"`

	// Recommended 是否推荐
	Recommended bool `json:"recommended,omitempty"`

	// Dangerous 是否危险操作
	Dangerous bool `json:"dangerous,omitempty"`
}

type HITLPriority string

type HITLRecord struct {
	Request   *HITLRequest  `json:"request"`
	Response  *HITLResponse `json:"response,omitempty"`
	Status    string        `json:"status"` // pending, completed, timeout, cancelled
	StartedAt time.Time     `json:"started_at"`
	EndedAt   *time.Time    `json:"ended_at,omitempty"`
}

type HITLRequest struct {
	// ID 请求唯一标识
	ID string `json:"id"`

	// Type 介入类型
	Type HITLType `json:"type"`

	// NodeID 触发节点
	NodeID string `json:"node_id"`

	// Title 请求标题
	Title string `json:"title"`

	// Description 请求描述
	Description string `json:"description"`

	// Context 上下文信息
	Context map[string]any `json:"context,omitempty"`

	// Options 可选项（用于审批）
	Options []HITLOption `json:"options,omitempty"`

	// InputSchema 输入 Schema（用于输入模式）
	InputSchema map[string]any `json:"input_schema,omitempty"`

	// CurrentOutput 当前输出（用于审查模式）
	CurrentOutput any `json:"current_output,omitempty"`

	// Timeout 超时时间
	Timeout time.Duration `json:"timeout,omitempty"`

	// Priority 优先级
	Priority HITLPriority `json:"priority"`

	// Metadata 元数据
	Metadata map[string]any `json:"metadata,omitempty"`

	// CreatedAt 创建时间
	CreatedAt time.Time `json:"created_at"`

	// ExpiresAt 过期时间
	ExpiresAt *time.Time `json:"expires_at,omitempty"`
}

type HITLResponse struct {
	// RequestID 对应请求 ID
	RequestID string `json:"request_id"`

	// Approved 是否批准（用于审批模式）
	Approved bool `json:"approved,omitempty"`

	// SelectedOption 选择的选项 ID
	SelectedOption string `json:"selected_option,omitempty"`

	// Input 人工输入数据
	Input map[string]any `json:"input,omitempty"`

	// CorrectedOutput 纠正后的输出
	CorrectedOutput any `json:"corrected_output,omitempty"`

	// Feedback 反馈信息
	Feedback string `json:"feedback,omitempty"`

	// RespondedBy 响应者标识
	RespondedBy string `json:"responded_by,omitempty"`

	// RespondedAt 响应时间
	RespondedAt time.Time `json:"responded_at"`

	// Metadata 元数据
	Metadata map[string]any `json:"metadata,omitempty"`
}

type HITLStats struct {
	TotalRequests   int64                  `json:"total_requests"`
	CompletedCount  int64                  `json:"completed_count"`
	TimeoutCount    int64                  `json:"timeout_count"`
	CancelledCount  int64                  `json:"cancelled_count"`
	AverageWaitTime time.Duration          `json:"average_wait_time"`
	ApprovalRate    float64                `json:"approval_rate"`
	ByType          map[HITLType]int64     `json:"by_type"`
	ByPriority      map[HITLPriority]int64 `json:"by_priority"`
}

type HITLType string

type HTTPExecutorOption func(*HTTPNodeExecutor)

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

type HumanInTheLoop[S State] struct {
	// contains filtered or unexported fields
}

type InputField struct {
	// Name 字段名
	Name string `json:"name"`
	// Type 字段类型（text, number, boolean, select, textarea）
	Type string `json:"type"`
	// Label 显示标签
	Label string `json:"label"`
	// Description 描述
	Description string `json:"description,omitempty"`
	// Required 是否必填
	Required bool `json:"required,omitempty"`
	// Default 默认值
	Default any `json:"default,omitempty"`
	// Options 选项（用于 select 类型）
	Options []string `json:"options,omitempty"`
	// Validation 验证规则
	Validation *FieldValidation `json:"validation,omitempty"`
}

type InputSchema struct {
	// Fields 输入字段
	Fields []InputField `json:"fields"`
}

type Interrupt struct {
	// ID 唯一标识符
	ID string `json:"id"`

	// ThreadID 线程 ID
	ThreadID string `json:"thread_id"`

	// GraphName 图名称
	GraphName string `json:"graph_name"`

	// NodeName 触发中断的节点
	NodeName string `json:"node_name"`

	// Type 中断类型
	Type InterruptType `json:"type"`

	// Status 中断状态
	Status InterruptStatus `json:"status"`

	// Title 标题（用于显示）
	Title string `json:"title"`

	// Message 消息内容
	Message string `json:"message"`

	// Data 附加数据
	Data map[string]any `json:"data,omitempty"`

	// Options 选项（用于 Approval 类型）
	Options []InterruptOption `json:"options,omitempty"`

	// InputSchema 输入模式（用于 Input 类型）
	InputSchema *InputSchema `json:"input_schema,omitempty"`

	// Response 响应数据
	Response *InterruptResponse `json:"response,omitempty"`

	// Timeout 超时时间
	Timeout time.Duration `json:"timeout,omitempty"`

	// CreatedAt 创建时间
	CreatedAt time.Time `json:"created_at"`

	// UpdatedAt 更新时间
	UpdatedAt time.Time `json:"updated_at"`

	// ResolvedAt 解决时间
	ResolvedAt *time.Time `json:"resolved_at,omitempty"`

	// ResolvedBy 解决者
	ResolvedBy string `json:"resolved_by,omitempty"`
}

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

type InterruptConfig struct {
	// Handler 中断处理器
	Handler InterruptHandler

	// DefaultTimeout 默认超时时间
	DefaultTimeout time.Duration

	// AutoResume 自动恢复（当中断解决后自动继续执行）
	AutoResume bool
}

type InterruptError struct {
	Interrupt *Interrupt
}

type InterruptHandler interface {
	// Create 创建中断
	Create(ctx context.Context, interrupt *Interrupt) error

	// Get 获取中断
	Get(ctx context.Context, id string) (*Interrupt, error)

	// Resolve 解决中断
	Resolve(ctx context.Context, id string, response *InterruptResponse, resolvedBy string) error

	// Cancel 取消中断
	Cancel(ctx context.Context, id string) error

	// List 列出中断
	List(ctx context.Context, threadID string) ([]*Interrupt, error)

	// ListPending 列出待处理的中断
	ListPending(ctx context.Context) ([]*Interrupt, error)

	// Wait 等待中断解决
	Wait(ctx context.Context, id string) (*Interrupt, error)

	// WaitWithTimeout 带超时等待中断解决
	WaitWithTimeout(ctx context.Context, id string, timeout time.Duration) (*Interrupt, error)
}

type InterruptOption struct {
	// Value 选项值
	Value string `json:"value"`
	// Label 显示标签
	Label string `json:"label"`
	// Description 描述
	Description string `json:"description,omitempty"`
	// Style 样式（primary, danger, default）
	Style string `json:"style,omitempty"`
}

type InterruptResponse struct {
	// Action 动作（approve, reject, submit, cancel）
	Action string `json:"action"`
	// Data 响应数据
	Data map[string]any `json:"data,omitempty"`
	// Comment 备注
	Comment string `json:"comment,omitempty"`
}

type InterruptStatus string

type InterruptType string

type ListOptions struct {
	Limit     int              // 限制数量
	Offset    int              // 偏移量
	Order     string           // 排序方式: "asc" 或 "desc"
	Status    CheckpointStatus // 状态过滤
	BranchID  string           // 分支过滤
	StartTime *time.Time       // 开始时间
	EndTime   *time.Time       // 结束时间
}

type LoopConfig struct {
	// MaxIterations 最大迭代次数（0 表示无限制）
	MaxIterations int

	// Timeout 循环超时时间（0 表示无超时）
	Timeout time.Duration

	// OnIteration 每次迭代回调
	OnIteration func(iteration int)

	// OnBreak 中断回调
	OnBreak func(iteration int, reason string)

	// OnComplete 完成回调
	OnComplete func(iterations int)

	// BreakOnError 遇到错误时中断
	BreakOnError bool

	// ContinueOnError 遇到错误时继续
	ContinueOnError bool
}

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

type MapFunc[S State] func(ctx context.Context, state S) (S, error)

type MapState map[string]any

type MemoryCacheOption func(*MemoryNodeCache)

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

type MemoryEnhancedCheckpointSaver struct {
	*MemoryCheckpointSaver
	// contains filtered or unexported fields
}

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

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

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

type MergeStrategy string

type MultiRouter[S State] interface {
	// RouteMulti 根据状态决定多个下一节点
	RouteMulti(state S) []string
}

type MultiRouterFunc[S State] func(state S) []string

type Node[S State] struct {
	// Name 节点名称
	Name string

	// Type 节点类型
	Type NodeType

	// Handler 节点处理函数
	Handler NodeHandler[S]

	// Metadata 节点元数据
	Metadata map[string]any

	// RetryPolicy 重试策略
	RetryPolicy *RetryPolicy

	// Timeout 超时时间（毫秒）
	Timeout int64
}

type NodeBuilder[S State] struct {
	// contains filtered or unexported fields
}

type NodeCache interface {
	// Get 获取缓存的状态
	// key 是基于节点输入计算的哈希值
	// 返回缓存的状态和是否命中
	Get(key string) (any, bool)

	// Set 设置缓存
	Set(key string, value any)

	// Delete 删除缓存
	Delete(key string)

	// Clear 清空所有缓存
	Clear()

	// Stats 返回缓存统计信息
	Stats() CacheStats
}

type NodeHandler[S State] func(ctx context.Context, state S) (S, error)

type NodePlacement struct {
	// NodeName 节点名称
	NodeName string

	// ExecutorName 远程执行器名称
	ExecutorName string

	// Fallback 是否在远程不可用时降级到本地执行
	Fallback bool
}

type NodeResult[S State] struct {
	// State 更新后的状态
	State S

	// NextNodes 下一个要执行的节点（用于条件路由）
	NextNodes []string

	// Error 执行错误
	Error error

	// Metadata 执行元数据
	Metadata map[string]any
}

type NodeStats struct {
	// Executions 执行次数
	Executions int64

	// TotalDuration 总执行时间
	TotalDuration time.Duration

	// AverageDuration 平均执行时间
	AverageDuration time.Duration

	// Errors 错误次数
	Errors int64

	// LastError 最后一次错误
	LastError error

	// LastExecution 最后一次执行时间
	LastExecution time.Time
}

type NodeType int

type OverwriteReducer[S State, V any] struct{}

type PregelConfig struct {
	// MaxSupersteps 最大超级步数量（防止无限循环）
	// 默认 100
	MaxSupersteps int

	// TriggerMode 默认触发模式
	// 默认 TriggerAnyPredecessor
	TriggerMode TriggerMode

	// ParallelExecution 是否并行执行同一超级步内的节点
	// 默认 true
	ParallelExecution bool

	// TerminationCheck 终止检查函数
	// 返回 true 表示应该终止迭代
	// 如果为 nil，则只检查是否到达 END 节点
	TerminationCheck func(step int, activeNodes []string) bool

	// Debug 调试模式
	Debug bool
}

type PregelEvent[S State] struct {
	// Type 事件类型
	Type PregelEventType

	// Superstep 当前超级步编号
	Superstep int

	// ActiveNodes 活跃节点列表
	ActiveNodes []string

	// State 当前状态
	State S

	// Error 错误信息
	Error error
}

type PregelEventType int

type PregelExecutor[S State] struct {
	// contains filtered or unexported fields
}

type PregelExecutorOption[S State] func(*PregelExecutor[S])

type PregelOption func(*PregelConfig)

type PregelStateMerger[S State] interface {
	// Merge 合并多个状态为一个
	// base 是执行前的基础状态
	// states 是各节点执行后的状态列表
	Merge(base S, states []S) S
}

type RedisCheckpointOption func(*RedisCheckpointSaver)

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

type ReduceFunc[S State] func(original S, results []S) S

type Reducer[S State, V any] interface {
	// Reduce 将新值合并到状态中
	Reduce(state S, key string, value V) S
}

type RemoteNodeExecutor interface {
	// Execute 远程执行节点
	// nodeName 节点名称
	// stateData 序列化后的状态数据
	// 返回序列化后的结果状态数据
	Execute(ctx context.Context, nodeName string, stateData []byte) ([]byte, error)

	// Ping 检查远程节点是否可用
	Ping(ctx context.Context) error

	// Name 返回执行器名称
	Name() string
}

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

type RetryConfig struct {
	// MaxRetries 最大重试次数
	MaxRetries int

	// Delay 基础延迟
	Delay time.Duration

	// MaxDelay 最大延迟
	MaxDelay time.Duration

	// Backoff 退避因子
	Backoff float64

	// Jitter 抖动比例 (0-1)
	Jitter float64

	// ShouldRetry 判断是否应该重试
	ShouldRetry func(err error) bool

	// OnRetry 重试回调
	OnRetry func(attempt int, err error, delay time.Duration)
}

type RetryPolicy struct {
	// MaxRetries 最大重试次数
	MaxRetries int

	// InitialDelay 初始延迟（毫秒）
	InitialDelay int64

	// MaxDelay 最大延迟（毫秒）
	MaxDelay int64

	// Multiplier 延迟倍数
	Multiplier float64

	// RetryOn 重试条件（返回 true 表示需要重试）
	RetryOn func(error) bool
}

type Router[S State] interface {
	// Route 根据状态决定下一个节点
	Route(state S) string
}

type RouterFunc[S State] func(state S) string

type RunOption func(*runConfig)

type Send struct {
	// Node 目标节点名称
	Node string

	// Data 发送的数据
	Data any
}

type SnapshotStorage interface {
	// Save 保存快照
	Save(ctx context.Context, snapshot *StateSnapshot) error

	// Load 加载快照
	Load(ctx context.Context, index int) (*StateSnapshot, error)

	// LoadRange 加载范围内的快照
	LoadRange(ctx context.Context, start, end int) ([]*StateSnapshot, error)

	// Delete 删除快照
	Delete(ctx context.Context, index int) error

	// Clear 清空所有快照
	Clear(ctx context.Context) error
}

type SplitFunc[S State] func(state S) []S

type State interface {
	// Clone 创建状态的深拷贝
	Clone() State
}

type StateAnnotation struct {
	Channels map[string]ChannelConfig
}

type StateDiff struct {
	// Key 键名
	Key string `json:"key"`

	// OldValue 旧值
	OldValue any `json:"old_value,omitempty"`

	// NewValue 新值
	NewValue any `json:"new_value,omitempty"`

	// Type 差异类型：added, removed, changed
	Type string `json:"type"`
}

type StateMachine[S any] struct {
	// contains filtered or unexported fields
}