claudecode

type Agent struct {
	// ID is the agentId, from the file name agent-<agentId>.jsonl.
	ID         string
	Meta       *AgentMeta
	Transcript *Transcript
	// MetaRaw and MetaErr hold a meta file that did not decode; Meta is
	// nil then.
	MetaRaw json.RawMessage
	MetaErr error
}

type AgentMeta struct {
	AgentType     string `json:"agentType"`
	Description   string `json:"description"`
	ToolUseID     string `json:"toolUseId"`
	ParentAgentID string `json:"parentAgentId"`
	IsFork        bool   `json:"isFork"`
	Name          string `json:"name"`
	TeamName      string `json:"teamName"`
	Model         string `json:"model"`
	SpawnDepth    int    `json:"spawnDepth"`
	// RequestShape is "foreground" for an agent the call waited on and
	// "background" for one it started and left running.
	RequestShape string `json:"requestShape"`

	Members

	// Raw is the file as read.
	Raw json.RawMessage `json:"-"`
}

type Attachment struct {
	Type string `json:"type"`

	Members
}

type Call struct {
	Use *ContentBlock
	// Line holds the tool_use block.
	Line *Line
	// Result is the user line holding the tool_result; nil when the call
	// was never answered.
	Result *Line
	// ResultBlock is the tool_result block within Result.
	ResultBlock *ContentBlock
}

type CompactMetadata struct {
	Trigger           string             `json:"trigger"`
	PreTokens         int64              `json:"preTokens"`
	PostTokens        int64              `json:"postTokens"`
	PreservedSegment  *PreservedSegment  `json:"preservedSegment"`
	PreservedMessages *PreservedMessages `json:"preservedMessages"`

	Members
}

type Content struct {
	// Text is the content when it was a string.
	Text string
	// IsText says the content was a string.
	IsText bool
	Blocks []*ContentBlock
}

type ContentBlock struct {
	Type string `json:"type"`

	// text
	Text string `json:"text"`
	// thinking
	Thinking  string `json:"thinking"`
	Signature string `json:"signature"`
	// redacted_thinking
	Data string `json:"data"`
	// tool_use, server_tool_use
	ID    string          `json:"id"`
	Name  string          `json:"name"`
	Input json.RawMessage `json:"input"`
	// tool_result
	ToolUseID string   `json:"tool_use_id"`
	Content   *Content `json:"content"`
	IsError   bool     `json:"is_error"`
	// image, document
	Source *MediaSource `json:"source"`
	// tool_reference
	ToolName string `json:"tool_name"`

	Members

	// Raw is set, with Err, when the block is not of the shapes this
	// type declares: a server tool result whose content is an object, a
	// block whose source is a string, a null. Only Type is decoded
	// then, when the block has a string type; Raw is written back
	// verbatim.
	Raw json.RawMessage `json:"-"`
	Err error           `json:"-"`
}

type Line struct {
	Type string `json:"type"`

	// The envelope of the tree's lines.
	UUID              string `json:"uuid"`
	ParentUUID        string `json:"parentUuid"`
	LogicalParentUUID string `json:"logicalParentUuid"`
	IsSidechain       bool   `json:"isSidechain"`
	SessionID         string `json:"sessionId"`
	AgentID           string `json:"agentId"`
	Timestamp         string `json:"timestamp"`
	CWD               string `json:"cwd"`
	GitBranch         string `json:"gitBranch"`
	Version           string `json:"version"`
	UserType          string `json:"userType"`
	Entrypoint        string `json:"entrypoint"`

	// user and assistant.
	Message *Message `json:"message"`

	// user.
	IsMeta                    bool            `json:"isMeta"`
	IsCompactSummary          bool            `json:"isCompactSummary"`
	IsVisibleInTranscriptOnly bool            `json:"isVisibleInTranscriptOnly"`
	ToolUseResult             json.RawMessage `json:"toolUseResult"`
	SourceToolAssistantUUID   string          `json:"sourceToolAssistantUUID"`
	PermissionMode            string          `json:"permissionMode"`

	// assistant.
	RequestID         string                     `json:"requestId"`
	APIBlockIndex     int                        `json:"apiBlockIndex"`
	RequestedModel    string                     `json:"requestedModel"`
	WireToolInputs    map[string]json.RawMessage `json:"wireToolInputs"`
	IsAPIErrorMessage bool                       `json:"isApiErrorMessage"`
	Error             json.RawMessage            `json:"error"`
	APIErrorStatus    int                        `json:"apiErrorStatus"`

	// attachment.
	Attachment          *Attachment `json:"attachment"`
	Rendered            []Rendered  `json:"rendered"`
	RenderedRole        string      `json:"renderedRole"`
	RenderedInHumanTurn []Rendered  `json:"renderedInHumanTurn"`

	// system.
	Subtype         string           `json:"subtype"`
	Content         json.RawMessage  `json:"content"`
	CompactMetadata *CompactMetadata `json:"compactMetadata"`

	// Side records.
	AITitle         string        `json:"aiTitle"`
	CustomTitle     string        `json:"customTitle"`
	Summary         string        `json:"summary"`
	LeafUUID        string        `json:"leafUuid"`
	LastPrompt      string        `json:"lastPrompt"`
	ParentSessionID string        `json:"parentSessionId"`
	ParentLastUUID  string        `json:"parentLastUuid"`
	Shape           *RequestShape `json:"shape"`

	Members

	// No is the line's 1-based number in its file.
	No int `json:"-"`
	// Raw is the line as read, without NUL bytes.
	Raw json.RawMessage `json:"-"`
	// Err is set when the line is JSON but does not decode as a line of
	// this package's types. The envelope members that are strings
	// (type, uuid, parentUuid, logicalParentUuid, timestamp, cwd,
	// gitBranch, version, sessionId, agentId, subtype) are still read,
	// so the line keeps its place in the tree; Raw is written back.
	Err error `json:"-"`
}

type LineError struct {
	No  int
	Err error
}

type MediaSource struct {
	Type      string `json:"type"`
	MediaType string `json:"media_type"`
	Data      string `json:"data"`
	URL       string `json:"url"`
	FileID    string `json:"file_id"`

	Members
}

type Members = jsonline.Members

type Message struct {
	ID           string          `json:"id"`
	Type         string          `json:"type"`
	Role         string          `json:"role"`
	Model        string          `json:"model"`
	Content      Content         `json:"content"`
	StopReason   string          `json:"stop_reason"`
	StopSequence string          `json:"stop_sequence"`
	Usage        json.RawMessage `json:"usage"`

	Members
}

type OutputTokensDetails struct {
	ThinkingTokens int64 `json:"thinking_tokens"`

	Members
}

type PreservedMessages struct {
	AnchorUUID string   `json:"anchorUuid"`
	UUIDs      []string `json:"uuids"`
	AllUUIDs   []string `json:"allUuids"`

	Members
}

type PreservedSegment struct {
	AnchorUUID string `json:"anchorUuid"`
	HeadUUID   string `json:"headUuid"`
	TailUUID   string `json:"tailUuid"`

	Members
}

type PromptSnapshot struct {
	CLIPrefix    string `json:"cliPrefix"`
	SystemPrompt []string
	Tools        []SnapshotTool
	// HasTools says the snapshot listed tools; one without them leaves
	// the tools as they were.
	HasTools bool
	// EchoWireToolInputs says the requests replay a tool call's
	// arguments as the model wrote them (wireToolInputs) rather than as
	// the CLI normalised them.
	EchoWireToolInputs bool
}

type Rendered struct {
	Content string `json:"content"`

	Members
}

type RequestShape struct {
	System Content    `json:"system"`
	Tools  []*ToolDef `json:"tools"`

	Members
}

type Response struct {
	MessageID string
	RequestID string
	Lines     []*Line
	Calls     []*Call
	// Extra holds result lines that belong to this response and carry
	// more than its results: other blocks, or results the tree could
	// not place (see [Tree.Unplaced]).
	Extra []*Line
	// Between holds the lines on the chain from one block of the
	// response to the next that are not the response's own, in the
	// order the chain runs. Claude Code sends them in the user turn
	// after the tool results.
	Between []*Line
}

type Session struct {
	// ID is the session's ID: the main transcript's file name.
	ID     string
	Main   *Transcript
	Agents []*Agent
}

type SnapshotTool struct {
	Name        string   `json:"name"`
	Description string   `json:"description"`
	Schema      *ToolDef `json:"schema"`
}

type ToolDef struct {
	Name        string          `json:"name"`
	Description string          `json:"description"`
	InputSchema json.RawMessage `json:"input_schema"`

	Members
}

type Transcript struct {
	// Path is the file the transcript was read from; empty when it was
	// read from a reader.
	Path  string
	Lines []*Line
	// Errors lists the lines that could not be read, which the reader
	// skipped.
	Errors []LineError
	// NULLines lists the lines that held NUL bytes, which the reader
	// removed before decoding. Claude Code leaves runs of them where a
	// write was torn.
	NULLines []int
}

type Tree struct {
	// Units are every unit, ordered by the file position of the line
	// each starts at.
	Units []*Unit
	Roots []*Unit
	// Head holds the side records written before the first tree line.
	Head []*Line
	// Orphans are tool_result lines none of whose results answer a call
	// in the transcript. Each is also a unit of its own.
	Orphans []*Line
	// Unplaced are result blocks on a line that belongs to a response
	// that are not that response's: a second result for a call already
	// answered, a result for another response's call, or for none.
	Unplaced []Unplaced
	// Dangling lists lines whose parent is not in the transcript; each
	// is a root here.
	Dangling []*Line
	// Cycles lists lines whose parent links led back to themselves; the
	// first line met of each cycle is a root here.
	Cycles []*Line
	// contains filtered or unexported fields
}

type Unit struct {
	// Line is the line of a single-line unit; nil for a response.
	Line     *Line
	Response *Response
	Parent   *Unit
	Children []*Unit
	// Side holds the side records written after this unit's lines and
	// before the next tree line, in file order.
	Side []*Line
	// Logical says Parent is a compaction's logical parent, not the
	// line's parentUuid.
	Logical bool
	// contains filtered or unexported fields
}

type Unplaced struct {
	Line  *Line
	Block *ContentBlock
	// Why is "duplicate", "other-response" or "no-call".
	Why string
}

type Usage struct {
	InputTokens              int64                `json:"input_tokens"`
	OutputTokens             int64                `json:"output_tokens"`
	CacheCreationInputTokens int64                `json:"cache_creation_input_tokens"`
	CacheReadInputTokens     int64                `json:"cache_read_input_tokens"`
	OutputTokensDetails      *OutputTokensDetails `json:"output_tokens_details"`

	Members
}