graph

type Checkpoint struct {
	State State
	Next  NodeID
}

type Checkpointer interface {
	// Get returns the checkpoint for a thread id, or nil if none exists.
	Get(ctx context.Context, threadID string) (*Checkpoint, error)
	// Put stores a checkpoint for a thread id.
	Put(ctx context.Context, threadID string, cp *Checkpoint) error
}

type Command struct {
	// Update is the state update to apply.
	Update State
	// Goto is a node to route to next. If empty, normal edges apply.
	Goto NodeID
	// Resume is a value to resume an interrupted run with.
	Resume any
	// ResumeSet marks whether Resume was explicitly set.
	ResumeSet bool
	// Send contains parallel branches to execute.
	Send []Send
}

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

type CondFunc func(ctx context.Context, state State) (NodeID, error)

type ConditionalEdges struct {
	From NodeID
	Cond CondFunc
}

type Edge struct {
	From NodeID
	To   NodeID
}

type FilterTransformer struct {
	Keep map[NodeID]bool
}

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

type InterruptedError struct {
	Checkpoint *Checkpoint
}

type Message struct {
	Role       string
	Content    string
	ToolCalls  []ToolCall
	ToolCallID string
	Name       string
}

type Node struct {
	ID   NodeID
	Run  NodeFunc
	Name string
}

type NodeFunc func(ctx context.Context, state State) (State, error)

type NodeID string

type PassthroughTransformer struct{}

type RunConfig struct {
	// ThreadID identifies the execution thread for checkpointing.
	ThreadID string
	// InterruptBefore/After pause execution at matching nodes.
	InterruptBefore []NodeID
	InterruptAfter  []NodeID
	// Resume supplies a value to resume an interrupted run.
	Resume any
}

type RunOption func(*RunConfig)

type Send struct {
	Node  NodeID
	Value any
}

type State = map[string]any

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

type StreamTransformer interface {
	// Transform receives the input stream and returns a transformed stream.
	Transform(ctx context.Context, in <-chan StreamUpdate) (<-chan StreamUpdate, error)
}

type StreamTransformerFunc func(ctx context.Context, in <-chan StreamUpdate) (<-chan StreamUpdate, error)

type StreamUpdate struct {
	Node  NodeID
	State State
}

type Tool struct {
	// Name is the tool's unique name.
	Name string
	// Description describes when to use the tool.
	Description string
	// ArgsSchema is the JSON schema for the tool arguments.
	ArgsSchema map[string]any
	// Func executes the tool.
	Func ToolFn
}

type ToolCall struct {
	ID    string
	Name  string
	Args  map[string]any
	Index int
}

type ToolFn func(ctx context.Context, input string) (string, error)

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