core

type Agent interface {
	// 继承 Runnable 接口，Agent 是一个可执行的组件
	Runnable[*AgentInput, *AgentOutput]

	// Agent 特有方法
	// Name 返回 Agent 的名称
	Name() string

	// Description 返回 Agent 的描述
	Description() string

	// Capabilities 返回 Agent 的能力列表
	Capabilities() []string
}

type AgentAction struct {
	Tool      string                 // 工具名称
	ToolInput map[string]interface{} // 工具输入
	Log       string                 // 日志信息
}

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

type AgentInput struct {
	// 任务描述
	Task        string                 `json:"task"`        // 任务描述
	Instruction string                 `json:"instruction"` // 具体指令
	Context     map[string]interface{} `json:"context"`     // 上下文信息

	// 执行选项
	Options AgentOptions `json:"options"` // 执行选项

	// 元数据
	SessionID string    `json:"session_id"` // 会话 ID
	Timestamp time.Time `json:"timestamp"`  // 时间戳
}

type AgentOptions struct {
	// LLM 配置
	Temperature float64 `json:"temperature,omitempty"` // LLM 温度参数
	MaxTokens   int     `json:"max_tokens,omitempty"`  // 最大 token 数
	Model       string  `json:"model,omitempty"`       // LLM 模型

	// 工具配置
	EnableTools  bool     `json:"enable_tools,omitempty"`   // 是否启用工具
	AllowedTools []string `json:"allowed_tools,omitempty"`  // 允许的工具列表
	MaxToolCalls int      `json:"max_tool_calls,omitempty"` // 最大工具调用次数

	// 记忆配置
	EnableMemory     bool `json:"enable_memory,omitempty"`      // 是否启用记忆
	LoadHistory      bool `json:"load_history,omitempty"`       // 是否加载历史
	SaveToMemory     bool `json:"save_to_memory,omitempty"`     // 是否保存到记忆
	MaxHistoryLength int  `json:"max_history_length,omitempty"` // 最大历史长度

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

type AgentOutput struct {
	// 执行结果
	Result  interface{} `json:"result"`  // 结果数据
	Status  string      `json:"status"`  // 状态: "success", "failed", "partial"
	Message string      `json:"message"` // 结果消息

	// 推理过程
	ReasoningSteps []ReasoningStep `json:"reasoning_steps"` // 推理步骤
	ToolCalls      []ToolCall      `json:"tool_calls"`      // 工具调用记录

	// Token 使用统计
	TokenUsage *interfaces.TokenUsage `json:"token_usage,omitempty"` // LLM Token 使用统计

	// 元数据
	Latency   time.Duration          `json:"latency"`   // 执行延迟
	Timestamp time.Time              `json:"timestamp"` // 时间戳
	Metadata  map[string]interface{} `json:"metadata"`  // 额外元数据
}

type AgentState = state.AgentState

type BackoffPolicy interface {
	// NextDelay 计算下一次重试的延迟
	NextDelay(attempt int) int64 // 返回毫秒数
}

type BaseAgent struct {
	*BaseRunnable[*AgentInput, *AgentOutput]
	// contains filtered or unexported fields
}

type BaseCallback struct{}

type BaseChain struct {
	*BaseRunnable[*ChainInput, *ChainOutput]
	// contains filtered or unexported fields
}

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

type BaseMiddleware = middleware.BaseMiddleware

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

type BasePlugin struct {
	*BaseLifecycle
	// contains filtered or unexported fields
}

type BaseRunnable[I, O any] struct {
	// contains filtered or unexported fields
}

type Callback interface {
	// 通用回调
	OnStart(ctx context.Context, input interface{}) error
	OnEnd(ctx context.Context, output interface{}) error
	OnError(ctx context.Context, err error) error

	// LLM 回调
	OnLLMStart(ctx context.Context, prompts []string, model string) error
	OnLLMEnd(ctx context.Context, output string, tokenUsage int) error
	OnLLMError(ctx context.Context, err error) error

	// Chain 回调
	OnChainStart(ctx context.Context, chainName string, input interface{}) error
	OnChainEnd(ctx context.Context, chainName string, output interface{}) error
	OnChainError(ctx context.Context, chainName string, err error) error

	// Tool 回调
	OnToolStart(ctx context.Context, toolName string, input interface{}) error
	OnToolEnd(ctx context.Context, toolName string, output interface{}) error
	OnToolError(ctx context.Context, toolName string, err error) error

	// Agent 回调
	OnAgentAction(ctx context.Context, action *AgentAction) error
	OnAgentFinish(ctx context.Context, output interface{}) error
}

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

type Chain interface {
	Runnable[*ChainInput, *ChainOutput]

	// Name 返回 Chain 的名称
	Name() string

	// Steps 返回包含的步骤数量
	Steps() int
}

type ChainInput struct {
	// 输入数据
	Data interface{} `json:"data"` // 主要输入数据

	// 变量和上下文
	Vars map[string]interface{} `json:"vars,omitempty"` // 变量集合，用于在步骤间传递上下文

	// 执行控制
	Options ChainOptions `json:"options,omitempty"` // 执行选项
}

type ChainOptions struct {
	// 执行控制
	StopOnError bool          `json:"stop_on_error,omitempty"` // 出错时是否停止
	Timeout     time.Duration `json:"timeout,omitempty"`       // 超时时间
	Parallel    bool          `json:"parallel,omitempty"`      // 是否并行执行（如果可能）

	// 步骤控制
	SkipSteps []int `json:"skip_steps,omitempty"` // 跳过的步骤编号
	OnlySteps []int `json:"only_steps,omitempty"` // 仅执行的步骤编号

	// 额外选项
	Extra map[string]interface{} `json:"extra,omitempty"` // 额外选项
}

type ChainOutput struct {
	// 输出数据
	Data interface{} `json:"data"` // 最终输出数据

	// 执行信息
	StepsExecuted []StepExecution `json:"steps_executed"` // 执行的步骤详情
	TotalLatency  time.Duration   `json:"total_latency"`  // 总耗时
	Status        string          `json:"status"`         // 执行状态: "success", "failed", "partial"

	// 额外结果
	Metadata map[string]interface{} `json:"metadata,omitempty"` // 额外元数据
}

type ChainableAgent struct {
	*BaseAgent
	// contains filtered or unexported fields
}

type ChunkMetadata = execution.ChunkMetadata

type ChunkTransformFunc = execution.ChunkTransformFunc

type ChunkType = execution.ChunkType

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

type CostTrackingCallback struct {
	*BaseCallback
	// contains filtered or unexported fields
}

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

type DefaultPanicHandler struct{}

type DynamicRunnable interface {
	// Invoke 执行动态输入，返回动态输出
	InvokeDynamic(ctx context.Context, input any) (any, error)

	// Stream 流式执行
	StreamDynamic(ctx context.Context, input any) (<-chan DynamicStreamChunk, error)

	// Batch 批量执行
	BatchDynamic(ctx context.Context, inputs []any) ([]any, error)

	// TypeInfo 返回类型信息，用于运行时验证
	TypeInfo() TypeInfo
}

type DynamicStreamChunk struct {
	Data  any   `json:"data,omitempty"`
	Error error `json:"-"`
	Done  bool  `json:"done"`
}

type DynamicToTypedAdapter[I, O any] struct {
	// contains filtered or unexported fields
}

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

type ExecutionStep struct {
	// 步骤信息
	Step        int    `json:"step"`        // 步骤编号
	Name        string `json:"name"`        // 步骤名称
	Type        string `json:"type"`        // 类型: "agent", "chain", "tool", "decision"
	Description string `json:"description"` // 描述

	// 执行信息
	ComponentName string      `json:"component_name"` // 组件名称
	Input         interface{} `json:"input"`          // 输入
	Output        interface{} `json:"output"`         // 输出
	Status        string      `json:"status"`         // 状态: "pending", "running", "success", "failed", "skipped"

	// 时间信息
	StartTime time.Time     `json:"start_time"` // 开始时间
	EndTime   time.Time     `json:"end_time"`   // 结束时间
	Duration  time.Duration `json:"duration"`   // 耗时

	// 错误信息
	Error        string `json:"error,omitempty"`         // 错误信息
	RetryCount   int    `json:"retry_count,omitempty"`   // 重试次数
	PartialError string `json:"partial_error,omitempty"` // 部分错误

	// 元数据
	Metadata map[string]interface{} `json:"metadata,omitempty"` // 额外元数据
}

type ExecutorOption func(*AgentExecutor)

type FastInvoker interface {
	// InvokeFast 快速执行 Agent，跳过回调和中间件
	//
	// 参数：
	//   - ctx: 执行上下文（用于取消和超时控制）
	//   - input: Agent 输入
	//
	// 返回：
	//   - output: Agent 输出
	//   - error: 执行错误
	//
	// 性能特性：
	//   - 无回调触发
	//   - 无中间件执行
	//   - 最小化内存分配
	//   - 优化的执行路径
	InvokeFast(ctx context.Context, input *AgentInput) (*AgentOutput, error)
}

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

type FunctionalLifecycleOption func(*FunctionalLifecycle)

type Generator[T any] iter.Seq2[T, error]

type Handler = middleware.Handler

type Interrupt struct {
	// ID is a unique identifier for this interrupt
	ID string

	// Type specifies what kind of interrupt this is
	Type InterruptType

	// Priority indicates how urgently this needs to be handled
	Priority InterruptPriority

	// Message describes what human action is needed
	Message string

	// Context provides additional context for the interrupt
	Context map[string]interface{}

	// State is a snapshot of the agent state at interrupt time
	State state.State

	// CreatedAt is when the interrupt was created
	CreatedAt time.Time

	// ExpiresAt is when the interrupt expires (optional)
	ExpiresAt *time.Time

	// Metadata holds additional interrupt metadata
	Metadata map[string]interface{}
}

type InterruptConfig struct {
	// EnableAutoSave saves state before each interrupt
	EnableAutoSave bool

	// DefaultTimeout is the default timeout for interrupts
	DefaultTimeout time.Duration

	// RequireReason requires a reason for all responses
	RequireReason bool

	// EnableHistory keeps history of all interrupts
	EnableHistory bool
}

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

type InterruptPriority string

type InterruptResponse struct {
	// InterruptID is the ID of the interrupt being responded to
	InterruptID string

	// Approved indicates if the action was approved
	Approved bool

	// Input contains any human-provided input/feedback
	Input map[string]interface{}

	// Reason explains why the decision was made
	Reason string

	// RespondedAt is when the response was provided
	RespondedAt time.Time

	// RespondedBy identifies who provided the response
	RespondedBy string
}

type InterruptRule struct {
	// Name identifies the rule
	Name string

	// Condition evaluates if an interrupt should be triggered
	Condition func(ctx context.Context, state state.State) bool

	// CreateInterrupt creates the interrupt if condition is met
	CreateInterrupt func(ctx context.Context, state state.State) *Interrupt
}

type InterruptType string

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

type LegacyStreamChunk = execution.LegacyStreamChunk

type LifecycleManagerConfig struct {
	// DefaultInitTimeout is the default timeout for Init operations
	DefaultInitTimeout time.Duration

	// DefaultStartTimeout is the default timeout for Start operations
	DefaultStartTimeout time.Duration

	// DefaultStopTimeout is the default timeout for Stop operations
	DefaultStopTimeout time.Duration

	// HealthCheckInterval is the interval between automatic health checks
	HealthCheckInterval time.Duration

	// ContinueOnError determines whether to continue if a component fails
	ContinueOnError bool
}

type Logger interface {
	Info(msg string, fields ...interface{})
	Error(msg string, fields ...interface{})
	Debug(msg string, fields ...interface{})
}

type LoggingCallback struct {
	*BaseCallback
	// contains filtered or unexported fields
}

type MetricsCallback struct {
	*BaseCallback
	// contains filtered or unexported fields
}

type MetricsCollector interface {
	IncrementCounter(name string, value int64, tags map[string]string)
	RecordHistogram(name string, value float64, tags map[string]string)
	RecordGauge(name string, value float64, tags map[string]string)
}

type Middleware = middleware.Middleware

type MiddlewareChain = middleware.MiddlewareChain

type MiddlewareRequest = middleware.MiddlewareRequest

type MiddlewareResponse = middleware.MiddlewareResponse

type NoOpMetricsCollector struct{}

type NoOpPanicLogger struct{}

type Orchestrator interface {
	// Execute 执行编排任务
	Execute(ctx context.Context, request *OrchestratorRequest) (*OrchestratorResponse, error)

	// RegisterAgent 注册 Agent
	RegisterAgent(name string, agent Agent) error

	// RegisterChain 注册 Chain
	RegisterChain(name string, chain Chain) error

	// RegisterTool 注册 Tool
	RegisterTool(name string, tool Tool) error

	// Name 返回编排器名称
	Name() string
}

type OrchestratorOptions struct {
	// 日志选项
	EnableLogging bool   `json:"enable_logging"` // 是否启用日志
	LogLevel      string `json:"log_level"`      // 日志级别

	// 监控选项
	EnableMetrics bool `json:"enable_metrics"` // 是否启用指标
	EnableTracing bool `json:"enable_tracing"` // 是否启用追踪

	// 回调
	OnStepStart    func(step ExecutionStep) `json:"-"` // 步骤开始回调
	OnStepComplete func(step ExecutionStep) `json:"-"` // 步骤完成回调
	OnError        func(err error)          `json:"-"` // 错误回调

	// 额外选项
	Extra map[string]interface{} `json:"extra,omitempty"` // 额外选项
}

type OrchestratorRequest struct {
	// 任务信息
	TaskID      string                 `json:"task_id"`     // 任务 ID
	TaskType    string                 `json:"task_type"`   // 任务类型
	Description string                 `json:"description"` // 任务描述
	Parameters  map[string]interface{} `json:"parameters"`  // 任务参数

	// 执行策略
	Strategy OrchestratorStrategy `json:"strategy"` // 编排策略

	// 选项
	Options OrchestratorOptions `json:"options"` // 执行选项

	// 元数据
	SessionID string    `json:"session_id"` // 会话 ID
	Timestamp time.Time `json:"timestamp"`  // 时间戳
}

type OrchestratorResponse struct {
	// 执行结果
	Result  interface{} `json:"result"`  // 最终结果
	Status  string      `json:"status"`  // 状态: "success", "failed", "partial"
	Message string      `json:"message"` // 结果消息

	// 执行过程
	ExecutionPlan  []ExecutionStep `json:"execution_plan"`  // 执行计划
	ExecutionSteps []ExecutionStep `json:"execution_steps"` // 实际执行的步骤

	// 性能指标
	TotalLatency time.Duration `json:"total_latency"` // 总延迟
	StartTime    time.Time     `json:"start_time"`    // 开始时间
	EndTime      time.Time     `json:"end_time"`      // 结束时间

	// 元数据
	Metadata map[string]interface{} `json:"metadata"` // 额外元数据
}

type OrchestratorStrategy struct {
	// 执行模式
	Mode string `json:"mode"` // "sequential", "parallel", "hybrid"

	// 重试策略
	EnableRetry  bool `json:"enable_retry"`  // 是否启用重试
	MaxRetries   int  `json:"max_retries"`   // 最大重试次数
	RetryBackoff int  `json:"retry_backoff"` // 重试退避时间（秒）

	// 失败处理
	FailurePolicy string `json:"failure_policy"` // "stop", "continue", "rollback"

	// 超时策略
	GlobalTimeout time.Duration `json:"global_timeout"` // 全局超时
	StepTimeout   time.Duration `json:"step_timeout"`   // 单步超时
}

type PanicHandler interface {
	// HandlePanic processes a recovered panic and returns an appropriate error.
	//
	// Parameters:
	//   - ctx: The execution context
	//   - component: The component where panic occurred (e.g., "runnable", "lifecycle_manager")
	//   - operation: The operation being performed (e.g., "invoke", "init", "start")
	//   - panicValue: The value passed to panic()
	//   - stackTrace: The stack trace at the point of panic
	//
	// Returns:
	//   - An error representing the panic, suitable for returning to callers
	HandlePanic(ctx context.Context, component, operation string, panicValue interface{}, stackTrace string) error
}

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

type PanicLogger interface {
	// LogPanic logs a panic event with all relevant context.
	//
	// Parameters:
	//   - ctx: The execution context
	//   - component: The component where panic occurred
	//   - operation: The operation being performed
	//   - panicValue: The value passed to panic()
	//   - stackTrace: The stack trace at the point of panic
	//   - recoveredError: The error returned from HandlePanic
	LogPanic(ctx context.Context, component, operation string, panicValue interface{}, stackTrace string, recoveredError error)
}

type PanicMetricsCollector interface {
	// RecordPanic records that a panic occurred.
	//
	// Parameters:
	//   - ctx: The execution context
	//   - component: The component where panic occurred
	//   - operation: The operation being performed
	//   - panicValue: The value passed to panic()
	RecordPanic(ctx context.Context, component, operation string, panicValue interface{})
}

type Plugin interface {
	interfaces.Lifecycle

	// Name returns the plugin's unique identifier.
	Name() string

	// Version returns the plugin's version string.
	Version() string

	// GetTools returns tools provided by this plugin.
	GetTools() []DynamicRunnable

	// GetAgents returns agents provided by this plugin.
	GetAgents() []DynamicRunnable

	// GetMiddleware returns middleware provided by this plugin.
	GetMiddleware() []interface{}
}

type PluginConfig struct {
	// Name is the plugin identifier
	Name string

	// Version is the plugin version
	Version string

	// Config is plugin-specific configuration
	Config map[string]interface{}

	// Dependencies lists other plugins this plugin depends on
	Dependencies []PluginDependency

	// Enabled determines if the plugin should be loaded
	Enabled bool
}

type PluginDependency struct {
	// Name of the required plugin
	Name string

	// VersionConstraint (e.g., ">=1.0.0", "~1.2.0")
	VersionConstraint string

	// Optional marks this dependency as optional
	Optional bool
}

type PluginMetadata struct {
	Name        string   `json:"name"`
	Version     string   `json:"version"`
	Description string   `json:"description"`
	Author      string   `json:"author,omitempty"`
	Tags        []string `json:"tags,omitempty"`
	TypeInfo    TypeInfo `json:"type_info"`
}

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

type ReasoningStep struct {
	Step        int           `json:"step"`        // 步骤编号
	Action      string        `json:"action"`      // 执行的操作
	Description string        `json:"description"` // 操作描述
	Result      string        `json:"result"`      // 操作结果
	Duration    time.Duration `json:"duration"`    // 耗时
	Success     bool          `json:"success"`     // 是否成功
	Error       string        `json:"error"`       // 错误信息
}

type RetryPolicy struct {
	MaxRetries int           // 最大重试次数
	Backoff    BackoffPolicy // 退避策略
}

type Runnable[I, O any] interface {
	// Invoke 执行单个输入并返回输出
	Invoke(ctx context.Context, input I) (O, error)

	// Stream 流式执行，返回输出通道
	// 调用者负责从通道读取并处理结果
	Stream(ctx context.Context, input I) (<-chan StreamChunk[O], error)

	// Batch 批量执行多个输入
	Batch(ctx context.Context, inputs []I) ([]O, error)

	// Pipe 连接到另一个 Runnable，形成管道
	// 当前 Runnable 的输出成为下一个 Runnable 的输入
	Pipe(next Runnable[O, any]) Runnable[I, any]

	// WithCallbacks 添加回调处理器
	WithCallbacks(callbacks ...Callback) Runnable[I, O]

	// WithConfig 配置 Runnable
	WithConfig(config RunnableConfig) Runnable[I, O]
}

type RunnableConfig struct {
	// Callbacks 回调处理器列表
	Callbacks []Callback

	// Tags 标签，用于标识和分类
	Tags []string

	// Metadata 元数据
	Metadata map[string]interface{}

	// MaxConcurrency 最大并发数（用于 Batch）
	MaxConcurrency int

	// RetryPolicy 重试策略
	RetryPolicy *RetryPolicy
}

type RunnableFunc[I, O any] struct {
	*BaseRunnable[I, O]
	// contains filtered or unexported fields
}

type RunnablePipe[I, M, O any] struct {
	// contains filtered or unexported fields
}

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

type SimpleAgent = interfaces.Agent

type Span interface {
	End()
	SetAttribute(key string, value interface{})
	SetStatus(code StatusCode, description string)
	RecordError(err error)
}

type State = state.State

type StatusCode int

type StdoutCallback struct {
	*BaseCallback
	// contains filtered or unexported fields
}

type Step interface {
	// Execute 执行步骤
	Execute(ctx context.Context, input interface{}) (interface{}, error)

	// Name 返回步骤名称
	Name() string

	// Description 返回步骤描述
	Description() string
}

type StepExecution struct {
	StepNumber  int           `json:"step_number"` // 步骤编号
	StepName    string        `json:"step_name"`   // 步骤名称
	Description string        `json:"description"` // 步骤描述
	Input       interface{}   `json:"input"`       // 输入
	Output      interface{}   `json:"output"`      // 输出
	Duration    time.Duration `json:"duration"`    // 耗时
	Success     bool          `json:"success"`     // 是否成功
	Error       string        `json:"error"`       // 错误信息
	Skipped     bool          `json:"skipped"`     // 是否跳过
}

type StreamChunk[T any] struct {
	Data  T     // 数据
	Error error // 错误（如果有）
	Done  bool  // 是否完成
}

type StreamConsumer = execution.StreamConsumer

type StreamOptions = execution.StreamOptions

type StreamOutput = execution.StreamOutput

type StreamState = execution.StreamState

type StreamStatus = execution.StreamStatus

type Tool interface {
	// Execute 执行工具
	Execute(ctx context.Context, input *ToolInput) (*ToolOutput, error)

	// Name 返回工具名称
	Name() string

	// Description 返回工具描述
	Description() string

	// Parameters 返回工具参数定义
	Parameters() []ToolParameter
}

type ToolCall struct {
	ToolName string                 `json:"tool_name"` // 工具名称
	Input    map[string]interface{} `json:"input"`     // 输入参数
	Output   interface{}            `json:"output"`    // 输出结果
	Duration time.Duration          `json:"duration"`  // 耗时
	Success  bool                   `json:"success"`   // 是否成功
	Error    string                 `json:"error"`     // 错误信息
}

type ToolInput struct {
	Action     string                 `json:"action"`     // 操作类型
	Parameters map[string]interface{} `json:"parameters"` // 参数
	Context    map[string]interface{} `json:"context"`    // 上下文
}

type ToolOutput struct {
	Success bool        `json:"success"` // 是否成功
	Data    interface{} `json:"data"`    // 输出数据
	Message string      `json:"message"` // 消息
	Error   string      `json:"error"`   // 错误信息
}

type ToolParameter struct {
	Name        string      `json:"name"`        // 参数名称
	Type        string      `json:"type"`        // 参数类型
	Description string      `json:"description"` // 参数描述
	Required    bool        `json:"required"`    // 是否必需
	Default     interface{} `json:"default"`     // 默认值
}

type Tracer interface {
	StartSpan(ctx context.Context, name string, attrs map[string]interface{}) (context.Context, Span)
}

type TracingCallback struct {
	*BaseCallback
	// contains filtered or unexported fields
}

type TypeInfo struct {
	// InputType 输入类型的反射信息
	InputType reflect.Type `json:"-"`

	// OutputType 输出类型的反射信息
	OutputType reflect.Type `json:"-"`

	// InputSchema JSON Schema 描述（可选，用于验证）
	InputSchema string `json:"input_schema,omitempty"`

	// OutputSchema JSON Schema 描述（可选，用于验证）
	OutputSchema string `json:"output_schema,omitempty"`

	// Name 组件名称
	Name string `json:"name"`

	// Description 组件描述
	Description string `json:"description,omitempty"`
}

type TypedToDynamicAdapter[I, O any] struct {
	// contains filtered or unexported fields
}