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 } } 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: prompt.OperationID, } if userFrame.MessageID == "" { userFrame.MessageID = hub.nextUserMessageID() } queued, refused := hub.submitPrompt(sessionID, &chatQueuedPrompt{ text: prompt.Text, files: attachmentFiles, operationID: prompt.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, requestID: request.ID, write: write, }) if refused { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " already has the maximum number of prompts queued"}) return } accepted = true // Publish the user turn to every other client; the sender already has it. hub.broadcastUser(userFrame, clientID) 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. _ = write(protocol.Message{Type: protocol.ChatSubscribe, ID: request.ID}) 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) { 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) }