423 lines
14 KiB
Go
423 lines
14 KiB
Go
package opencode
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// MaxSessionExport bounds the native session readback used for the stage session
|
|
// export. A larger session is read as a bounded prefix and reported truncated,
|
|
// never presented as the whole session.
|
|
const MaxSessionExport = 8 << 20
|
|
|
|
var ErrEmptySessionExport = errors.New("session recorded but native export contains no messages")
|
|
var errTransientExport = errors.New("native session export temporarily unavailable")
|
|
var errSessionIdentity = errors.New("native export session identity mismatch")
|
|
|
|
// nativeExportResult is one bounded native export readback. envelope is capped
|
|
// at the caller's limit; truncated explicitly distinguishes a size-limited
|
|
// prefix from complete JSON.
|
|
type nativeExportResult struct {
|
|
envelope []byte
|
|
truncated bool
|
|
}
|
|
|
|
// exportNative reads the existing V2 endpoint directly (CLI stdout silently
|
|
// cuts large exports at 256 KiB), retaining the top-level export CLI for V1.
|
|
// It never starts a backend, resumes a session, pairs, or mutates stored data.
|
|
func exportNative(ctx context.Context, executable, directory, backend, id string, limit int, connections ...*Connection) (nativeExportResult, error) {
|
|
if !sessionID.MatchString(id) {
|
|
return nativeExportResult{}, fmt.Errorf("invalid session ID")
|
|
}
|
|
if backend == "v2" {
|
|
var c *Connection
|
|
if len(connections) > 0 {
|
|
c = connections[0]
|
|
} else {
|
|
var err error
|
|
c, err = sessionExportConnection(directory)
|
|
if err != nil {
|
|
return nativeExportResult{}, err
|
|
}
|
|
}
|
|
if c == nil || c.URL == "" || c.Backend != "v2" {
|
|
return nativeExportResult{}, fmt.Errorf("session export requires the existing V2 endpoint")
|
|
}
|
|
body, err := c.HistoryNative(ctx, "/api/experimental/session/"+id+"/export?sanitize=false")
|
|
if err != nil {
|
|
if c.LastHTTPStatus == 429 || c.LastHTTPStatus == 503 {
|
|
err = errors.Join(errTransientExport, err)
|
|
}
|
|
return nativeExportResult{}, err
|
|
}
|
|
defer body.Close()
|
|
data, err := io.ReadAll(io.LimitReader(body, int64(limit)+1))
|
|
if err != nil {
|
|
return nativeExportResult{}, fmt.Errorf("session export response interrupted")
|
|
}
|
|
if len(data) > limit {
|
|
return nativeExportResult{envelope: data[:limit], truncated: true}, nil
|
|
}
|
|
return nativeExportResult{envelope: data}, nil
|
|
}
|
|
args := []string{"export", id}
|
|
cmd := CommandContext(ctx, executable, args...)
|
|
cmd.Dir = directory
|
|
stdout := &boundedOutput{limit: limit}
|
|
stderr := &boundedOutput{limit: 8 << 10}
|
|
cmd.Stdout = stdout
|
|
cmd.Stderr = stderr
|
|
if err := cmd.Run(); err != nil {
|
|
// Only known temporary transport/store failures are retried. Do not
|
|
// expose stderr: it may contain session text or credentials.
|
|
text := strings.ToLower(string(stderr.Bytes()))
|
|
for _, temporary := range []string{"temporarily unavailable", "connection refused", "database is locked", "server is busy"} {
|
|
if strings.Contains(text, temporary) {
|
|
err = errors.Join(errTransientExport, err)
|
|
break
|
|
}
|
|
}
|
|
return nativeExportResult{envelope: stdout.Bytes(), truncated: stdout.overflow}, err
|
|
}
|
|
return nativeExportResult{envelope: stdout.Bytes(), truncated: stdout.overflow}, nil
|
|
}
|
|
|
|
// validNativeExport is the exact-ID and messages-array validation
|
|
// Connection.Messages and ExportSession share: the envelope must parse, carry an
|
|
// info.id equal to wantID and a JSON messages array. An empty array is valid
|
|
// readback syntax, not complete evidence; consumers must label it empty.
|
|
func validNativeExport(data []byte, wantID string) (json.RawMessage, bool) {
|
|
var envelope struct {
|
|
Info struct {
|
|
ID string `json:"id"`
|
|
} `json:"info"`
|
|
Messages json.RawMessage `json:"messages"`
|
|
Data json.RawMessage `json:"data"`
|
|
}
|
|
if json.Unmarshal(data, &envelope) != nil {
|
|
return nil, false
|
|
}
|
|
// The HTTP/CLI readback can wrap a payload in data. Only unwrap an
|
|
// otherwise absent envelope, never use data to override a mismatched ID.
|
|
if envelope.Info.ID == "" && len(envelope.Messages) == 0 && len(envelope.Data) > 0 {
|
|
if json.Unmarshal(envelope.Data, &envelope) != nil {
|
|
return nil, false
|
|
}
|
|
}
|
|
if envelope.Info.ID != wantID || len(envelope.Messages) == 0 {
|
|
return nil, false
|
|
}
|
|
messages := bytes.TrimSpace(envelope.Messages)
|
|
if len(messages) > 0 && messages[0] == '{' {
|
|
var wrapped struct {
|
|
Data json.RawMessage `json:"data"`
|
|
}
|
|
if json.Unmarshal(messages, &wrapped) != nil {
|
|
return nil, false
|
|
}
|
|
messages = bytes.TrimSpace(wrapped.Data)
|
|
}
|
|
if len(messages) == 0 || messages[0] != '[' {
|
|
return nil, false
|
|
}
|
|
var records []json.RawMessage
|
|
if json.Unmarshal(messages, &records) != nil {
|
|
return nil, false
|
|
}
|
|
return messages, true
|
|
}
|
|
|
|
// ExportedPart is one decoded content element of an exported session. Raw keeps
|
|
// the part's original JSON so an unrecognised type is rendered rather than
|
|
// silently dropped; State carries a tool call's status, input, result and error.
|
|
type ExportedPart struct {
|
|
Type string
|
|
ID string
|
|
Text string
|
|
Name string
|
|
State *protocol.ChatToolState
|
|
Time *protocol.ChatTime
|
|
Raw json.RawMessage
|
|
}
|
|
|
|
// ExportedMessage is one decoded turn. Every role is kept, not only
|
|
// user/assistant, so the export is the session the harness stored.
|
|
type ExportedMessage struct {
|
|
Raw json.RawMessage
|
|
ID string
|
|
Role string
|
|
Model string
|
|
Agent string
|
|
CreatedAt int64
|
|
Parts []ExportedPart
|
|
}
|
|
|
|
// ExportedSession is one bounded native session readback for the stage session
|
|
// export. Truncated is true when the source exceeded MaxSessionExport; Messages
|
|
// then covers the complete turns decoded before the cut.
|
|
type ExportedSession struct {
|
|
Attempts int
|
|
ID string
|
|
Backend string
|
|
Messages []ExportedMessage
|
|
Truncated bool
|
|
}
|
|
|
|
// ExportSession reads the session's native export read-only and decodes it into
|
|
// ExportedSession. It reuses the shared export invocation and exact-ID check,
|
|
// decodes the v1/v2 message and part shapes through chatMessageRecords and, when
|
|
// the source exceeded MaxSessionExport, streams the complete turns decoded from
|
|
// the bounded prefix and reports Truncated instead of failing. It performs no
|
|
// writes, no resumption and no idleness wait. Empty readbacks and explicitly
|
|
// temporary failures get at most three attempts within the caller's deadline;
|
|
// wrong identity and permanent failures never retry.
|
|
// An optional existing connection pins V2 readback to the caller's exact
|
|
// endpoint/auth context. Otherwise only configured endpoint/private local
|
|
// service state is read; there is no CLI/service-start fallback.
|
|
func ExportSession(ctx context.Context, executable, directory, backend, id string, connections ...*Connection) (ExportedSession, error) {
|
|
if !sessionID.MatchString(id) {
|
|
return ExportedSession{}, fmt.Errorf("invalid session ID")
|
|
}
|
|
for attempt := 0; attempt < 3; attempt++ {
|
|
session, err := exportSessionOnce(ctx, executable, directory, backend, id, connections...)
|
|
session.Attempts = attempt + 1
|
|
if err == nil {
|
|
return session, nil
|
|
}
|
|
if ctx.Err() != nil {
|
|
return session, ctx.Err()
|
|
}
|
|
if attempt == 2 || (!errors.Is(err, ErrEmptySessionExport) && !errors.Is(err, errTransientExport)) {
|
|
return session, err
|
|
}
|
|
// Bounded recovery, not a causal claim about why readback was empty.
|
|
timer := time.NewTimer(time.Duration(attempt+1) * 200 * time.Millisecond)
|
|
select {
|
|
case <-ctx.Done():
|
|
timer.Stop()
|
|
return session, ctx.Err()
|
|
case <-timer.C:
|
|
}
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
func exportSessionOnce(ctx context.Context, executable, directory, backend, id string, connections ...*Connection) (ExportedSession, error) {
|
|
session := ExportedSession{ID: id, Backend: backend}
|
|
exported, err := exportNative(ctx, executable, directory, backend, id, MaxSessionExport, connections...)
|
|
if err != nil {
|
|
return session, fmt.Errorf("native session export failed: %w", err)
|
|
}
|
|
if exported.truncated {
|
|
records, _, err := decodeExportPrefix(exported.envelope, id)
|
|
if err != nil {
|
|
return session, err
|
|
}
|
|
session.Messages, session.Truncated = exportedMessages(records), true
|
|
// Even a cut inside the first turn is partial evidence, never settling.
|
|
return session, nil
|
|
}
|
|
messages, ok := validNativeExport(exported.envelope, id)
|
|
if !ok {
|
|
// Incomplete JSON is a possible interrupted read; valid but wrong
|
|
// identity/schema is permanent and must never be retried as settling.
|
|
var syntax *json.SyntaxError
|
|
var envelope struct {
|
|
Info struct {
|
|
ID string `json:"id"`
|
|
} `json:"info"`
|
|
Data json.RawMessage `json:"data"`
|
|
}
|
|
if err := json.Unmarshal(exported.envelope, &envelope); err != nil {
|
|
identity := exportPrefixIdentity(exported.envelope)
|
|
if identity != "" && identity != id {
|
|
return session, errSessionIdentity
|
|
}
|
|
if backend != "v2" && len(exported.envelope) != 262144 && identity == id && errors.As(err, &syntax) && strings.Contains(syntax.Error(), "unexpected end") {
|
|
return session, errTransientExport
|
|
}
|
|
return session, fmt.Errorf("native export returned invalid session evidence")
|
|
}
|
|
if envelope.Info.ID == "" && len(envelope.Data) > 0 {
|
|
_ = json.Unmarshal(envelope.Data, &envelope)
|
|
}
|
|
if envelope.Info.ID != "" && envelope.Info.ID != id {
|
|
return session, errSessionIdentity
|
|
}
|
|
return session, fmt.Errorf("native export returned unsupported or missing session evidence")
|
|
}
|
|
records, err := chatMessageRecords(messages)
|
|
if err != nil {
|
|
return session, err
|
|
}
|
|
session.Messages = exportedMessages(records)
|
|
if len(session.Messages) == 0 {
|
|
return session, ErrEmptySessionExport
|
|
}
|
|
return session, nil
|
|
}
|
|
|
|
// exportPrefixIdentity reads only complete metadata preceding an interrupted
|
|
// messages array. A known wrong session is permanent even when JSON is cut.
|
|
func exportPrefixIdentity(data []byte) string {
|
|
decoder := json.NewDecoder(bytes.NewReader(data))
|
|
if token, err := decoder.Token(); err != nil || token != json.Delim('{') {
|
|
return ""
|
|
}
|
|
for decoder.More() {
|
|
token, err := decoder.Token()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
if token == "info" {
|
|
var info struct {
|
|
ID string `json:"id"`
|
|
}
|
|
if decoder.Decode(&info) == nil {
|
|
return info.ID
|
|
}
|
|
return ""
|
|
}
|
|
var skip json.RawMessage
|
|
if decoder.Decode(&skip) != nil {
|
|
return ""
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// exportedMessages maps decoded native turns onto ExportedMessage, preserving
|
|
// every role and each part's raw JSON for unknown types.
|
|
func exportedMessages(records []nativeChatMessage) []ExportedMessage {
|
|
messages := make([]ExportedMessage, 0, len(records))
|
|
for _, record := range records {
|
|
message := ExportedMessage{
|
|
Raw: record.Raw,
|
|
ID: record.messageID(),
|
|
Role: record.role(),
|
|
Model: record.modelID(),
|
|
Agent: record.agent(),
|
|
CreatedAt: record.createdAt(),
|
|
}
|
|
for _, part := range record.contentParts() {
|
|
message.Parts = append(message.Parts, ExportedPart{
|
|
Type: part.Type, ID: part.ID, Text: part.Text, Name: part.Name,
|
|
State: part.State, Time: part.Time, Raw: part.Raw,
|
|
})
|
|
}
|
|
// A v2 user turn carries its prompt text as a message-level string rather
|
|
// than a content array, so surface it as the turn's single text part.
|
|
if len(message.Parts) == 0 && message.Role == protocol.ChatRoleUser && record.Text != "" {
|
|
message.Parts = append(message.Parts, ExportedPart{Type: protocol.ChatPartText, Text: record.Text})
|
|
}
|
|
var fields map[string]json.RawMessage
|
|
_ = json.Unmarshal(record.Raw, &fields)
|
|
var files []json.RawMessage
|
|
_ = json.Unmarshal(fields["files"], &files)
|
|
for _, file := range files {
|
|
message.Parts = append(message.Parts, ExportedPart{Type: "file", Raw: file})
|
|
}
|
|
// Non-chat events (system, selection, compaction, etc.) must retain
|
|
// their real payload even when they have no text/content array.
|
|
if len(message.Parts) == 0 {
|
|
message.Parts = append(message.Parts, ExportedPart{Type: record.role(), Raw: record.Raw})
|
|
}
|
|
messages = append(messages, message)
|
|
}
|
|
return messages
|
|
}
|
|
|
|
// decodeExportPrefix streams the messages of a bounded export prefix. Complete
|
|
// turns decoded before the cut are returned with truncated=true; a mismatched
|
|
// info.id is an error so an unrelated session is never exported.
|
|
func decodeExportPrefix(data []byte, wantID string) ([]nativeChatMessage, bool, error) {
|
|
decoder := json.NewDecoder(bytes.NewReader(data))
|
|
return decodeExportPrefixObject(decoder, wantID)
|
|
}
|
|
|
|
func decodeExportPrefixObject(decoder *json.Decoder, wantID string) ([]nativeChatMessage, bool, error) {
|
|
open, err := decoder.Token()
|
|
if err != nil {
|
|
return nil, false, fmt.Errorf("native export returned invalid session evidence")
|
|
}
|
|
if delim, ok := open.(json.Delim); !ok || delim != '{' {
|
|
return nil, false, fmt.Errorf("native export returned invalid session evidence")
|
|
}
|
|
var messages []nativeChatMessage
|
|
sawMessages := false
|
|
sawIdentity := false
|
|
partial := func() ([]nativeChatMessage, bool, error) {
|
|
if !sawIdentity {
|
|
return nil, false, fmt.Errorf("native export prefix has no verified session identity")
|
|
}
|
|
return messages, true, nil
|
|
}
|
|
for decoder.More() {
|
|
keyToken, err := decoder.Token()
|
|
if err != nil {
|
|
return partial()
|
|
}
|
|
key, _ := keyToken.(string)
|
|
switch key {
|
|
case "data":
|
|
if sawIdentity || sawMessages {
|
|
return nil, false, fmt.Errorf("ambiguous native export envelope")
|
|
}
|
|
return decodeExportPrefixObject(decoder, wantID)
|
|
case "info":
|
|
var info struct {
|
|
ID string `json:"id"`
|
|
}
|
|
if err := decoder.Decode(&info); err != nil {
|
|
return partial()
|
|
}
|
|
if info.ID != wantID {
|
|
return nil, false, fmt.Errorf("native export session id mismatch")
|
|
}
|
|
sawIdentity = true
|
|
case "messages":
|
|
sawMessages = true
|
|
open, err := decoder.Token()
|
|
if err != nil {
|
|
return partial()
|
|
}
|
|
if delim, ok := open.(json.Delim); !ok || delim != '[' {
|
|
return nil, false, fmt.Errorf("native export returned invalid session evidence")
|
|
}
|
|
for decoder.More() {
|
|
var message nativeChatMessage
|
|
if err := decoder.Decode(&message); err != nil {
|
|
return partial()
|
|
}
|
|
messages = append(messages, message)
|
|
}
|
|
if _, err := decoder.Token(); err != nil {
|
|
return partial()
|
|
}
|
|
default:
|
|
var skip json.RawMessage
|
|
if err := decoder.Decode(&skip); err != nil {
|
|
return partial()
|
|
}
|
|
}
|
|
}
|
|
if !sawMessages {
|
|
return nil, false, fmt.Errorf("native export returned no session messages")
|
|
}
|
|
if !sawIdentity {
|
|
return nil, false, fmt.Errorf("native export prefix has no verified session identity")
|
|
}
|
|
if _, err := decoder.Token(); err != nil {
|
|
return partial()
|
|
}
|
|
return messages, false, nil
|
|
}
|