Files
pipelines/internal/opencode/chat.go
T
alan b8b545accd Stream brokered OpenCode chat replies over /connect
Add the server-side half of the brokered chat path (route B): the
opencode.Chat adapter forwards chat_prompt to POST
/api/session/{id}/prompt through the owned Connection.Call translation
and derives chat_event frames from the authenticated /api/event SSE
firehose (text and reasoning deltas, tool parts with their status
transitions, step and usage). Every pushed frame carries a stable
session and message id, with a last-message-id fallback so step/tool
events that omit the assistant message id stay attributable.

The /connect handler keeps per-session retained state (chatHub) capped at
1 MiB with least-recently-updated eviction at 128 turns, so a
reconnecting client re-syncs through chat_messages instead of replaying
deltas the OpenCode per-session log never resends. Prompt dispatch
subscribes before posting and buffers pre-ack frames to preserve order,
and cancels the stream on disconnect so no goroutine leaks. chat_sessions
and chat_create are declared but not yet brokered: they answer with an
explicit protocol error rather than the generic Pong.

Reuse the existing transport, validation and normalization; no second
OpenCode transport or credential path is introduced.

Tests: protocol golden round-trip, adapter normalization + v1/v2 Call
translation, and handler ack/stream/validation/resume/disconnect, plus a
real-adapter no-tool evidence harness.
2026-10-16 04:09:14 +01:00

356 lines
13 KiB
Go

package opencode
import (
"bufio"
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"strings"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// 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
}
// 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) }
// 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")
}
body := map[string]any{"parts": []map[string]string{{"type": "text", "text": text}}}
if _, err := c.conn.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.conn.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
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)
}
if err != nil {
return nil, err
}
return decodeChatMessages(id, data)
}
// 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.conn.Call(ctx, "post", path, body); err != nil {
return err
}
return 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()
}
// 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
}
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
}
// decodeChatMessages maps the native /message response onto the protocol chat
// history shape. Assistant content parts are text, reasoning and tool; a user
// turn is the prompt text. It never re-derives provider shapes.
type nativeChatMessage struct {
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 []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"`
} `json:"parts"`
}
// 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) {
var response struct {
Data []nativeChatMessage `json:"data"`
}
if err := json.Unmarshal(data, &response); err == nil && response.Data != nil {
return response.Data, 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 _, message := range records {
role := message.Info.Role
if role != protocol.ChatRoleUser && role != protocol.ChatRoleAssistant {
continue
}
out := protocol.ChatMessage{ID: message.Info.ID, SessionID: sessionID, Role: role, Model: message.Info.ModelID, Agent: message.Info.Agent, CreatedAt: message.Info.CreatedAt}
for _, part := range message.Parts {
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})
}
}
messages = append(messages, out)
}
return messages, nil
}