e42f9cc031
Claude Code (stream-json stdin) and Codex (turn/steer pinned to the active turn) receive a prompt sent while a turn runs immediately. Other harnesses (OpenCode) get a durable chat_prompt_queue row owned by the session: it survives the last client detaching and a server restart, is delivered in order when the turn ends with or without a client, and is deduplicated by operation id. chat_subscribe carries the queue, chat_queue frames report delivered/removed/failed changes, and chat_unqueue removes a waiting prompt.
278 lines
12 KiB
Go
278 lines
12 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/opencode"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// chatPermissionPollInterval is the fixed interval between permission polls: one
|
|
// GET per poll through the shared Connection bounds, never a busy loop. The first
|
|
// poll runs immediately so a request pending when a turn starts is surfaced
|
|
// without waiting a full interval.
|
|
const chatPermissionPollInterval = 2 * time.Second
|
|
|
|
// handleChatPrompt accepts a prompt from any client. It never rejects a prompt
|
|
// because another client is watching the session: the client attaches to the
|
|
// session's shared room and the prompt either starts a turn or is queued behind
|
|
// the one in flight, with the ack saying which. The prompt is echoed live to
|
|
// every other client, attributed to the sending device's label, and the turn's
|
|
// output is fanned out to all of them.
|
|
func handleChatPrompt(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, clientID string, write func(protocol.Message) error) {
|
|
if broker == nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"})
|
|
return
|
|
}
|
|
prompt := request.ChatPrompt
|
|
if prompt == nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a chat prompt payload is required"})
|
|
return
|
|
}
|
|
if !validChatSessionID(prompt.SessionID) {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid OpenCode session id is required"})
|
|
return
|
|
}
|
|
if strings.TrimSpace(prompt.Text) == "" {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a nonempty chat prompt is required"})
|
|
return
|
|
}
|
|
// Reject an oversized prompt before any OpenCode call; the bound matches the
|
|
// OpenCode request limit.
|
|
if len(prompt.Text) > opencode.MaxRequest {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat prompt exceeds 64 KiB"})
|
|
return
|
|
}
|
|
if len(prompt.Attachments) > 0 {
|
|
var err error
|
|
if checker, ok := broker.(interface {
|
|
CheckAttachments(context.Context, string) error
|
|
}); ok {
|
|
err = checker.CheckAttachments(ctx, prompt.SessionID)
|
|
} else if _, ok := broker.(chatPromptWithFiles); !ok {
|
|
err = errChatAttachmentsUnsupported
|
|
}
|
|
if err != nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
|
|
return
|
|
}
|
|
}
|
|
operationID := prompt.OperationID
|
|
if operationID == "" {
|
|
// Every server-held prompt is addressable (chat_unqueue) and unique in
|
|
// its session's durable queue, so mint an id for a client that sent none.
|
|
operationID = "srv-" + strings.TrimPrefix(chatClientToken(), "conn-")
|
|
} else if duplicate, queued := hub.duplicateOp(prompt.SessionID, operationID); duplicate {
|
|
// A retry of a prompt this session already accepted: acknowledge it the
|
|
// same way again instead of delivering it a second time.
|
|
hub.attach(prompt.SessionID, clientID, sanitizeChatClientLabel(prompt.Client), broker, write)
|
|
_ = write(protocol.Message{Type: protocol.ChatPrompt, ID: request.ID, ChatQueued: queued})
|
|
return
|
|
}
|
|
attachmentFiles, attachmentParts, err := prepareChatAttachments(prompt.SessionID, prompt.Attachments)
|
|
if err != nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
|
|
return
|
|
}
|
|
accepted := false
|
|
defer func() {
|
|
if !accepted {
|
|
releaseChatAttachments(attachmentFiles)
|
|
}
|
|
}()
|
|
sessionID := prompt.SessionID
|
|
sub := hub.attach(sessionID, clientID, sanitizeChatClientLabel(prompt.Client), broker, write)
|
|
if sub == nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "could not attach to session " + sessionID})
|
|
return
|
|
}
|
|
// The user turn every *other* client sees, carrying the sender's label. The
|
|
// sender's own client appended it locally, so it is excluded below.
|
|
userFrame := protocol.ChatEventFrame{
|
|
SessionID: sessionID,
|
|
MessageID: prompt.NativeMessageID,
|
|
Kind: protocol.ChatEventUser,
|
|
Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: prompt.Text},
|
|
Attachments: attachmentParts,
|
|
Client: sub.label,
|
|
OperationID: operationID,
|
|
}
|
|
if userFrame.MessageID == "" {
|
|
userFrame.MessageID = hub.nextUserMessageID()
|
|
}
|
|
queuedPrompt := &chatQueuedPrompt{
|
|
text: prompt.Text,
|
|
files: attachmentFiles,
|
|
operationID: operationID,
|
|
// Only the caller's real OpenCode message id is forwarded. The hub's own
|
|
// `usr_` display id is not a valid OpenCode `msg_` id, so a client that
|
|
// omitted native_message_id lets OpenCode generate one instead.
|
|
nativeID: prompt.NativeMessageID,
|
|
messageID: userFrame.MessageID,
|
|
client: sub.label,
|
|
parts: attachmentParts,
|
|
requestID: request.ID,
|
|
write: write,
|
|
}
|
|
// Claim the operation before admission so a concurrent retry of the same
|
|
// prompt is acknowledged rather than delivered twice.
|
|
hub.rememberOp(sessionID, operationID)
|
|
admission, admitErr := hub.admitPrompt(ctx, sessionID, broker, queuedPrompt)
|
|
if admission == chatAdmitRefused {
|
|
hub.forgetOp(sessionID, operationID)
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: admitErr.Error()})
|
|
return
|
|
}
|
|
accepted = true
|
|
queued := admission == chatAdmitQueued
|
|
// Publish the user turn to every other client; the sender already has it.
|
|
hub.broadcastUser(userFrame, clientID)
|
|
if admission == chatAdmitSteered {
|
|
// The harness took the message into its running turn: it is sent, not
|
|
// queued, and the turn already in flight carries its reply.
|
|
_ = write(protocol.Message{Type: protocol.ChatPrompt, ID: request.ID})
|
|
}
|
|
if queued {
|
|
// The client that sent it is told the prompt is waiting for the in-flight
|
|
// turn, so it shows queued/steering instead of blocking or silently
|
|
// dropping the message. The turn runner acknowledges it once it runs, so
|
|
// clear the ack on the queued entry to avoid a second ack for the same id.
|
|
_ = write(protocol.Message{Type: protocol.ChatPrompt, ID: request.ID, ChatQueued: true})
|
|
}
|
|
if registry != nil {
|
|
// Recency is one UPDATE: it moves the operator session to the front of
|
|
// chat_sessions. A session id that is not an operator session updates no
|
|
// row and is not an error, so pipeline stage prompts are unaffected.
|
|
if err := registry.TouchOperatorSession(ctx, sessionID); err != nil {
|
|
// Best-effort; the turn runner also touches on delivery.
|
|
_ = err
|
|
}
|
|
}
|
|
}
|
|
|
|
// handleChatModels lists the models a session's harness can switch to.
|
|
func handleChatModels(ctx context.Context, request protocol.Message, broker chatBroker, write func(protocol.Message) error) {
|
|
query := request.ChatQuery
|
|
if query == nil || !validChatSessionID(query.SessionID) {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid OpenCode session id is required"})
|
|
return
|
|
}
|
|
modeler, ok := broker.(chatModeler)
|
|
if !ok {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "this chat harness does not support changing models"})
|
|
return
|
|
}
|
|
models, err := modeler.Models(ctx, query.SessionID)
|
|
if err != nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
|
|
return
|
|
}
|
|
_ = write(protocol.Message{Type: protocol.ChatModels, ID: request.ID, ChatModels: models})
|
|
}
|
|
|
|
// handleChatModelSwitch changes one session's model for subsequent turns.
|
|
func handleChatModelSwitch(ctx context.Context, request protocol.Message, broker chatBroker, write func(protocol.Message) error) {
|
|
body := request.ModelRequest
|
|
if body == nil || !validChatSessionID(body.SessionID) {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid OpenCode session id is required"})
|
|
return
|
|
}
|
|
if strings.TrimSpace(body.Provider) == "" || strings.TrimSpace(body.Model) == "" {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a model and provider are required"})
|
|
return
|
|
}
|
|
modeler, ok := broker.(chatModeler)
|
|
if !ok {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "this chat harness does not support changing models"})
|
|
return
|
|
}
|
|
if err := modeler.SwitchModel(ctx, body.SessionID, body.Provider, body.Model); err != nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
|
|
return
|
|
}
|
|
reply := *body
|
|
reply.Selection = ""
|
|
if reporter, ok := broker.(interface {
|
|
ModelSelectionMode(context.Context, string) string
|
|
}); ok {
|
|
reply.Selection = reporter.ModelSelectionMode(ctx, body.SessionID)
|
|
}
|
|
_ = write(protocol.Message{Type: protocol.ChatModelSelect, ID: request.ID, ModelRequest: &reply})
|
|
}
|
|
|
|
// handleChatSubscribe attaches one connection to a session's shared stream so it
|
|
// receives every frame any client's turn produces, its own or another device's.
|
|
// It replays the session's still-pending approval requests, if the room holds
|
|
// any, so a device that joins late still shows the cards.
|
|
func handleChatSubscribe(request protocol.Message, broker chatBroker, hub *chatHub, clientID string, write func(protocol.Message) error) {
|
|
// The wire body of chat_subscribe is the chat_subscribe field (the app's
|
|
// subscribeRequest and docs/cli.md both use it), not the chat_query body the
|
|
// other session-scoped commands carry.
|
|
query := request.ChatSubscribe
|
|
if query == nil || !validChatSessionID(query.SessionID) {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid OpenCode session id is required"})
|
|
return
|
|
}
|
|
if broker == nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"})
|
|
return
|
|
}
|
|
sub := hub.attach(query.SessionID, clientID, "", broker, write)
|
|
if sub == nil {
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "could not attach to session " + query.SessionID})
|
|
return
|
|
}
|
|
// Acknowledge before the stream is allowed to fan out: otherwise an immediately
|
|
// available retained shell can overtake the subscribe reply on this connection.
|
|
// The reply carries the prompts the server still holds for the session, so
|
|
// a reloaded client draws them as Queued without any device storage.
|
|
queue := hub.queueFrame(query.SessionID)
|
|
_ = write(protocol.Message{Type: protocol.ChatSubscribe, ID: request.ID, ChatQueue: &queue})
|
|
if err := hub.ensureObserving(sub.room, broker); err != nil {
|
|
sub.close()
|
|
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "could not observe session " + query.SessionID})
|
|
return
|
|
}
|
|
// Observe requests from CLI-originated turns and recover after reload; do
|
|
// not require the browser to send another prompt just to start polling.
|
|
hub.startRoomPoller(sub.room, broker)
|
|
// A turn already in flight when this client attaches has no `step started`
|
|
// frame in its future, so replay the live marker. The composer's Stop control
|
|
// and the transcript's one activity row read it; the later `step ended` frame
|
|
// settles them normally.
|
|
if hub.turnRunning(query.SessionID, broker) {
|
|
sub.send(protocol.Message{Type: protocol.ChatEvent, ChatEvent: &protocol.ChatEventFrame{
|
|
SessionID: query.SessionID,
|
|
Kind: protocol.ChatEventStep,
|
|
Step: &protocol.ChatStep{Status: protocol.ChatStepStarted},
|
|
}})
|
|
}
|
|
// Replay every still-unresolved approval request the room holds, not only the
|
|
// most recent one, so a client that attaches after two requests were raised
|
|
// still sees both cards.
|
|
for _, pending := range hub.pendingFrames(query.SessionID) {
|
|
frame := pending
|
|
sub.send(protocol.Message{Type: protocol.ChatPermission, ChatPermission: &frame})
|
|
}
|
|
// Replay a question/form the agent raised before this client attached, so a
|
|
// reload or another device still sees the paused tool call.
|
|
for _, form := range hub.pendingForms(query.SessionID) {
|
|
pending := form
|
|
sub.send(protocol.Message{Type: protocol.ChatEvent, ChatEvent: &protocol.ChatEventFrame{
|
|
SessionID: query.SessionID,
|
|
Kind: protocol.ChatEventForm,
|
|
Form: &pending,
|
|
}})
|
|
}
|
|
// Replay the background processes still running, so a device that attaches
|
|
// after they started (a reconnect, or a chat opened from another device)
|
|
// shows them rather than nothing until they exit. The message snapshot cannot
|
|
// carry a shell — a shell outlives the turn and is not a turn — so this is the
|
|
// shell half of the resume.
|
|
hub.replayShells(sub)
|
|
hub.replayCompaction(sub)
|
|
hub.replayUsage(sub)
|
|
}
|