client

type CallToolParams struct {
	Name      string          `json:"name"`
	Arguments json.RawMessage `json:"arguments,omitempty"`
}

type CallToolResult struct {
	Content           []Content       `json:"content"`
	StructuredContent json.RawMessage `json:"structuredContent,omitempty"`
	IsError           bool            `json:"isError"`
}

type CaptureTx interface {
	Tx
	// Reason is the checkpoint reason the hook must emit.
	Reason() protocol.CheckpointReason
	// Epoch is the epoch being appended to.
	Epoch() EpochState
	// Committed is the committed head H; a replay summary covers findings touched above it.
	Committed() uint64
}

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

type Clock interface {
	Now() time.Time
	After(d time.Duration) <-chan time.Time
}

type Conn interface {
	Call(ctx context.Context, method string, params, result any) error
	Notify(ctx context.Context, method string, params any) error
	SendBinary(ctx context.Context, frame []byte) error
	Handle(h Handler)
	// Done is closed after the session ends and no Handler invocation is running.
	Done() <-chan struct{}
	Close() error
}

type Content struct {
	Type string `json:"type"`
	Text string `json:"text"`
}

type DivergenceError struct {
	Head   uint64
	Reason string
}

type Entry struct {
	Seq       uint64
	Type      protocol.RecordType
	State     RecordState
	Bytes     []byte
	Hash      protocol.Hash
	ChainHash protocol.Hash
}

type EpochState struct {
	ID         protocol.EpochID
	OpenReason string
	PrevEpoch  *protocol.EpochID
	PrevHead   *uint64
	Registered bool
	Chain      protocol.Chain
}

type Handler func(ctx context.Context, req *Request) (any, error)

type Hooks interface {
	// CaptureReplay appends only the replay anchor (reason 5) and returns the lifecycle summary as of it (SPEC 8.4 step 3).
	CaptureReplay(tx CaptureTx) (protocol.SummaryParams, error)
	// Rebaseline appends the full checkpoint that starts a new epoch.
	Rebaseline(tx CaptureTx) error
	BundleAvailable(protocol.BundleAvailableParams)
	Tools() []Tool
	Tool(ctx context.Context, name string, args json.RawMessage) (any, error)
	Health() any
}

type Identity struct {
	TargetID     string
	TargetType   string
	Credential   string
	CredentialID string
	MachineID    string
}

type InitializeResult struct {
	ProtocolVersion string         `json:"protocolVersion"`
	Capabilities    map[string]any `json:"capabilities"`
	ServerInfo      ServerInfo     `json:"serverInfo"`
}

type MemOptions struct {
	WriterID protocol.WriterID // zero generates a random writer ID
	Identity Identity
	Now      func() time.Time
}

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

type Options struct {
	Store     Store
	Transport Transport
	Hooks     Hooks
	Agent     protocol.AgentInfo
	Logger    *slog.Logger
	Clock     Clock
	// Jitter returns a random duration in [0, ceiling]; the default is uniform (full jitter).
	Jitter               func(ceiling time.Duration) time.Duration
	BackoffBase          time.Duration // default 1s
	BackoffMax           time.Duration // default 5m
	ReplayBytesPerSecond int64         // backlog replay rate limit; 0 is unlimited
	HealthInterval       time.Duration // default 60s; negative disables health reports
	CallTimeout          time.Duration // default 30s
	MaxBatchRecords      int           // default 512
	DisableCompression   bool
}

type RecordState int

type RejectError struct {
	Code string
	Err  error
}

type Request struct {
	Method       string
	Params       json.RawMessage
	Notification bool
}

type ServerInfo struct {
	Name    string `json:"name"`
	Version string `json:"version"`
}

type Status struct {
	Connected  bool
	SessionID  string
	Epoch      protocol.EpochID
	Registered bool
	Head       uint64
	Watermark  uint64
	// BacklogRecords and BacklogBytes count what Store.Entries(0) returns.
	BacklogRecords int
	BacklogBytes   int64
	Sessions       int
	Rebaselines    int
	LastError      string
	LastErrorCode  string
	Halted         string
	Compat         protocol.Compat
}

type StopError struct{ Code string }

type Store interface {
	WriterID() protocol.WriterID
	Incarnation() uint64
	Identity() Identity
	SetIdentity(Identity) error
	Epoch() (EpochState, bool)
	OpenEpoch(reason string, prev *protocol.EpochID, prevHead *uint64) (protocol.EpochID, error)
	MarkRegistered() error
	Do(fn func(tx Tx) error) error
	Entries(fromSeq uint64) []*Entry
	MarkTransmitted(seqs ...uint64) error
	Commit(epoch protocol.EpochID, seq uint64, chainHash protocol.Hash) error
	LastCommitted() (protocol.ChainPoint, bool)
	DiscardAbove(seq uint64) error
	Notify() <-chan struct{}
	SetHalted(code string) error
	Halted() (string, bool)
}

type Tool struct {
	Name        string          `json:"name"`
	Description string          `json:"description,omitempty"`
	InputSchema json.RawMessage `json:"inputSchema"`
}

type ToolsListResult struct {
	Tools []Tool `json:"tools"`
}

type Transport interface {
	Dial(ctx context.Context) (Conn, error)
}

type Tx interface {
	Append(t protocol.RecordType, build func(env protocol.Envelope) (*protocol.Record, error)) (*Entry, error)
}