inspect

type Call struct {
	CallID string
	Name   string
	Args   string
	// State is the path's reading of the call (agentsession's CallState).
	State string
	// Decisions are the decision entries for the call, in order: each the
	// verdict, who gave it and why.
	Decisions []Decision
	// Verdicts are the policy verdicts recorded for the call
	// (agentpolicy:verdict): the rule and the source behind a decision.
	Verdicts []Verdict
	// Asked are the questions put to the user about the call, and what
	// became of them.
	Asked []session.Elicitation
	// Dispatch is the dispatch entry, when the call was handed to its tool.
	Dispatch *Dispatch
	// Callees are the call's subsession and peer links on the path, in
	// order, with what became of each.
	Callees []Callee
	// Output is what the call returned, and OutputEntry the entry that
	// holds it; HasOutput says whether there is one.
	Output      string
	OutputEntry string
	HasOutput   bool
	// Grants are the skill grants in force when the call was made, and
	// whether and when they were revoked later.
	Grants []Grant
}

type Callee struct {
	Entry   string
	Rel     string
	Session string
	// URL, Task and Context name a callee in another system.
	URL     string
	Task    string
	Context string
	// Dispatch is the dispatch the link belongs to, "" when the path
	// records none.
	Dispatch string
	// CancelSent says a cancel notice names the link: the caller asked
	// the callee to stop and did not wait.
	CancelSent bool
	// Answered says the call's output came from this callee.
	Answered bool
}

type Config struct {
	Model string
	// InstructionsParts is the number of parts the instructions are
	// built from, and InstructionsLen their length in runes.
	InstructionsParts int
	InstructionsLen   int
	Tools             int
	// Known is false when the context at the end of the line could not be
	// built, with Err saying why.
	Known bool
	Err   string
}

type Decision struct {
	Entry   string
	Verdict string
	By      string
	Reason  string
	Args    string
}

type Dispatch struct {
	Entry          string
	Target         string
	IdempotencyKey string
	Time           time.Time
}

type Entry struct {
	ID   string
	Type string
	Time time.Time
	// Title says what the entry is: "agent message", "function call
	// upper", "compaction".
	Title string
	// KeptFromModel is set for an item the filter kept out of the
	// model's context.
	KeptFromModel bool
	// Response is the response the entry's item belongs to, when it has
	// one.
	Response *Response
	// Call is set for a function call and for its output.
	Call *Call
	// Fold is set for a compaction.
	Fold *Fold
}

type Fold struct {
	// FirstKept is the entry the context keeps from, described.
	FirstKept     string
	FirstKeptDesc string
	// Folded is how many items sit on the path before FirstKept: the ones
	// the summary stands for in the model's request. They stay on the
	// record.
	Folded int
	// SummaryLen is the summary's length in runes, and SummaryType the
	// item type that carries it.
	SummaryLen   int
	SummaryType  string
	SummaryStart string
	// Pinned describes the items carried over whole.
	Pinned       []string
	TokensBefore int
	Usage        *openresponses.Usage
	// Call is the model call the fold made, when the compaction records one.
	Call *session.FoldCall
}

type Grant struct {
	// Skill is the skill's listed name, Source the source the rule was
	// granted under.
	Skill  string
	Source string
	Rule   string
	// Since is the verdict entry that recorded the grant.
	Since string
	// Ended is the verdict entry that revoked the source's grants, "" while
	// they hold on the whole path.
	Ended string
}

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

type Manifest struct {
	Entries []ManifestEntry `json:"entries"`
	Omitted []ManifestEntry `json:"omitted,omitempty"`
	// Entry is the record entry the manifest in force came from.
	Entry string `json:"-"`
}

type ManifestEntry struct {
	Scope  string `json:"scope"`
	Name   string `json:"name"`
	Hash   string `json:"hash"`
	Bytes  int    `json:"bytes"`
	Reason string `json:"reason,omitempty"`
}

type Option func(*Inspector)

type PathVerify struct {
	Responses  int
	Verified   int
	Unhashed   int
	Mismatched int
	Failed     int
	// Problems lists what did not verify, response by response, the
	// mismatches first.
	Problems []Problem
}

type Problem struct {
	Response string
	Verify   Verify
}

type Refusal struct {
	Entry string
	Why   string
}

type Response struct {
	Entry       string
	ResponseID  string
	Model       string
	Status      string
	Usage       *openresponses.Usage
	LatencyMS   int64
	Attempts    int
	RequestHash string
	Verify      Verify
}

type Session struct {
	ID            string
	Name          string
	CWD           string
	Harness       string
	Format        string
	Created       time.Time
	ParentSession string
	Base          string
	SpawnedBy     string
	// Entries is the session's entry count, Path the length of the viewed
	// line.
	Entries int
	Path    int

	// Verify is the tally over the responses on the viewed line.
	Verify PathVerify
	// Usage is the token usage of the model calls on the viewed line,
	// responses and folds.
	Usage openresponses.Usage
	// UsageByModel is Usage split by the model each call was made under.
	UsageByModel map[string]openresponses.Usage
	// Cost is the viewed line's cost in US dollars under the cost source,
	// and Priced says every call was priced (false with no source).
	Cost   float64
	Priced bool
	// Unpriced lists the models that have usage on the viewed line but
	// that the cost source has no price for, sorted.
	Unpriced []string
	// Config is what the record has in force at the end of the line.
	Config Config
	// Refs are the refs that point at the session, RefsErr why they could
	// not be listed (a store without refs).
	Refs    []agentsession.Ref
	RefsErr string
	// Manifest is the memory manifest in force, nil when the line holds
	// none; ManifestRefused lists the records the fold refused, which
	// leave the manifest in force as it was.
	Manifest        *Manifest
	ManifestRefused []Refusal
	// Grants are the skill grants in force at the end of the line, and
	// those a revocation ended.
	Grants []Grant
}

type Source interface {
	Read(ctx context.Context, sessionID string) (*agentsession.Session, error)
	Refs(ctx context.Context, sessionID string) ([]agentsession.Ref, error)
}

type Verdict struct {
	Entry      string `json:"-"`
	RunID      string `json:"run_id,omitempty"`
	Turn       int    `json:"turn,omitempty"`
	CallID     string `json:"call_id,omitempty"`
	Tool       string `json:"tool,omitempty"`
	Guard      string `json:"guard,omitempty"`
	Action     string `json:"action"`
	Rule       string `json:"rule,omitempty"`
	Source     string `json:"source,omitempty"`
	SourceHash string `json:"source_hash,omitempty"`
	Note       string `json:"note,omitempty"`
	Reason     string `json:"reason,omitempty"`
	By         string `json:"by,omitempty"`
	Held       bool   `json:"held,omitempty"`
	Subject    string `json:"subject,omitempty"`
	Confined   string `json:"confined,omitempty"`
}

type Verify struct {
	State VerifyState
	// Why is the cause an unhashed response names, or the error of a
	// mismatch or a failure.
	Why string
}

type VerifyState int