wire

type Adapter interface {
	// Handshake writes protocol initialization (control initialize, thread
	// setup) and returns any immediately-known events. It runs inside Start,
	// which blocks until it returns. A non-nil error fails the start.
	Handshake(ctx context.Context, w *Writer) ([]Event, error)
	// EncodePrompt renders one user turn as one frame.
	EncodePrompt(p Prompt) ([]byte, error)
	// Parse maps one stdout line to zero or more events.
	Parse(line []byte) []Event
	// EncodeDecision answers a permission request.
	EncodeDecision(id string, d Decision) ([]byte, error)
	// Exit maps process exit (after stdout EOF) to events. It is not called
	// when the session produced its own terminal result and exited cleanly.
	Exit(code int, err error, stderr string) []Event
}

type Attachment struct {
	// MIME is the media type, for example "image/png".
	MIME string
	// Path is a file on disk the library reads and encodes itself.
	Path string
	// Data is the raw bytes, used when Path is empty.
	Data []byte
}

type ConcurrentPrompter interface {
	ConcurrentPrompt() bool
}

type Config struct {
	// MaxFrameBytes bounds one frame. Zero uses DefaultMaxFrameBytes.
	MaxFrameBytes int
	// LogPath records the frames in and out as NDJSON, one line per frame.
	// Secrets are not redacted, so the file is created mode 0600. Stream
	// fragments are left out unless LogFragments is set.
	LogPath string
	// FragmentLogPath gets the buffered fragments of the open message when
	// the stream fails or ends before the complete message, mode 0600.
	FragmentLogPath string
	// LogFragments writes every fragment to LogPath.
	LogFragments bool
}

type Decision struct {
	Allow        bool
	Message      string
	UpdatedInput json.RawMessage
}

type Delivery string

type Event struct {
	Type EventType
	At   time.Time

	// Turn counts completed user turns. It is 1 for the first turn.
	Turn int

	// SessionID carries the vendor session/thread id on init and result.
	SessionID string

	// Text is assistant/user text or a short human summary.
	Text string
	// Delta marks Text as a stream delta rather than a complete block.
	Delta bool

	Tool       *ToolEvent
	Permission *Permission
	Result     *Result
	Usage      *Usage
	Limits     *Limits
	// Status is the tracker hint of a status event.
	Status SessionStatus

	// Error is a human-readable failure for EventError/EventExit.
	Error string
	// Code is the stable machine code of a failure (for example
	// "frame_too_large", "process_exited"). Consumers map it to their own
	// text; the library never ships operator prose.
	Code string
	// EndReason is the classified failure family (auth|limit|entitlement|...).
	EndReason string
	// ExitCode is set on EventExit.
	ExitCode *int

	// Raw is the vendor frame, kept for fixtures and the run log.
	Raw []byte
}

type EventType string

type FragmentClassifier interface {
	Fragment(line []byte) bool
}

type InterruptEncoder interface {
	EncodeInterrupt() ([]byte, error)
}

type LimitWindow struct {
	// Key is five_hour, daily, weekly, monthly, or custom.
	Key string
	// Scope narrows the window, for example "opus" or a Codex limit id.
	Scope string
	// Minutes is the window length. It is 0 when not known.
	Minutes int
	// UsedPercent is 0–100.
	UsedPercent float64
	// ResetsAt is zero when not known.
	ResetsAt time.Time
}

type Limits struct {
	// Plan is the vendor plan name, for example "plus". Empty when not known.
	Plan string
	// Rejected reports that the harness refused the last request on a limit.
	Rejected bool
	Windows  []LimitWindow
}

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

type Permission struct {
	ID       string
	Tool     string
	Kind     ToolKind
	Question string
	Input    string
	Options  []string
	// ToolUseID is the tool_use id the request belongs to, when the vendor
	// carries it. A consumer joins an approval card to its tool chip.
	ToolUseID string
}

type Prompt struct {
	Text string
	// Kind is the origin: job|assistant|agent|memory_fix|followup|wake. The
	// library never interprets it; it is carried for consumer log lines.
	Kind string
	// Attachments are images or files sent with the turn, images first.
	Attachments []Attachment
}

type Prompter interface {
	PromptSession(ctx context.Context, p Prompt) error
}

type Result struct {
	Subtype   string
	IsError   bool
	Text      string
	SessionID string
	Usage     Usage
	EndReason string
	// Code is the classified machine code of an error result.
	Code string
}

type SendOps struct {
	Active func() bool
	Prompt func(context.Context, Prompt) error
	// Steer is nil when the session cannot steer.
	Steer func(context.Context, Prompt) error
	// Concurrent means Prompt is safe during a turn.
	Concurrent bool
}

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

type SessionStatus string

type SteerAdapter interface {
	Steer(ctx context.Context, p Prompt) error
}

type ToolEvent struct {
	ID     string
	Name   string
	Kind   ToolKind
	Input  string
	Output string
	Status string // started|completed|failed
	// Paths lists the files an edit touches, where the protocol says so.
	Paths    []string
	ExitCode *int
}

type ToolKind string

type TurnStater interface {
	TurnActive() bool
}

type Usage struct {
	Input         int64
	Output        int64
	CacheRead     int64
	CacheCreation int64
	Model         string
	CostUSD       float64
}

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

type WriterSetter interface {
	SetWriter(*Writer)
}