1f75e4797e
Add an opt-in way to broker chat from an operator-supplied OpenCode service instead of the instance the server spawns for itself, and a way to adopt a session that already exists on that endpoint so it appears in chat_sessions and can be continued from the app. - Endpoint selection: the `-opencode-endpoint` server flag (defaulting to `PIPELINES_OPENCODE_ENDPOINT`) opts in; precedence is explicit flag > explicit environment > the endpoint recorded on a previous run, with the spawned instance as the default. opencode.OpenEndpoint validates the reference once (http(s), host, no userinfo/query/fragment/path), detects the backend from its own /api/info (v2) or /global/health (v1) contract, and requires a streamable text/event-stream event path. It owns no process (Close is a no-op) and never calls startServe; every failure names the endpoint and disables chat rather than silently falling back. An authenticated endpoint takes an optional password only through the private file PIPELINES_OPENCODE_ENDPOINT_PASSWORD_FILE, with PIPELINES_OPENCODE_ENDPOINT_USERNAME overriding the detected default. - Persistence: the validated choice is recorded in an additive single-row server_settings table so a restart with no flag/environment reuses it; an unreachable recorded endpoint disables chat with a clear message and no fallback. - chat_adopt: a new protocol request (ChatAdoptRequest) with handleChatAdopt in internal/server/chat.go. It refuses a nil broker/registry/payload and a blank or foreign-shaped id before any endpoint call, reads the endpoint via the shared Chat.Session (which reuses Sessions/decodeChatSessions), records through the existing RecordOperatorSession with the endpoint's directory and title verbatim, and echoes the adopted session plus its registry row like chat_create. A missing id is refused naming the id and records nothing; an endpoint record with an empty directory is refused rather than substituting the server's working directory or home. - CLI: `pipelines chat-adopt <session-id> [--json]` (usage, notes, help inventory, dispatch) with docs/cli.md updated under Chat sessions. - Autostart preserves the endpoint variables (and the password-file reference, never an inline secret) via serviceEnvironmentKeys. Checks before committing: - Package location: the change is user-facing chat behaviour, so the packaged authoring skill reference internal/author/skill/references/operations.md is updated in the same change (Brokered OpenCode chat section) with a dated verification-evidence entry and the not-deployed state. No new reference file is added, so internal/author/install.go's managed inventory is unchanged. - Packaged templates: this repository packages no template set for this behaviour and none references the chat endpoint, so no template needs updating. - Verification: `go build ./...`, `go vet` on the touched packages, `gofmt -l` clean and `go test ./...` all pass. The unit tests cover the endpoint validation/precedence, the adopt happy path and refusals, the recorded endpoint round-trip, the protocol round-trip and the CLI dispatch. The live scratch-server check against the operator's real endpoint was not run in this change. Nothing unrelated is staged; docs left stale (README and other shared documents) are not edited here and are for a single folding writer.
766 lines
29 KiB
Go
766 lines
29 KiB
Go
package opencode
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"sort"
|
|
"strings"
|
|
"sync"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// ErrPermissionUnsupported reports that the connected OpenCode backend does not
|
|
// expose the brokered approval surface. The native v1 serve translation returns
|
|
// it; callers treat it as a documented limitation rather than an operational
|
|
// failure, so a chat prompt does not emit a permission error frame on a backend
|
|
// that cannot answer one.
|
|
var ErrPermissionUnsupported = errors.New("OpenCode permission approval is not implemented for the native serve backend")
|
|
|
|
// Chat is the brokered OpenCode chat adapter (route B in the research): the
|
|
// Pipelines server owns the OpenCode endpoint and credentials and turns the v2
|
|
// HTTP API into protocol.ChatEventFrame frames. It reuses the owned-endpoint
|
|
// semantics, the session-id shape and the 64 KiB / 1 MiB bounds of Connection so
|
|
// no second transport or credential path is introduced.
|
|
type Chat struct {
|
|
conn *Connection
|
|
// mu serializes the adapter's HTTP calls. Connection records its last
|
|
// operation and status on the shared connection, so two calls must not
|
|
// overlap; the permission poller runs alongside the read loop's
|
|
// prompt/interrupt/reply calls.
|
|
mu sync.Mutex
|
|
}
|
|
|
|
// NewChat brokers chat for one owned OpenCode endpoint. The connection must be
|
|
// able to reach the /api HTTP surface: an owned serve connection (translated by
|
|
// Connection.Call) or a connection that already carries the v2 API URL.
|
|
func NewChat(conn *Connection) *Chat { return &Chat{conn: conn} }
|
|
|
|
// ValidSessionID reports whether id has the OpenCode session-id shape the
|
|
// native adapter already accepts. It is the single validation shared by the
|
|
// chat adapter and callers that must reject a request before any OpenCode call.
|
|
func ValidSessionID(id string) bool { return sessionID.MatchString(id) }
|
|
|
|
// call serializes the adapter's HTTP calls and forwards them through the shared
|
|
// Connection, so no second transport is introduced and Connection's recorded
|
|
// last operation/status is never written by two goroutines at once.
|
|
func (c *Chat) call(ctx context.Context, method, path string, body any) ([]byte, error) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
return c.conn.Call(ctx, method, path, body)
|
|
}
|
|
|
|
// Prompt forwards one chat prompt through the existing Call translation
|
|
// (authenticated, bounded, directory-scoped). The endpoint returns the inbox
|
|
// envelope immediately; the reply arrives on Stream.
|
|
func (c *Chat) Prompt(ctx context.Context, id, text string) error {
|
|
if !sessionID.MatchString(id) {
|
|
return fmt.Errorf("invalid OpenCode session id")
|
|
}
|
|
if strings.TrimSpace(text) == "" {
|
|
return fmt.Errorf("empty chat prompt")
|
|
}
|
|
// The V2 prompt body is {"text": ...}; the native serve translation accepts
|
|
// the same "text" field, so one shape works on both backends without a
|
|
// second request format.
|
|
body := map[string]any{"text": text}
|
|
if _, err := c.call(ctx, "post", "/api/session/"+id+"/prompt", body); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Interrupt aborts the session's active run, reusing the same translated surface.
|
|
func (c *Chat) Interrupt(ctx context.Context, id string) error {
|
|
if !sessionID.MatchString(id) {
|
|
return fmt.Errorf("invalid OpenCode session id")
|
|
}
|
|
if _, err := c.call(ctx, "post", "/api/session/"+id+"/interrupt", map[string]any{}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Messages reads one session's stored turns. On the owned serve backend it
|
|
// reuses Connection.Messages, including its read-only OutputFormat readback
|
|
// fallback, instead of duplicating that path. It maps the verified assistant
|
|
// content parts (text | reasoning | tool) onto protocol.ChatMessage.
|
|
func (c *Chat) Messages(ctx context.Context, id string, limit int) ([]protocol.ChatMessage, error) {
|
|
if !sessionID.MatchString(id) {
|
|
return nil, fmt.Errorf("invalid OpenCode session id")
|
|
}
|
|
var data []byte
|
|
var err error
|
|
c.mu.Lock()
|
|
if c.conn.Backend == "v1" {
|
|
data, err = c.conn.Messages(ctx, id)
|
|
} else {
|
|
path := "/api/session/" + id + "/message"
|
|
if limit > 0 {
|
|
path += fmt.Sprintf("?limit=%d", limit)
|
|
}
|
|
data, err = c.conn.Call(ctx, "get", path, nil)
|
|
}
|
|
c.mu.Unlock()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return decodeChatMessages(id, data)
|
|
}
|
|
|
|
// Sessions lists the OpenCode sessions on the endpoint. On the V2 HTTP API that
|
|
// is GET /api/session; the native v1 serve translation maps it to GET /session.
|
|
// It reads the list unscoped by the connection's directory (see
|
|
// Connection.SessionList): the V2 list is otherwise restricted to the
|
|
// connection's own directory, while an operator session may live in any
|
|
// directory, and the caller is responsible for restricting the result to the
|
|
// operator's recorded sessions. It decodes the verified {"data":[...]} envelope
|
|
// (tolerating a bare array like chatMessageRecords), lifts the nested
|
|
// location.directory and time{created,updated} into protocol.ChatSession, drops
|
|
// records without a valid session id, and orders newest-updated first so the list
|
|
// is deterministic.
|
|
func (c *Chat) Sessions(ctx context.Context) ([]protocol.ChatSession, error) {
|
|
c.mu.Lock()
|
|
data, err := c.conn.SessionList(ctx)
|
|
c.mu.Unlock()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return decodeChatSessions(data)
|
|
}
|
|
|
|
// Create creates one OpenCode session in the given directory, mirroring the
|
|
// verified V2 shape POST /api/session {"title":...,"location":{"directory":...}}.
|
|
// It deliberately sends no model or permission override here: the endpoint's own
|
|
// defaults apply, exactly as the live check creates a session. The created
|
|
// session is returned with its directory lifted from location.directory.
|
|
func (c *Chat) Create(ctx context.Context, title, directory string) (protocol.ChatSession, error) {
|
|
body := struct {
|
|
Title string `json:"title"`
|
|
Location struct {
|
|
Directory string `json:"directory"`
|
|
} `json:"location"`
|
|
}{Title: title}
|
|
body.Location.Directory = directory
|
|
data, err := c.call(ctx, "post", "/api/session", body)
|
|
if err != nil {
|
|
return protocol.ChatSession{}, err
|
|
}
|
|
return decodeChatSession(data)
|
|
}
|
|
|
|
// Session returns the endpoint's own record of one session so a caller can adopt
|
|
// an existing session with the directory and title the endpoint reports, never a
|
|
// guessed directory. found is false when the endpoint does not list id. It
|
|
// reuses Sessions/decodeChatSessions, so no second session decoder or endpoint is
|
|
// introduced; it performs at most one bounded endpoint read.
|
|
func (c *Chat) Session(ctx context.Context, id string) (protocol.ChatSession, bool, error) {
|
|
if !ValidSessionID(id) {
|
|
return protocol.ChatSession{}, false, fmt.Errorf("invalid OpenCode session id")
|
|
}
|
|
sessions, err := c.Sessions(ctx)
|
|
if err != nil {
|
|
return protocol.ChatSession{}, false, err
|
|
}
|
|
for _, session := range sessions {
|
|
if session.ID == id {
|
|
return session, true, nil
|
|
}
|
|
}
|
|
return protocol.ChatSession{}, false, nil
|
|
}
|
|
|
|
// Reply posts a permission decision, mirroring the documented endpoint.
|
|
func (c *Chat) Reply(ctx context.Context, request protocol.ChatReplyRequest) error {
|
|
if !sessionID.MatchString(request.SessionID) {
|
|
return fmt.Errorf("invalid OpenCode session id")
|
|
}
|
|
if request.RequestID == "" {
|
|
return fmt.Errorf("missing permission request id")
|
|
}
|
|
decision := request.Decision
|
|
if decision != protocol.ChatDecisionOnce && decision != protocol.ChatDecisionAlways && decision != protocol.ChatDecisionReject {
|
|
return fmt.Errorf("invalid permission decision %q", decision)
|
|
}
|
|
body := map[string]any{"decision": decision}
|
|
if request.Message != "" {
|
|
body["message"] = request.Message
|
|
}
|
|
path := "/api/session/" + request.SessionID + "/permission/" + request.RequestID + "/reply"
|
|
if _, err := c.call(ctx, "post", path, body); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Permissions lists the session's pending OpenCode approval requests, mirroring
|
|
// GET /api/permission/request. The endpoint is global, so the decoded list is
|
|
// filtered to sessionID; a malformed response is an error, never an empty
|
|
// success. It reuses Connection.Call so the request keeps the shared bounds,
|
|
// auth and translation, and reuses ValidSessionID for the same rejection the
|
|
// other chat calls apply.
|
|
func (c *Chat) Permissions(ctx context.Context, id string) ([]protocol.ChatPermissionFrame, error) {
|
|
if !sessionID.MatchString(id) {
|
|
return nil, fmt.Errorf("invalid OpenCode session id")
|
|
}
|
|
data, err := c.call(ctx, "get", "/api/permission/request", nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return decodeChatPermissions(id, data)
|
|
}
|
|
|
|
// nativeChatPermission is one pending approval request matching the V2
|
|
// Permission.Request schema verified against the service's /openapi.json: id,
|
|
// sessionID, action and resources are required; save, metadata, source and
|
|
// message are optional, so the decoder tolerates any of them being absent.
|
|
type nativeChatPermission struct {
|
|
ID string `json:"id"`
|
|
SessionID string `json:"sessionID"`
|
|
Action string `json:"action"`
|
|
Resources []string `json:"resources"`
|
|
Save []string `json:"save"`
|
|
Metadata map[string]any `json:"metadata"`
|
|
Source *nativeChatPermissionSource `json:"source"`
|
|
Message string `json:"message"`
|
|
}
|
|
|
|
// nativeChatPermissionSource is the incoming Permission.Source union; its single
|
|
// (tool) member carries type plus the message id and call id (the protocol frame
|
|
// renames messageID to message_id).
|
|
type nativeChatPermissionSource struct {
|
|
Type string `json:"type"`
|
|
MessageID string `json:"messageID"`
|
|
ID string `json:"id"`
|
|
}
|
|
|
|
// chatEnvelope unwraps the {"data":[...]} envelope the V2 HTTP API returns and
|
|
// reports whether the body was that envelope with a non-nil data array; a bare
|
|
// array or a malformed body returns ok=false. It is the single envelope rule the
|
|
// message and permission decoders share instead of each re-deriving it.
|
|
func chatEnvelope[T any](data []byte) ([]T, bool) {
|
|
var response struct {
|
|
Data []T `json:"data"`
|
|
}
|
|
if err := json.Unmarshal(data, &response); err != nil || response.Data == nil {
|
|
return nil, false
|
|
}
|
|
return response.Data, true
|
|
}
|
|
|
|
// chatPermissionRecords reads the {"data":[...]} envelope the V2 endpoint
|
|
// returns. An unparseable body or a missing data array is an error, never an
|
|
// empty list.
|
|
func chatPermissionRecords(data []byte) ([]nativeChatPermission, error) {
|
|
records, ok := chatEnvelope[nativeChatPermission](data)
|
|
if !ok {
|
|
return nil, fmt.Errorf("invalid OpenCode permission response")
|
|
}
|
|
return records, nil
|
|
}
|
|
|
|
// decodeChatPermissions maps the pending-request list onto protocol frames,
|
|
// keeping only the requested session's requests (a request with no id cannot be
|
|
// answered and is dropped).
|
|
func decodeChatPermissions(sessionID string, data []byte) ([]protocol.ChatPermissionFrame, error) {
|
|
records, err := chatPermissionRecords(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
frames := make([]protocol.ChatPermissionFrame, 0, len(records))
|
|
for _, record := range records {
|
|
if record.SessionID != sessionID || record.ID == "" {
|
|
continue
|
|
}
|
|
frame := protocol.ChatPermissionFrame{
|
|
SessionID: sessionID,
|
|
RequestID: record.ID,
|
|
Action: record.Action,
|
|
Resources: record.Resources,
|
|
Save: record.Save,
|
|
Metadata: record.Metadata,
|
|
Message: record.Message,
|
|
}
|
|
if record.Source != nil {
|
|
frame.Source = &protocol.ChatPermissionSource{Type: record.Source.Type, MessageID: record.Source.MessageID, ID: record.Source.ID}
|
|
}
|
|
frames = append(frames, frame)
|
|
}
|
|
return frames, nil
|
|
}
|
|
|
|
// Stream subscribes to the OpenCode event firehose and invokes emit for every
|
|
// frame belonging to sessionID. It reads one bounded SSE frame at a time and
|
|
// never polls the per-session message log; the global firehose is the only
|
|
// source of token-level deltas on this build. ready, when non-nil, is called
|
|
// once the subscription is attached and before the first frame is read, so a
|
|
// caller can post its prompt only after the stream is listening (the firehose
|
|
// has no replay cursor). Canceling ctx cancels the subscription and returns
|
|
// without leaking a connection.
|
|
func (c *Chat) Stream(ctx context.Context, id string, ready func(), emit func(protocol.ChatEventFrame) error) error {
|
|
if !sessionID.MatchString(id) {
|
|
return fmt.Errorf("invalid OpenCode session id")
|
|
}
|
|
body, err := c.conn.EventStream(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer body.Close()
|
|
if ready != nil {
|
|
ready()
|
|
}
|
|
return scanChatEvents(ctx, body, id, emit)
|
|
}
|
|
|
|
// scanChatEvents turns an SSE body into protocol frames, one bounded frame at a
|
|
// time. Heartbeat comments, blank lines and unrelated event types are ignored;
|
|
// malformed JSON fails the stream instead of producing a malformed frame. The
|
|
// last assistant message id is retained so a later tool/step event that omits it
|
|
// still attributes every frame to a stable message.
|
|
func scanChatEvents(ctx context.Context, body io.Reader, sessionID string, emit func(protocol.ChatEventFrame) error) error {
|
|
scanner := bufio.NewScanner(body)
|
|
scanner.Buffer(make([]byte, 0, 64<<10), MaxResponse)
|
|
lastMessageID := ""
|
|
for scanner.Scan() {
|
|
if err := ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
line := bytes.TrimSpace(scanner.Bytes())
|
|
if !bytes.HasPrefix(line, []byte("data:")) {
|
|
continue
|
|
}
|
|
payload := bytes.TrimSpace(line[len("data:"):])
|
|
if len(payload) == 0 {
|
|
continue
|
|
}
|
|
frame, ok, err := NormalizeChatEvent(payload, sessionID, &lastMessageID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !ok {
|
|
continue
|
|
}
|
|
if frame.MessageID != "" {
|
|
lastMessageID = frame.MessageID
|
|
}
|
|
if err := emit(frame); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := scanner.Err(); err != nil {
|
|
if ctx.Err() != nil {
|
|
return ctx.Err()
|
|
}
|
|
return fmt.Errorf("OpenCode event stream read failed")
|
|
}
|
|
return ctx.Err()
|
|
}
|
|
|
|
// isChatEventType reports whether t is an event type NormalizeChatEvent
|
|
// surfaces. Unknown types are skipped before their data is decoded, so an
|
|
// unrelated event whose fields share a name with chatEvent but carry a different
|
|
// JSON shape cannot fail the stream.
|
|
func isChatEventType(t string) bool {
|
|
switch t {
|
|
case "session.text.delta", "session.reasoning.delta",
|
|
"session.step.started", "session.step.streamed", "session.step.ended",
|
|
"session.usage.updated",
|
|
"session.tool.input.started", "session.tool.input.ended",
|
|
"session.tool.called", "session.tool.progress",
|
|
"session.tool.success", "session.tool.failed":
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// chatEvent is the subset of the verified firehose envelope this adapter reads:
|
|
// {"type":"session.text.delta","data":{...}}. Fields absent from a given event
|
|
// stay zero so one struct covers every type.
|
|
type chatEvent struct {
|
|
SessionID string `json:"sessionID"`
|
|
MessageID string `json:"assistantMessageID"`
|
|
MessageIDAlt string `json:"messageID"`
|
|
Delta string `json:"delta"`
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
Input json.RawMessage `json:"input"`
|
|
Content []protocol.ChatToolContent `json:"content"`
|
|
Metadata map[string]any `json:"metadata"`
|
|
Error *protocol.ChatError `json:"error"`
|
|
Ordinal int `json:"ordinal"`
|
|
Index int `json:"index"`
|
|
Step int `json:"step"`
|
|
InputTokens int `json:"inputTokens"`
|
|
OutputTokens int `json:"outputTokens"`
|
|
Cost float64 `json:"cost"`
|
|
Tokens struct {
|
|
Input int `json:"input"`
|
|
Output int `json:"output"`
|
|
} `json:"tokens"`
|
|
}
|
|
|
|
// NormalizeChatEvent maps one OpenCode firehose `data:` payload to a
|
|
// protocol.ChatEventFrame. ok is false for an event type this adapter does not
|
|
// surface or one belonging to a different session, so the caller can skip it
|
|
// without emitting a frame. Malformed JSON returns an error and never a frame.
|
|
func NormalizeChatEvent(payload []byte, sessionID string, lastMessageID *string) (protocol.ChatEventFrame, bool, error) {
|
|
var outer struct {
|
|
Type string `json:"type"`
|
|
Data json.RawMessage `json:"data"`
|
|
}
|
|
if err := json.Unmarshal(payload, &outer); err != nil {
|
|
return protocol.ChatEventFrame{}, false, fmt.Errorf("malformed OpenCode event: %w", err)
|
|
}
|
|
if outer.Type == "" || len(outer.Data) == 0 {
|
|
return protocol.ChatEventFrame{}, false, nil
|
|
}
|
|
// Only decode the data of event types this adapter surfaces. The firehose
|
|
// also carries unrelated session events whose fields collide with chatEvent
|
|
// but have a different JSON shape (session.instructions.updated carries
|
|
// "delta" as an object), so decoding every event would fail the stream on an
|
|
// event that is not a chat frame at all.
|
|
if !isChatEventType(outer.Type) {
|
|
return protocol.ChatEventFrame{}, false, nil
|
|
}
|
|
var data chatEvent
|
|
if err := json.Unmarshal(outer.Data, &data); err != nil {
|
|
return protocol.ChatEventFrame{}, false, fmt.Errorf("malformed OpenCode event data: %w", err)
|
|
}
|
|
if data.SessionID != sessionID {
|
|
return protocol.ChatEventFrame{}, false, nil
|
|
}
|
|
messageID := data.MessageID
|
|
if messageID == "" {
|
|
messageID = data.MessageIDAlt
|
|
}
|
|
if messageID == "" && lastMessageID != nil {
|
|
messageID = *lastMessageID
|
|
}
|
|
// Every pushed frame must carry a stable message id so the client can
|
|
// attribute it; without one this is not a chat frame.
|
|
if messageID == "" {
|
|
return protocol.ChatEventFrame{}, false, nil
|
|
}
|
|
frame := protocol.ChatEventFrame{SessionID: sessionID, MessageID: messageID}
|
|
switch {
|
|
case outer.Type == "session.text.delta":
|
|
frame.Kind = protocol.ChatEventText
|
|
frame.Delta = data.Delta
|
|
frame.Part = &protocol.ChatPart{Type: protocol.ChatPartText, ID: fmt.Sprintf("%s#%d", messageID, data.Ordinal)}
|
|
case outer.Type == "session.reasoning.delta":
|
|
frame.Kind = protocol.ChatEventReasoning
|
|
frame.Delta = data.Delta
|
|
frame.Part = &protocol.ChatPart{Type: protocol.ChatPartReasoning, ID: fmt.Sprintf("%s#%d", messageID, data.Ordinal)}
|
|
case outer.Type == "session.step.started" || outer.Type == "session.step.streamed" || outer.Type == "session.step.ended":
|
|
frame.Kind = protocol.ChatEventStep
|
|
frame.Step = &protocol.ChatStep{Status: strings.TrimPrefix(outer.Type, "session.step."), Index: stepIndex(data)}
|
|
case strings.HasPrefix(outer.Type, "session.tool."):
|
|
status, ok := toolStatus(outer.Type)
|
|
if !ok {
|
|
return protocol.ChatEventFrame{}, false, nil
|
|
}
|
|
frame.Kind = protocol.ChatEventTool
|
|
state := &protocol.ChatToolState{Status: status, Input: data.Input, Content: data.Content, Metadata: data.Metadata, Error: data.Error}
|
|
frame.Part = &protocol.ChatPart{Type: protocol.ChatPartTool, ID: data.ID, Name: data.Name, State: state}
|
|
case outer.Type == "session.usage.updated":
|
|
frame.Kind = protocol.ChatEventUsage
|
|
input, output := data.InputTokens, data.OutputTokens
|
|
if data.Tokens.Input != 0 || data.Tokens.Output != 0 {
|
|
input, output = data.Tokens.Input, data.Tokens.Output
|
|
}
|
|
frame.Usage = &protocol.ChatUsage{InputTokens: input, OutputTokens: output, Cost: data.Cost}
|
|
default:
|
|
return protocol.ChatEventFrame{}, false, nil
|
|
}
|
|
return frame, true, nil
|
|
}
|
|
|
|
// toolStatus maps the verified tool event types onto the ToolState lifecycle.
|
|
func toolStatus(eventType string) (string, bool) {
|
|
switch eventType {
|
|
case "session.tool.input.started", "session.tool.input.ended":
|
|
return protocol.ChatToolStreaming, true
|
|
case "session.tool.called", "session.tool.progress":
|
|
return protocol.ChatToolRunning, true
|
|
case "session.tool.success":
|
|
return protocol.ChatToolCompleted, true
|
|
case "session.tool.failed":
|
|
return protocol.ChatToolError, true
|
|
}
|
|
return "", false
|
|
}
|
|
|
|
func stepIndex(data chatEvent) int {
|
|
if data.Step > 0 {
|
|
return data.Step
|
|
}
|
|
return data.Index
|
|
}
|
|
|
|
// nativeChatMessage is one stored turn. The two surfaces return different
|
|
// envelopes for the same session and both decode into this one struct, so the
|
|
// mapping below reads whichever fields a record populated:
|
|
//
|
|
// - the V2 HTTP API (GET /api/session/{id}/message) puts id/type/agent/model,
|
|
// the timing and the parts array at the message top level, with the parts
|
|
// under "content" and a user turn's text as a bare string;
|
|
// - the native serve readback nests the same fields under "info" (role as
|
|
// "role", model as "modelID", timing as "created") with the parts under
|
|
// "parts".
|
|
type nativeChatMessage struct {
|
|
ID string `json:"id"`
|
|
Type string `json:"type"`
|
|
Agent string `json:"agent"`
|
|
Model nativeChatModel `json:"model"`
|
|
Time *protocol.ChatTime `json:"time"`
|
|
Text string `json:"text"`
|
|
Content []nativeChatPart `json:"content"`
|
|
Info struct {
|
|
ID string `json:"id"`
|
|
Role string `json:"role"`
|
|
ModelID string `json:"modelID"`
|
|
Agent string `json:"agent"`
|
|
CreatedAt int64 `json:"created"`
|
|
} `json:"info"`
|
|
Parts []nativeChatPart `json:"parts"`
|
|
}
|
|
|
|
// nativeChatModel is the nested Model.Ref a V2 turn carries ({id, providerID,
|
|
// variant}); only the model id is surfaced in the protocol message.
|
|
type nativeChatModel struct {
|
|
ID string `json:"id"`
|
|
}
|
|
|
|
// nativeChatPart is one content element shared by both message envelopes. Raw
|
|
// keeps the element's original JSON so the session exporter can render an
|
|
// unrecognised part type (file, patch, step, ...) instead of dropping it; it is
|
|
// ignored when a part is re-encoded.
|
|
type nativeChatPart struct {
|
|
Type string `json:"type"`
|
|
ID string `json:"id"`
|
|
Text string `json:"text"`
|
|
Name string `json:"name"`
|
|
Executed bool `json:"executed"`
|
|
State *protocol.ChatToolState `json:"state"`
|
|
Time *protocol.ChatTime `json:"time"`
|
|
Raw json.RawMessage `json:"-"`
|
|
}
|
|
|
|
// UnmarshalJSON decodes one content part and retains its raw JSON alongside the
|
|
// decoded fields, so a part type the decoder does not model is still available
|
|
// verbatim to the session exporter.
|
|
func (p *nativeChatPart) UnmarshalJSON(data []byte) error {
|
|
type part nativeChatPart
|
|
var decoded part
|
|
if err := json.Unmarshal(data, &decoded); err != nil {
|
|
return err
|
|
}
|
|
*p = nativeChatPart(decoded)
|
|
p.Raw = append(p.Raw[:0], data...)
|
|
return nil
|
|
}
|
|
|
|
// role, parts and the accessor methods below read the V2 top-level fields first
|
|
// and fall back to the native serve "info"/"parts" fields, so one record maps
|
|
// regardless of which surface produced it.
|
|
|
|
func (m nativeChatMessage) role() string {
|
|
if m.Info.Role != "" {
|
|
return m.Info.Role
|
|
}
|
|
return m.Type
|
|
}
|
|
|
|
func (m nativeChatMessage) messageID() string {
|
|
if m.Info.ID != "" {
|
|
return m.Info.ID
|
|
}
|
|
return m.ID
|
|
}
|
|
|
|
func (m nativeChatMessage) modelID() string {
|
|
if m.Info.ModelID != "" {
|
|
return m.Info.ModelID
|
|
}
|
|
return m.Model.ID
|
|
}
|
|
|
|
func (m nativeChatMessage) agent() string {
|
|
if m.Info.Agent != "" {
|
|
return m.Info.Agent
|
|
}
|
|
return m.Agent
|
|
}
|
|
|
|
func (m nativeChatMessage) createdAt() int64 {
|
|
if m.Info.CreatedAt != 0 {
|
|
return m.Info.CreatedAt
|
|
}
|
|
if m.Time != nil {
|
|
return m.Time.Created
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m nativeChatMessage) contentParts() []nativeChatPart {
|
|
if m.Parts != nil {
|
|
return m.Parts
|
|
}
|
|
return m.Content
|
|
}
|
|
|
|
// chatMessageRecords accepts both message envelopes the two surfaces return:
|
|
// the V2 HTTP API wraps them in {"data":[...]} while the native serve readback
|
|
// returns a bare array. An unrecognised body is an error, never empty history.
|
|
func chatMessageRecords(data []byte) ([]nativeChatMessage, error) {
|
|
if records, ok := chatEnvelope[nativeChatMessage](data); ok {
|
|
return records, nil
|
|
}
|
|
var records []nativeChatMessage
|
|
if err := json.Unmarshal(data, &records); err != nil {
|
|
return nil, fmt.Errorf("invalid OpenCode message response")
|
|
}
|
|
return records, nil
|
|
}
|
|
|
|
func decodeChatMessages(sessionID string, data []byte) ([]protocol.ChatMessage, error) {
|
|
records, err := chatMessageRecords(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
messages := make([]protocol.ChatMessage, 0, len(records))
|
|
for _, record := range records {
|
|
role := record.role()
|
|
if role != protocol.ChatRoleUser && role != protocol.ChatRoleAssistant {
|
|
continue
|
|
}
|
|
out := protocol.ChatMessage{ID: record.messageID(), SessionID: sessionID, Role: role, Model: record.modelID(), Agent: record.agent(), CreatedAt: record.createdAt()}
|
|
for _, part := range record.contentParts() {
|
|
switch part.Type {
|
|
case protocol.ChatPartText, protocol.ChatPartReasoning:
|
|
out.Parts = append(out.Parts, protocol.ChatPart{Type: part.Type, ID: part.ID, Text: part.Text})
|
|
case protocol.ChatPartTool:
|
|
out.Parts = append(out.Parts, protocol.ChatPart{Type: protocol.ChatPartTool, ID: part.ID, Name: part.Name, Executed: part.Executed, State: part.State, Time: part.Time})
|
|
}
|
|
}
|
|
// 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(out.Parts) == 0 && role == protocol.ChatRoleUser && record.Text != "" {
|
|
out.Parts = append(out.Parts, protocol.ChatPart{Type: protocol.ChatPartText, Text: record.Text})
|
|
}
|
|
messages = append(messages, out)
|
|
}
|
|
return messages, nil
|
|
}
|
|
|
|
// nativeChatSession is one listed session in the verified V2 shape
|
|
// ({id,title,agent,model,cost,tokens,outcome,time,title,location.directory,
|
|
// parentID,permissions}); only the fields the protocol surfaces are read. The
|
|
// native v1 serve readback of the same list is not covered by the research, so
|
|
// its records decode through the same tolerant envelope but any additional
|
|
// nesting is not asserted.
|
|
type nativeChatSession struct {
|
|
ID string `json:"id"`
|
|
Title string `json:"title"`
|
|
Agent string `json:"agent"`
|
|
Model nativeChatModel `json:"model"`
|
|
ParentID string `json:"parentID"`
|
|
Location struct {
|
|
Directory string `json:"directory"`
|
|
} `json:"location"`
|
|
Time struct {
|
|
Created int64 `json:"created"`
|
|
Updated int64 `json:"updated"`
|
|
} `json:"time"`
|
|
}
|
|
|
|
// chatSessionRecords accepts both session-list envelopes: the V2 HTTP API wraps
|
|
// them in {"data":[...]} while the native serve readback returns a bare array.
|
|
// An unrecognised body is an error, never an empty list.
|
|
func chatSessionRecords(data []byte) ([]nativeChatSession, error) {
|
|
if records, ok := chatEnvelope[nativeChatSession](data); ok {
|
|
return records, nil
|
|
}
|
|
var records []nativeChatSession
|
|
if err := json.Unmarshal(data, &records); err != nil {
|
|
return nil, fmt.Errorf("invalid OpenCode session response")
|
|
}
|
|
return records, nil
|
|
}
|
|
|
|
// chatSessionRecord reads one created session, accepting the {"data":{...}}
|
|
// envelope the V2 API returns and tolerating a bare object. An unrecognised body
|
|
// is an error, never an empty session.
|
|
func chatSessionRecord(data []byte) (nativeChatSession, error) {
|
|
var response struct {
|
|
Data *nativeChatSession `json:"data"`
|
|
}
|
|
if err := json.Unmarshal(data, &response); err == nil && response.Data != nil {
|
|
return *response.Data, nil
|
|
}
|
|
var record nativeChatSession
|
|
if err := json.Unmarshal(data, &record); err != nil || record.ID == "" {
|
|
return nativeChatSession{}, fmt.Errorf("invalid OpenCode session response")
|
|
}
|
|
return record, nil
|
|
}
|
|
|
|
// chatSessionFields lifts the nested location.directory and time{created,updated}
|
|
// of one native session record onto protocol.ChatSession. It is the single field
|
|
// mapping shared by the list decoder and Create, so the two cannot drift.
|
|
func chatSessionFields(record nativeChatSession) protocol.ChatSession {
|
|
return protocol.ChatSession{
|
|
ID: record.ID,
|
|
Title: record.Title,
|
|
Agent: record.Agent,
|
|
Model: record.Model.ID,
|
|
Directory: record.Location.Directory,
|
|
ParentID: record.ParentID,
|
|
CreatedAt: record.Time.Created,
|
|
UpdatedAt: record.Time.Updated,
|
|
}
|
|
}
|
|
|
|
// decodeChatSessions maps the listed sessions onto protocol.ChatSession, dropping
|
|
// every record whose id is not a valid OpenCode session id (an empty or foreign
|
|
// id cannot be addressed) and ordering by UpdatedAt then id so the result is
|
|
// deterministic.
|
|
func decodeChatSessions(data []byte) ([]protocol.ChatSession, error) {
|
|
records, err := chatSessionRecords(data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sessions := make([]protocol.ChatSession, 0, len(records))
|
|
for _, record := range records {
|
|
if !sessionID.MatchString(record.ID) {
|
|
continue
|
|
}
|
|
sessions = append(sessions, chatSessionFields(record))
|
|
}
|
|
sort.SliceStable(sessions, func(i, j int) bool {
|
|
if sessions[i].UpdatedAt != sessions[j].UpdatedAt {
|
|
return sessions[i].UpdatedAt > sessions[j].UpdatedAt
|
|
}
|
|
return sessions[i].ID < sessions[j].ID
|
|
})
|
|
return sessions, nil
|
|
}
|
|
|
|
// decodeChatSession maps one created session, rejecting an empty or foreign id
|
|
// (an unaddressable session is an error, never a silent success).
|
|
func decodeChatSession(data []byte) (protocol.ChatSession, error) {
|
|
record, err := chatSessionRecord(data)
|
|
if err != nil {
|
|
return protocol.ChatSession{}, err
|
|
}
|
|
if !sessionID.MatchString(record.ID) {
|
|
return protocol.ChatSession{}, fmt.Errorf("invalid OpenCode session response")
|
|
}
|
|
return chatSessionFields(record), nil
|
|
}
|