359 lines
10 KiB
Go
359 lines
10 KiB
Go
package claude
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// maxTranscriptBytes bounds one history read. A Claude session file grows with
|
|
// every turn; past this bound the caller is told the truth instead of being
|
|
// served a silently truncated conversation.
|
|
const maxTranscriptBytes = 64 << 20
|
|
|
|
type transcriptEntry struct {
|
|
Type string `json:"type"`
|
|
Subtype string `json:"subtype"`
|
|
UUID string `json:"uuid"`
|
|
IsSidechain bool `json:"isSidechain"`
|
|
Timestamp string `json:"timestamp"`
|
|
Cwd string `json:"cwd"`
|
|
Message struct {
|
|
ID string `json:"id"`
|
|
Role string `json:"role"`
|
|
Model string `json:"model"`
|
|
Content json.RawMessage `json:"content"`
|
|
} `json:"message"`
|
|
ToolUseResult json.RawMessage `json:"toolUseResult"`
|
|
Compact json.RawMessage `json:"compactMetadata"`
|
|
}
|
|
|
|
func readTranscript(path string) ([]transcriptEntry, error) {
|
|
file, err := os.Open(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer file.Close()
|
|
info, err := file.Stat()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if info.Size() > maxTranscriptBytes {
|
|
return nil, fmt.Errorf("the Claude session transcript is larger than the %d MiB history limit", maxTranscriptBytes>>20)
|
|
}
|
|
scanner := bufio.NewScanner(file)
|
|
scanner.Buffer(make([]byte, 0, 64<<10), maxLineBytes)
|
|
var entries []transcriptEntry
|
|
for scanner.Scan() {
|
|
line := scanner.Bytes()
|
|
if len(line) == 0 {
|
|
continue
|
|
}
|
|
var entry transcriptEntry
|
|
if json.Unmarshal(line, &entry) == nil {
|
|
entries = append(entries, entry)
|
|
}
|
|
}
|
|
if err := scanner.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return entries, nil
|
|
}
|
|
|
|
// transcriptSession describes a session from its retained file, so the manager
|
|
// can resolve a registry row after a restart.
|
|
func transcriptSession(id string) (protocol.ChatSession, bool) {
|
|
path := findTranscriptFile(id)
|
|
if path == "" {
|
|
return protocol.ChatSession{}, false
|
|
}
|
|
session := protocol.ChatSession{ID: id, Backend: Backend, ModelProvider: Backend, Tag: protocol.ChatSessionTagOperator}
|
|
entries, err := readTranscript(path)
|
|
if err != nil {
|
|
return session, true
|
|
}
|
|
for _, entry := range entries {
|
|
if entry.Cwd != "" && session.Directory == "" {
|
|
session.Directory = entry.Cwd
|
|
}
|
|
if stamp, ok := transcriptTime(entry.Timestamp); ok {
|
|
if session.CreatedAt == 0 || stamp < session.CreatedAt {
|
|
session.CreatedAt = stamp
|
|
}
|
|
if stamp > session.UpdatedAt {
|
|
session.UpdatedAt = stamp
|
|
}
|
|
}
|
|
if entry.Type == "assistant" && entry.Message.Model != "" && !entry.IsSidechain {
|
|
session.Model = entry.Message.Model
|
|
}
|
|
}
|
|
return session, true
|
|
}
|
|
|
|
func transcriptTime(text string) (int64, bool) {
|
|
if strings.TrimSpace(text) == "" {
|
|
return 0, false
|
|
}
|
|
parsed, err := time.Parse(time.RFC3339Nano, text)
|
|
if err != nil {
|
|
return 0, false
|
|
}
|
|
return parsed.UnixMilli(), true
|
|
}
|
|
|
|
// transcriptMessages maps the CLI's own session file into chat messages. It
|
|
// merges the JSONL's one-entry-per-content-block shape by message id, attaches
|
|
// tool results to the call that produced them, and never invents a turn.
|
|
func (s *session) transcriptMessages(limit int, cursor string) (protocol.ChatHistoryPage, error) {
|
|
path := findTranscriptFile(s.id)
|
|
if path == "" {
|
|
return protocol.ChatHistoryPage{Messages: []protocol.ChatMessage{}}, nil
|
|
}
|
|
entries, err := readTranscript(path)
|
|
if err != nil {
|
|
return protocol.ChatHistoryPage{}, err
|
|
}
|
|
s.mu.Lock()
|
|
prompts := append([]promptRecord(nil), s.prompts...)
|
|
s.mu.Unlock()
|
|
promptIDs := map[string][]string{}
|
|
for _, prompt := range prompts {
|
|
if prompt.id == "" || prompt.text == "" {
|
|
continue
|
|
}
|
|
promptIDs[prompt.text] = append(promptIDs[prompt.text], prompt.id)
|
|
}
|
|
usedPrompts := map[string]int{}
|
|
takePromptID := func(text string) string {
|
|
text = strings.TrimSpace(text)
|
|
ids := promptIDs[text]
|
|
if len(ids) == 0 {
|
|
return ""
|
|
}
|
|
index := usedPrompts[text]
|
|
if index >= len(ids) {
|
|
return ""
|
|
}
|
|
usedPrompts[text] = index + 1
|
|
return ids[index]
|
|
}
|
|
messages := []protocol.ChatMessage{}
|
|
messageIndex := map[string]int{}
|
|
toolIndex := map[string][2]int{} // tool id -> message/part index
|
|
for _, entry := range entries {
|
|
if entry.IsSidechain {
|
|
continue
|
|
}
|
|
switch entry.Type {
|
|
case "assistant":
|
|
messageID := strings.TrimSpace(entry.Message.ID)
|
|
if messageID == "" {
|
|
messageID = entry.UUID
|
|
}
|
|
if messageID == "" {
|
|
continue
|
|
}
|
|
created, _ := transcriptTime(entry.Timestamp)
|
|
index, exists := messageIndex[messageID]
|
|
if !exists {
|
|
messages = append(messages, protocol.ChatMessage{ID: messageID, SessionID: s.id, Role: protocol.ChatRoleAssistant, Model: entry.Message.Model, CreatedAt: created, Parts: []protocol.ChatPart{}})
|
|
index = len(messages) - 1
|
|
messageIndex[messageID] = index
|
|
}
|
|
if entry.Message.Model != "" {
|
|
messages[index].Model = entry.Message.Model
|
|
}
|
|
blocks := decodeBlocks(entry.Message.Content)
|
|
for _, block := range blocks {
|
|
switch block.Type {
|
|
case "text":
|
|
if strings.TrimSpace(block.Text) == "" {
|
|
continue
|
|
}
|
|
ordinal := textOrdinal(messages[index].Parts, protocol.ChatPartText)
|
|
part := protocol.ChatPart{Type: protocol.ChatPartText, ID: protocol.ChatDeltaPartID(messageID, protocol.ChatPartText, ordinal), Text: block.Text}
|
|
messages[index].Parts = append(messages[index].Parts, part)
|
|
case "thinking":
|
|
if strings.TrimSpace(block.Thinking) == "" {
|
|
continue
|
|
}
|
|
ordinal := textOrdinal(messages[index].Parts, protocol.ChatPartReasoning)
|
|
part := protocol.ChatPart{Type: protocol.ChatPartReasoning, ID: protocol.ChatDeltaPartID(messageID, protocol.ChatPartReasoning, ordinal), Text: block.Thinking}
|
|
messages[index].Parts = append(messages[index].Parts, part)
|
|
case "tool_use":
|
|
if block.ID == "" {
|
|
continue
|
|
}
|
|
part := protocol.ChatPart{
|
|
Type: protocol.ChatPartTool,
|
|
ID: block.ID,
|
|
Name: block.Name,
|
|
State: &protocol.ChatToolState{
|
|
Status: protocol.ChatToolRunning,
|
|
Input: truncateJSON(block.Input, 64<<10),
|
|
},
|
|
}
|
|
messages[index].Parts = append(messages[index].Parts, part)
|
|
toolIndex[block.ID] = [2]int{index, len(messages[index].Parts) - 1}
|
|
}
|
|
}
|
|
case "user":
|
|
if len(entry.Message.Content) > 0 && entry.Message.Content[0] == '"' {
|
|
// A string user entry is harness feedback (local command output or
|
|
// a tool protocol message), never a turn the operator sent.
|
|
continue
|
|
}
|
|
blocks := decodeBlocks(entry.Message.Content)
|
|
var text string
|
|
files := []protocol.ChatPart{}
|
|
hasResult := false
|
|
for _, block := range blocks {
|
|
switch block.Type {
|
|
case "tool_result":
|
|
hasResult = true
|
|
applyTranscriptToolResult(&messages, toolIndex, block)
|
|
case "text":
|
|
if strings.TrimSpace(block.Text) == "" {
|
|
continue
|
|
}
|
|
if text != "" {
|
|
text += "\n"
|
|
}
|
|
text += block.Text
|
|
case "image":
|
|
if block.Source != nil && block.Source.Data != "" && len(block.Source.Data) <= 512<<10 {
|
|
files = append(files, protocol.ChatPart{Type: protocol.ChatPartFile, Mime: block.Source.MediaType, Name: "image", URI: "data:" + block.Source.MediaType + ";base64," + block.Source.Data})
|
|
}
|
|
}
|
|
}
|
|
if hasResult || (text == "" && len(files) == 0) {
|
|
continue
|
|
}
|
|
id := takePromptID(text)
|
|
if id == "" {
|
|
id = entry.UUID
|
|
}
|
|
if id == "" {
|
|
continue
|
|
}
|
|
created, _ := transcriptTime(entry.Timestamp)
|
|
parts := []protocol.ChatPart{}
|
|
if text != "" {
|
|
parts = append(parts, protocol.ChatPart{Type: protocol.ChatPartText, ID: id + "#text", Text: text})
|
|
}
|
|
parts = append(parts, files...)
|
|
messages = append(messages, protocol.ChatMessage{ID: id, SessionID: s.id, Role: protocol.ChatRoleUser, CreatedAt: created, Parts: parts})
|
|
}
|
|
}
|
|
// Drop assistant messages that ended with no renderable part (for example a
|
|
// signature-only thinking entry).
|
|
filtered := messages[:0]
|
|
for _, message := range messages {
|
|
if len(message.Parts) > 0 {
|
|
filtered = append(filtered, message)
|
|
}
|
|
}
|
|
messages = filtered
|
|
if limit <= 0 {
|
|
limit = 50
|
|
}
|
|
if limit > 100 {
|
|
limit = 100
|
|
}
|
|
offset := 0
|
|
if strings.TrimSpace(cursor) != "" {
|
|
if parsed, err := strconv.Atoi(cursor); err == nil && parsed >= 0 {
|
|
offset = parsed
|
|
}
|
|
}
|
|
if offset > len(messages) {
|
|
offset = len(messages)
|
|
}
|
|
end := len(messages) - offset
|
|
start := end - limit
|
|
if start < 0 {
|
|
start = 0
|
|
}
|
|
page := protocol.ChatHistoryPage{Messages: append([]protocol.ChatMessage{}, messages[start:end]...)}
|
|
if start > 0 {
|
|
page.HasMore = true
|
|
page.NextCursor = strconv.Itoa(offset + len(page.Messages))
|
|
}
|
|
return page, nil
|
|
}
|
|
|
|
func textOrdinal(parts []protocol.ChatPart, kind string) int {
|
|
count := 0
|
|
for _, part := range parts {
|
|
if part.Type == kind {
|
|
count++
|
|
}
|
|
}
|
|
return count
|
|
}
|
|
|
|
func applyTranscriptToolResult(messages *[]protocol.ChatMessage, toolIndex map[string][2]int, block contentBlock) {
|
|
position, ok := toolIndex[block.ToolUseID]
|
|
if !ok || position[0] >= len(*messages) {
|
|
return
|
|
}
|
|
message := &(*messages)[position[0]]
|
|
if position[1] >= len(message.Parts) {
|
|
return
|
|
}
|
|
part := &message.Parts[position[1]]
|
|
if part.State == nil {
|
|
part.State = &protocol.ChatToolState{}
|
|
}
|
|
text, images := toolResultContent(block.Content)
|
|
status := protocol.ChatToolCompleted
|
|
var toolErr *protocol.ChatError
|
|
exit := exitCode(text)
|
|
if block.IsError || (exit != nil && *exit != 0) {
|
|
status = protocol.ChatToolError
|
|
detail := strings.TrimSpace(text)
|
|
if detail == "" {
|
|
detail = "the tool returned an error"
|
|
}
|
|
toolErr = &protocol.ChatError{Type: "tool", Message: boundedText(detail, 2<<10)}
|
|
}
|
|
part.State.Status = status
|
|
part.State.Error = toolErr
|
|
if text != "" {
|
|
part.State.Content = append(part.State.Content, protocol.ChatToolContent{Type: "text", Text: boundedText(text, 128<<10)})
|
|
}
|
|
part.State.Content = append(part.State.Content, images...)
|
|
}
|
|
|
|
// Messages serves the authoritative transcript history.
|
|
func (c *Chat) Messages(ctx context.Context, id string, limit int, cursor string) (protocol.ChatHistoryPage, error) {
|
|
s := c.session(id)
|
|
if s == nil {
|
|
meta, ok := transcriptSession(id)
|
|
if !ok {
|
|
return protocol.ChatHistoryPage{}, errors.New("unknown Claude session " + id)
|
|
}
|
|
s = c.sessionFor(id, meta.Directory)
|
|
}
|
|
return s.transcriptMessages(limit, cursor)
|
|
}
|
|
|
|
// sessionTranscriptPath is used by tests and diagnostics.
|
|
func sessionTranscriptPath(id string) string {
|
|
path := findTranscriptFile(id)
|
|
if path == "" {
|
|
return ""
|
|
}
|
|
return filepath.Clean(path)
|
|
}
|