Send mid-turn chat prompts to the harness and queue the rest durably on the server

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.
This commit is contained in:
2026-11-01 18:30:20 +00:00
parent d300fdc5a5
commit e42f9cc031
25 changed files with 1568 additions and 78 deletions
+24 -6
View File
@@ -435,13 +435,31 @@ sessions pipeline runs create. The protocol types are:
client that watches a session sees every frame any client's turn produces — the
other devices' prompts and the turn's streaming output — and can answer a shared
approval. Attaching is idempotent per connection; the subscription is released
when the connection ends.
when the connection ends. The reply carries `chat_queue` (`session_id`,
`prompts`): the prompts the server still holds for the session, each with
`operation_id`, `message_id`, `native_message_id`, `text`, `client`,
`attachments` and `queued_at`, so a reloaded client draws them as queued.
- `chat_prompt` may come from any client. A prompt whose session already has a turn
in flight is accepted into that session's bounded queue (currently 8) and
acknowledged with `chat_queued: true`; the agent never receives two interleaved
turns. The prompt is echoed to the other watching clients as a `chat_event` of
kind `user`, carried with the sender's `client` label (a device name), while the
sender's own transcript keeps its local copy.
in flight is handed to that turn at once when the harness accepts mid-turn input
(Claude Code reads it from stdin at its next step; Codex takes it with
`turn/steer` pinned to the active turn) and is acknowledged as sent. Otherwise
(OpenCode, or a turn that ended meanwhile) it is written to the session's durable
server-side queue (bounded, currently 8) and acknowledged with
`chat_queued: true`; the agent never receives two interleaved turns. Queued
prompts belong to the session, not the connection: they are delivered in order
when the turn ends even with no client attached, and after a server restart once
the harness is idle. A retry with the same `operation_id` is acknowledged again,
never queued or delivered twice. The prompt is echoed to the other watching
clients as a `chat_event` of kind `user`, carried with the sender's `client`
label (a device name), while the sender's own transcript keeps its local copy;
a queued prompt's user event is published again as it is delivered.
- `chat_queue` is pushed to every watching client whenever a session's queue
changes, with the current `prompts` and the change: `delivered`, `removed`, or
`failed` with `error` (the harness refused it; it is not retried).
- `chat_unqueue` (body `chat_unqueue`: `session_id`, `operation_id`) removes one
prompt still waiting in the queue and replies with the updated `chat_queue`. A
prompt already handed to the harness is refused as already sent. Closing a chat
drops its queue.
- `chat_reply` is exactly-once: the first answer to a pending request wins, is
recorded with the answering client's label and is pushed back to every watching
client as the same `chat_permission` frame with `resolved: true`, `decision` and
+71 -4
View File
@@ -151,6 +151,8 @@ func (c *Chat) PromptWithMessageIDModelFiles(ctx context.Context, id, text, mess
if directory == "" {
return errors.New("the Claude session has no working directory")
}
s.promptMu.Lock()
defer s.promptMu.Unlock()
proc, err := s.ensureProcess(ctx)
if err != nil {
return err
@@ -182,10 +184,9 @@ func (c *Chat) PromptWithMessageIDModelFiles(ctx context.Context, id, text, mess
s.mu.Lock()
s.turnID = turn
s.running = true
s.prompts = append(s.prompts, promptRecord{id: messageID, text: strings.TrimSpace(text)})
if len(s.prompts) > 200 {
s.prompts = s.prompts[len(s.prompts)-200:]
}
s.steered = 0
s.awaitFollowUp = false
s.recordPromptLocked(messageID, text)
s.mu.Unlock()
s.emit(protocol.ChatEventFrame{SessionID: id, NativeTurnID: turn, Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepStarted, TurnID: turn}})
payload := map[string]any{
@@ -199,6 +200,72 @@ func (c *Chat) PromptWithMessageIDModelFiles(ctx context.Context, id, text, mess
return nil
}
func (s *session) recordPromptLocked(messageID, text string) {
s.prompts = append(s.prompts, promptRecord{id: messageID, text: strings.TrimSpace(text)})
if len(s.prompts) > 200 {
s.prompts = s.prompts[len(s.prompts)-200:]
}
}
// SteerPrompt hands a user message to the turn Claude Code is running now. The
// stream-json CLI accepts user messages on stdin while it works and reads them
// at its next step, surfacing them to the model within the running turn (or,
// when the turn ends first, as its own follow-up turn). It reports false when
// the session has no live process with a turn in flight, so the caller queues
// the prompt instead. The model/mode selection applies at the next turn.
func (c *Chat) SteerPrompt(ctx context.Context, id, text, messageID string, files []opencode.PromptFile) (bool, error) {
s := c.session(id)
if s == nil {
return false, nil
}
if strings.TrimSpace(text) == "" {
return false, errors.New("a nonempty chat prompt is required")
}
s.promptMu.Lock()
defer s.promptMu.Unlock()
s.mu.Lock()
proc := s.proc
running := s.running
s.mu.Unlock()
if proc == nil || !running {
return false, nil
}
content, err := promptContent(text, files)
if err != nil {
return false, err
}
payload := map[string]any{
"type": "user",
"message": map[string]any{"role": "user", "content": content},
}
if err := proc.write(payload); err != nil {
return false, fmt.Errorf("Claude Code is not accepting input: %w", err)
}
s.mu.Lock()
s.steered++
s.lastUsed = time.Now()
s.recordPromptLocked(messageID, text)
s.mu.Unlock()
return true, nil
}
// adoptFollowUpTurn starts a turn for output the CLI produces after a result
// while messages written mid-turn were outstanding: the CLI is running them as
// a turn of its own, which clients must see as running until its result.
func (s *session) adoptFollowUpTurn() {
s.mu.Lock()
if s.running || !s.awaitFollowUp {
s.mu.Unlock()
return
}
s.awaitFollowUp = false
turn := fmt.Sprintf("claude-%d", time.Now().UnixNano())
s.turnID = turn
s.running = true
s.mu.Unlock()
s.emit(protocol.ChatEventFrame{SessionID: s.id, NativeTurnID: turn, Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepStarted, TurnID: turn}})
}
// finishTurn settles a turn that never reached a CLI result.
func (s *session) finishTurn(turn, diagnostic string) {
s.mu.Lock()
+9 -2
View File
@@ -243,8 +243,15 @@ type session struct {
startErr error
turnID string
running bool
lastUsed time.Time
lastErr string
// promptMu serializes writing user turns, so a prompt and a mid-turn
// message never both decide the CLI is idle. steered counts messages
// written into the running turn; awaitFollowUp is set when a turn ended
// with some outstanding, because the CLI then runs them as its own turn.
promptMu sync.Mutex
steered int
awaitFollowUp bool
lastUsed time.Time
lastErr string
subs map[chan protocol.ChatEventFrame]struct{}
approvals map[string]*pendingApproval
+2
View File
@@ -352,6 +352,8 @@ func (s *session) processExit(p *process, err error) {
turn := s.turnID
s.running = false
s.turnID = ""
s.steered = 0
s.awaitFollowUp = false
s.resetStreamLocked()
s.mu.Unlock()
if !running {
+89
View File
@@ -0,0 +1,89 @@
package claude
import (
"context"
"os"
"strings"
"testing"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// A message sent while a turn runs is written to the CLI at once: the CLI
// reads it at the running turn's next step, and the transcript records it as
// the operator's turn at that point, carrying the caller's message id.
func TestSteerPromptReachesTheRunningTurn(t *testing.T) {
chat := testChat(t)
session := newCreatedChat(t, chat)
frames := subscribe(t, chat, session.ID)
if delivered, err := chat.SteerPrompt(context.Background(), session.ID, "too early", "msg_early", nil); err != nil || delivered {
t.Fatalf("idle session took a mid-turn message: delivered=%v err=%v", delivered, err)
}
if err := chat.Prompt(context.Background(), session.ID, "long task"); err != nil {
t.Fatal(err)
}
started := 0
waitFrame(t, frames, "turn started", func(frame protocol.ChatEventFrame) bool {
if frame.Kind == protocol.ChatEventStep && frame.Step != nil && frame.Step.Status == protocol.ChatStepStarted {
started++
return true
}
return false
})
delivered, err := chat.SteerPrompt(context.Background(), session.ID, "also check the docs", "msg_steer", nil)
if err != nil || !delivered {
t.Fatalf("running turn refused a mid-turn message: delivered=%v err=%v", delivered, err)
}
// The fake CLI only finishes the long turn once it has read the message.
waitFrame(t, frames, "steered reply", func(frame protocol.ChatEventFrame) bool {
return frame.Kind == protocol.ChatEventTool || (frame.Kind == protocol.ChatEventText && strings.Contains(frame.Delta, "Noted")) ||
(frame.Part != nil && strings.Contains(frame.Part.Text, "Noted"))
})
waitStepEnded(t, frames)
steered, err := os.ReadFile(os.Getenv("FAKE_CLAUDE_LOG") + ".steer")
if err != nil || strings.TrimSpace(string(steered)) != "also check the docs" {
t.Fatalf("CLI did not receive the message mid-turn: %q %v", steered, err)
}
if chat.TurnRunning(session.ID) {
t.Fatal("turn still running after its result")
}
page, err := chat.Messages(context.Background(), session.ID, 50, "")
if err != nil {
t.Fatal(err)
}
var users []string
for _, message := range page.Messages {
if message.Role == protocol.ChatRoleUser {
users = append(users, message.ID+"="+message.Parts[0].Text)
}
}
if len(users) != 2 || users[1] != "msg_steer=also check the docs" {
t.Fatalf("transcript users = %v, want the mid-turn message recorded once with its id", users)
}
}
// When the CLI ends the turn before reading a mid-turn message it runs that
// message as a turn of its own; its output must be reported as a running turn
// with a start and an end rather than activity outside any turn.
func TestSteerPromptFollowUpTurnIsAdopted(t *testing.T) {
chat := testChat(t)
session := newCreatedChat(t, chat)
frames := subscribe(t, chat, session.ID)
s := chat.session(session.ID)
s.mu.Lock()
s.awaitFollowUp = true
s.mu.Unlock()
s.adoptFollowUpTurn()
frame := waitFrame(t, frames, "follow-up start", func(frame protocol.ChatEventFrame) bool {
return frame.Kind == protocol.ChatEventStep && frame.Step != nil && frame.Step.Status == protocol.ChatStepStarted
})
if frame.Step.TurnID == "" || !chat.TurnRunning(session.ID) {
t.Fatalf("follow-up turn not adopted: %+v", frame.Step)
}
s.handleResult(lineEnvelope{Type: "result", Subtype: "success"})
waitStepEnded(t, frames)
s.adoptFollowUpTurn()
if chat.TurnRunning(session.ID) {
t.Fatal("a turn without outstanding messages was adopted")
}
}
+23
View File
@@ -211,8 +211,31 @@ def handle(line):
if images and log_path:
with open(log_path + ".content", "a", encoding="utf-8") as log:
log.write(json.dumps(content) + "\n")
pending = state["pending"]
if pending and pending["kind"] == "long":
steer(pending, text)
return
user_message(text)
def steer(pending, text):
"""A message written while a turn runs is read at the turn's next step,
recorded as a queued_command attachment, and the same turn finishes."""
if log_path:
with open(log_path + ".steer", "a", encoding="utf-8") as log:
log.write(text + "\n")
state["pending"] = None
append({"type": "attachment", "uuid": "steer-%d" % state["turn"], "timestamp": stamp(),
"attachment": {"type": "queued_command", "commandMode": "prompt",
"prompt": [{"type": "text", "text": text}]}})
reply = "Noted: " + text
append({"type": "assistant", "uuid": "asst-steer-%d" % state["turn"], "timestamp": stamp(),
"message": {"id": pending["message"] + "_steer", "role": "assistant", "model": "claude-test",
"content": [{"type": "text", "text": reply}]}})
send({"type": "assistant", "message": {"id": pending["message"] + "_steer", "role": "assistant",
"model": "claude-test", "content": [{"type": "text", "text": reply}]}})
finish(pending["message"])
for line in sys.stdin:
handle(line.strip())
+44 -11
View File
@@ -35,6 +35,14 @@ type transcriptEntry struct {
} `json:"message"`
ToolUseResult json.RawMessage `json:"toolUseResult"`
Compact json.RawMessage `json:"compactMetadata"`
// Attachment is set on "attachment" entries; a queued_command with
// commandMode "prompt" is a user message the CLI read mid-turn. Prompt is
// either a string or an array of content blocks.
Attachment struct {
Type string `json:"type"`
Prompt json.RawMessage `json:"prompt"`
CommandMode string `json:"commandMode"`
} `json:"attachment"`
}
func readTranscript(path string) ([]transcriptEntry, error) {
@@ -150,6 +158,22 @@ func (s *session) transcriptMessages(limit int, cursor string) (protocol.ChatHis
messages := []protocol.ChatMessage{}
messageIndex := map[string]int{}
toolIndex := map[string][2]int{} // tool id -> message/part index
addUser := func(entry transcriptEntry, text string, files []protocol.ChatPart) {
id := takePromptID(text)
if id == "" {
id = entry.UUID
}
if id == "" {
return
}
created, _ := transcriptTime(entry.Timestamp)
parts := []protocol.ChatPart{}
if text != "" {
parts = append(parts, protocol.ChatPart{Type: protocol.ChatPartText, ID: id + "#text", Text: text})
}
parts = append(parts, files...)
messages = append(messages, protocol.ChatMessage{ID: id, SessionID: s.id, Role: protocol.ChatRoleUser, CreatedAt: created, Parts: parts})
}
for _, entry := range entries {
if entry.IsSidechain {
continue
@@ -239,20 +263,29 @@ func (s *session) transcriptMessages(limit int, cursor string) (protocol.ChatHis
if hasResult || (text == "" && len(files) == 0) {
continue
}
id := takePromptID(text)
if id == "" {
id = entry.UUID
}
if id == "" {
addUser(entry, text, files)
case "attachment":
// A message the operator sent while the turn was running is recorded
// as a queued_command attachment where the CLI surfaced it to the
// model, so it is the user's turn at that point of the transcript.
// Other queued commands (task notifications, agent messages) are
// harness input, not the operator's.
if entry.Attachment.Type != "queued_command" || entry.Attachment.CommandMode != "prompt" {
continue
}
created, _ := transcriptTime(entry.Timestamp)
parts := []protocol.ChatPart{}
if text != "" {
parts = append(parts, protocol.ChatPart{Type: protocol.ChatPartText, ID: id + "#text", Text: text})
var text string
for _, block := range decodeBlocks(entry.Attachment.Prompt) {
if block.Type == "text" && strings.TrimSpace(block.Text) != "" {
if text != "" {
text += "\n"
}
text += block.Text
}
}
parts = append(parts, files...)
messages = append(messages, protocol.ChatMessage{ID: id, SessionID: s.id, Role: protocol.ChatRoleUser, CreatedAt: created, Parts: parts})
if strings.TrimSpace(text) == "" {
continue
}
addUser(entry, text, []protocol.ChatPart{})
}
}
// Drop assistant messages that ended with no renderable part (for example a
+7
View File
@@ -102,8 +102,10 @@ func (s *session) handleLine(p *process, line []byte) {
case "control_response":
s.handleControlResponse(p, envelope)
case "stream_event":
s.adoptFollowUpTurn()
s.handleStreamEvent(envelope)
case "assistant":
s.adoptFollowUpTurn()
s.handleAssistant(envelope)
case "user":
s.handleUser(envelope)
@@ -552,6 +554,10 @@ func (s *session) handleResult(envelope lineEnvelope) {
proc := s.proc
s.running = false
s.turnID = ""
// Messages written mid-turn that the CLI did not fold into this turn run
// next as their own turn; its output adopts a new turn id.
s.awaitFollowUp = s.steered > 0
s.steered = 0
s.approvals = map[string]*pendingApproval{}
s.forms = map[string]*pendingForm{}
s.resetStreamLocked()
@@ -592,6 +598,7 @@ func (s *session) handleSystem(envelope lineEnvelope) {
s.emit(protocol.ChatEventFrame{SessionID: s.id, NativeTurnID: s.currentTurn(), Kind: protocol.ChatEventCompaction, Compaction: &protocol.ChatCompaction{Status: "completed"}})
case "init":
// The CLI re-emits init at each turn; keep only the authoritative identity.
s.adoptFollowUpTurn()
if envelope.SessionID != "" && envelope.SessionID != s.id {
s.mu.Lock()
s.lastErr = "Claude Code opened unexpected session " + envelope.SessionID
+32
View File
@@ -457,6 +457,38 @@ func (c *Chat) PromptWithMessageIDModelFiles(ctx context.Context, id, text, mess
return err
}
// SteerPrompt adds a user message to the thread's active turn with the App
// Server's turn/steer, which the agent reads at its next step. expectedTurnId
// pins the turn: when it already ended (or none is active) the App Server
// refuses and false is returned so the caller queues the prompt for the next
// turn instead. A transport failure is an error: it may have been admitted and
// must not be blindly repeated.
func (c *Chat) SteerPrompt(ctx context.Context, id, text, messageID string, files []opencode.PromptFile) (bool, error) {
c.mu.Lock()
turn := c.turns[id]
c.mu.Unlock()
if turn == "" {
return false, nil
}
input, err := promptInput(text, files)
if err != nil {
return false, err
}
params := map[string]any{"threadId": id, "expectedTurnId": turn, "input": input}
if messageID != "" {
params["clientUserMessageId"] = messageID
}
_, err = c.call(ctx, "turn/steer", params)
var refused *rpcCallError
if errors.As(err, &refused) {
return false, nil
}
if err != nil {
return false, err
}
return true, nil
}
// ActivateSkill is an OpenCode-only chat concept.
func (c *Chat) ActivateSkill(context.Context, string, string) error {
return errors.New("Codex chat has no out-of-band skill activation")
+47
View File
@@ -0,0 +1,47 @@
package codex
import (
"context"
"encoding/json"
"testing"
)
// A prompt for a thread with an active turn is steered into that turn, pinned
// by expectedTurnId; a refusal (the turn already ended) reports not delivered
// so the server queues it, and a thread with no active turn is not steered.
func TestSteerPromptTargetsTheActiveTurn(t *testing.T) {
var steered []map[string]any
refuse := false
chat := modelTestChat(t, func(method string, raw json.RawMessage) any {
if method != "turn/steer" {
t.Errorf("unexpected method %s", method)
return map[string]any{}
}
var params map[string]any
if err := json.Unmarshal(raw, &params); err != nil {
t.Error(err)
}
steered = append(steered, params)
if refuse {
return &rpcError{Code: -32600, Message: "expected turn is not active"}
}
return map[string]any{"turnId": params["expectedTurnId"]}
})
if delivered, err := chat.SteerPrompt(context.Background(), fixtureThread, "idle", "msg_idle", nil); err != nil || delivered {
t.Fatalf("idle thread steered: delivered=%v err=%v", delivered, err)
}
chat.mu.Lock()
chat.turns[fixtureThread] = "turn-7"
chat.mu.Unlock()
delivered, err := chat.SteerPrompt(context.Background(), fixtureThread, "also this", "msg_steer", nil)
if err != nil || !delivered {
t.Fatalf("active turn not steered: delivered=%v err=%v", delivered, err)
}
if len(steered) != 1 || steered[0]["expectedTurnId"] != "turn-7" || steered[0]["threadId"] != fixtureThread || steered[0]["clientUserMessageId"] != "msg_steer" {
t.Fatalf("steer params = %+v", steered)
}
refuse = true
if delivered, err := chat.SteerPrompt(context.Background(), fixtureThread, "late", "msg_late", nil); err != nil || delivered {
t.Fatalf("refused steer reported delivered=%v err=%v", delivered, err)
}
}
+170
View File
@@ -0,0 +1,170 @@
package pipeline
import (
"context"
"database/sql"
"errors"
"time"
)
// ErrChatQueueFull refuses a prompt that would exceed a session's queue bound.
var ErrChatQueueFull = errors.New("chat prompt queue is full")
// ChatQueuedPrompt is one durable prompt waiting for its session's harness to
// finish the turn in flight. Files and Parts are the server-prepared attachment
// references (JSON) the prompt carries; the bytes stay in the attachment store.
type ChatQueuedPrompt struct {
ID int64
SessionID string
OperationID string
MessageID string
NativeID string
Text string
Client string
FilesJSON string
PartsJSON string
CreatedAt time.Time
}
// initChatPromptQueue creates the additive queue table. A prompt belongs to
// its chat session, not to a connection: rows are written when a prompt is
// queued behind a running turn and deleted once it is delivered or removed.
// (session_id, operation_id) is unique so a client retry never enqueues twice.
func (s *Store) initChatPromptQueue() error {
_, err := s.db.Exec(`CREATE TABLE IF NOT EXISTS chat_prompt_queue (
id INTEGER PRIMARY KEY AUTOINCREMENT,
session_id TEXT NOT NULL,
operation_id TEXT NOT NULL,
message_id TEXT NOT NULL,
native_message_id TEXT NOT NULL DEFAULT '',
text TEXT NOT NULL,
client TEXT NOT NULL DEFAULT '',
files_json TEXT NOT NULL DEFAULT '[]',
parts_json TEXT NOT NULL DEFAULT '[]',
created_at INTEGER NOT NULL,
UNIQUE(session_id, operation_id));
CREATE INDEX IF NOT EXISTS chat_prompt_queue_session ON chat_prompt_queue(session_id, id);`)
return err
}
// EnqueueChatPrompt appends prompt to its session's queue. When the session
// already holds the same operation id the existing row is returned with
// created false and nothing is written. A new row that would exceed limit is
// refused with ErrChatQueueFull.
func (s *Store) EnqueueChatPrompt(ctx context.Context, prompt ChatQueuedPrompt, limit int) (ChatQueuedPrompt, bool, error) {
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return ChatQueuedPrompt{}, false, err
}
defer tx.Rollback()
existing, err := scanChatQueuedPrompt(tx.QueryRowContext(ctx, chatQueueSelect+` WHERE session_id = ? AND operation_id = ?`, prompt.SessionID, prompt.OperationID))
if err == nil {
return existing, false, nil
}
if !errors.Is(err, sql.ErrNoRows) {
return ChatQueuedPrompt{}, false, err
}
var count int
if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM chat_prompt_queue WHERE session_id = ?`, prompt.SessionID).Scan(&count); err != nil {
return ChatQueuedPrompt{}, false, err
}
if limit > 0 && count >= limit {
return ChatQueuedPrompt{}, false, ErrChatQueueFull
}
if prompt.CreatedAt.IsZero() {
prompt.CreatedAt = time.Now()
}
if prompt.FilesJSON == "" {
prompt.FilesJSON = "[]"
}
if prompt.PartsJSON == "" {
prompt.PartsJSON = "[]"
}
result, err := tx.ExecContext(ctx, `INSERT INTO chat_prompt_queue
(session_id, operation_id, message_id, native_message_id, text, client, files_json, parts_json, created_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
prompt.SessionID, prompt.OperationID, prompt.MessageID, prompt.NativeID, prompt.Text, prompt.Client,
prompt.FilesJSON, prompt.PartsJSON, prompt.CreatedAt.UnixMilli())
if err != nil {
return ChatQueuedPrompt{}, false, err
}
if prompt.ID, err = result.LastInsertId(); err != nil {
return ChatQueuedPrompt{}, false, err
}
if err := tx.Commit(); err != nil {
return ChatQueuedPrompt{}, false, err
}
return prompt, true, nil
}
// DeleteChatQueuedPrompt removes one queued prompt and reports whether a row
// was removed.
func (s *Store) DeleteChatQueuedPrompt(ctx context.Context, sessionID, operationID string) (bool, error) {
result, err := s.db.ExecContext(ctx, `DELETE FROM chat_prompt_queue WHERE session_id = ? AND operation_id = ?`, sessionID, operationID)
if err != nil {
return false, err
}
n, err := result.RowsAffected()
return n > 0, err
}
// ClearChatQueuedPrompts drops every queued prompt of one session.
func (s *Store) ClearChatQueuedPrompts(ctx context.Context, sessionID string) error {
_, err := s.db.ExecContext(ctx, `DELETE FROM chat_prompt_queue WHERE session_id = ?`, sessionID)
return err
}
// ChatQueuedPrompts lists one session's queued prompts in delivery order.
func (s *Store) ChatQueuedPrompts(ctx context.Context, sessionID string) ([]ChatQueuedPrompt, error) {
rows, err := s.db.QueryContext(ctx, chatQueueSelect+` WHERE session_id = ? ORDER BY id`, sessionID)
if err != nil {
return nil, err
}
defer rows.Close()
var prompts []ChatQueuedPrompt
for rows.Next() {
prompt, err := scanChatQueuedPrompt(rows)
if err != nil {
return nil, err
}
prompts = append(prompts, prompt)
}
return prompts, rows.Err()
}
// ChatQueuedSessions lists the sessions holding queued prompts, oldest first,
// so a restarted server can resume their delivery.
func (s *Store) ChatQueuedSessions(ctx context.Context) ([]string, error) {
rows, err := s.db.QueryContext(ctx, `SELECT session_id FROM chat_prompt_queue GROUP BY session_id ORDER BY MIN(id)`)
if err != nil {
return nil, err
}
defer rows.Close()
var sessions []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return nil, err
}
sessions = append(sessions, id)
}
return sessions, rows.Err()
}
const chatQueueSelect = `SELECT id, session_id, operation_id, message_id, native_message_id, text, client, files_json, parts_json, created_at FROM chat_prompt_queue`
type chatQueueScanner interface {
Scan(...any) error
}
func scanChatQueuedPrompt(row chatQueueScanner) (ChatQueuedPrompt, error) {
var prompt ChatQueuedPrompt
var created int64
err := row.Scan(&prompt.ID, &prompt.SessionID, &prompt.OperationID, &prompt.MessageID, &prompt.NativeID,
&prompt.Text, &prompt.Client, &prompt.FilesJSON, &prompt.PartsJSON, &created)
if err != nil {
return ChatQueuedPrompt{}, err
}
prompt.CreatedAt = time.UnixMilli(created)
return prompt, nil
}
@@ -0,0 +1,45 @@
package pipeline
import (
"context"
"errors"
"path/filepath"
"testing"
)
func TestChatPromptQueueOrderDedupeAndBound(t *testing.T) {
ctx := context.Background()
path := filepath.Join(t.TempDir(), "queue.db")
store, err := Open(path)
if err != nil {
t.Fatal(err)
}
for _, op := range []string{"a", "b"} {
if _, created, err := store.EnqueueChatPrompt(ctx, ChatQueuedPrompt{SessionID: "ses_1", OperationID: op, MessageID: "m-" + op, Text: op}, 2); err != nil || !created {
t.Fatalf("enqueue %s: created=%v err=%v", op, created, err)
}
}
if row, created, err := store.EnqueueChatPrompt(ctx, ChatQueuedPrompt{SessionID: "ses_1", OperationID: "a", Text: "again"}, 2); err != nil || created || row.Text != "a" {
t.Fatalf("duplicate operation: row=%+v created=%v err=%v", row, created, err)
}
if _, _, err := store.EnqueueChatPrompt(ctx, ChatQueuedPrompt{SessionID: "ses_1", OperationID: "c", Text: "c"}, 2); !errors.Is(err, ErrChatQueueFull) {
t.Fatalf("bound not enforced: %v", err)
}
store.Close()
store, err = Open(path)
if err != nil {
t.Fatal(err)
}
defer store.Close()
sessions, err := store.ChatQueuedSessions(ctx)
if err != nil || len(sessions) != 1 || sessions[0] != "ses_1" {
t.Fatalf("sessions = %v %v", sessions, err)
}
if removed, err := store.DeleteChatQueuedPrompt(ctx, "ses_1", "a"); err != nil || !removed {
t.Fatalf("delete: %v %v", removed, err)
}
rows, err := store.ChatQueuedPrompts(ctx, "ses_1")
if err != nil || len(rows) != 1 || rows[0].OperationID != "b" || rows[0].MessageID != "m-b" {
t.Fatalf("rows = %+v %v", rows, err)
}
}
+4
View File
@@ -81,6 +81,10 @@ CREATE TABLE IF NOT EXISTS submissions (id INTEGER PRIMARY KEY, name TEXT NOT NU
db.Close()
return nil, err
}
if err := s.initChatPromptQueue(); err != nil {
db.Close()
return nil, err
}
if err := s.initAppNotifications(); err != nil {
db.Close()
return nil, err
+41
View File
@@ -69,6 +69,16 @@ const (
// body is a ChatQuery naming the session and the response echoes the request
// id once the subscription is attached.
ChatSubscribe = "chat_subscribe"
// ChatQueue is pushed to every client watching a session whenever its
// server-side prompt queue changes (a prompt queued, delivered, removed or
// refused by the harness). The chat_subscribe reply carries the same body so
// a reloaded client draws the queued prompts the server still holds.
ChatQueue = "chat_queue"
// ChatUnqueue removes one prompt the server still holds in a session's
// queue, named by its operation id. Its body is ChatUnqueueRequest and the
// reply carries the updated queue in ChatQueue. A prompt already delivered
// to the harness is no longer removable and is refused.
ChatUnqueue = "chat_unqueue"
// ChatDirectories is the request/response type for the operator's directory
// choices: the home directory plus the directories of previous operator
// sessions, most recently used first, deduplicated and bounded. It is a
@@ -354,6 +364,37 @@ type ChatPromptRequest struct {
Attachments []ChatAttachment `json:"attachments,omitempty"`
}
// ChatQueuedPrompt is one prompt the server holds for a session until its
// harness finishes the turn in flight. It is durable: it survives the sending
// client disconnecting and a server restart, and is delivered in order.
type ChatQueuedPrompt struct {
OperationID string `json:"operation_id"`
MessageID string `json:"message_id"`
NativeMessageID string `json:"native_message_id,omitempty"`
Text string `json:"text"`
Client string `json:"client,omitempty"`
Attachments []ChatPart `json:"attachments,omitempty"`
QueuedAt int64 `json:"queued_at,omitempty"`
}
// ChatQueueFrame is a session's current server-side prompt queue, in delivery
// order. Delivered, Removed or Failed name the operation whose change produced
// the frame; Error carries the harness refusal for Failed.
type ChatQueueFrame struct {
SessionID string `json:"session_id"`
Prompts []ChatQueuedPrompt `json:"prompts"`
Delivered string `json:"delivered,omitempty"`
Removed string `json:"removed,omitempty"`
Failed string `json:"failed,omitempty"`
Error string `json:"error,omitempty"`
}
// ChatUnqueueRequest names one queued prompt to remove.
type ChatUnqueueRequest struct {
SessionID string `json:"session_id"`
OperationID string `json:"operation_id"`
}
// ChatAttachment is one browser attachment carried by a chat prompt. Data is
// standard base64 (no data: prefix); Name is a display name and Mime is the
// browser's content type. The server derives the on-disk name and never trusts
+5
View File
@@ -221,6 +221,11 @@ type Message struct {
// accepted into the session's queue instead of being sent immediately.
ChatSubscribe *ChatQuery `json:"chat_subscribe,omitempty"`
ChatQueued bool `json:"chat_queued,omitempty"`
// ChatQueue is the session's server-held prompt queue: pushed as a
// chat_queue frame when it changes and carried by the chat_subscribe and
// chat_unqueue replies.
ChatQueue *ChatQueueFrame `json:"chat_queue,omitempty"`
ChatUnqueue *ChatUnqueueRequest `json:"chat_unqueue,omitempty"`
// ChatDirectories carries the operator's directory choices on a
// chat_directories response (home first, then recent operator-session
// directories, deduplicated and bounded). Additive/omitempty so older peers
+3
View File
@@ -167,6 +167,9 @@ func handleChat(ctx context.Context, request protocol.Message, broker chatBroker
case protocol.ChatSubscribe:
handleChatSubscribe(request, broker, hub, clientID, write)
return true
case protocol.ChatUnqueue:
handleChatUnqueue(ctx, request, hub, write)
return true
case protocol.ChatMessages:
handleChatMessages(ctx, request, broker, hub, write)
return true
+2
View File
@@ -56,6 +56,8 @@ func handleChatClose(ctx context.Context, request protocol.Message, broker chatB
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
return
}
// A closed chat takes no more turns: prompts it still held are dropped.
hub.clearQueue(ctx, sessionID)
session, found, err := registry.OperatorSession(ctx, sessionID)
if err != nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
+6
View File
@@ -34,3 +34,9 @@ func TestAdvertisedChatHarnessesExposeInteractiveWebContract(t *testing.T) {
}
}
}
// Claude Code and Codex take a prompt into a running turn; OpenCode does not
// (its prompts are queued durably on the server behind the running turn).
var _ chatMidTurn = (*claude.Chat)(nil)
var _ chatMidTurn = (*codex.Chat)(nil)
var _ chatMidTurn = (*chatManager)(nil)
+7
View File
@@ -51,6 +51,13 @@ type chatHub struct {
attentionSeen map[string]struct{}
attentionOrder []string
attentionWG sync.WaitGroup
// queueStore persists prompts queued behind a running turn; nil keeps the
// queue in memory only (tests and store-less servers).
queueStore chatPromptQueueStore
// recentOps/recentOpOrder are the bounded record of accepted prompt
// operation ids, so a client retry is acknowledged instead of re-sent.
recentOps map[string]struct{}
recentOpOrder []string
}
// chatPart is the retained form of one part. Text and reasoning deltas append to
+20
View File
@@ -388,6 +388,26 @@ func (m *chatManager) PromptWithMessageIDFiles(ctx context.Context, sessionID, t
return errChatAttachmentsUnsupported
}
// SteerPrompt forwards a prompt into the routed harness's running turn when
// that harness accepts mid-turn input (Claude Code, Codex). A harness without
// it reports not delivered, so the hub queues the prompt durably instead.
func (m *chatManager) SteerPrompt(ctx context.Context, sessionID, text, messageID string, files []opencode.PromptFile) (bool, error) {
adapter, err := m.brokerFor(ctx, sessionID)
if err != nil {
return false, err
}
steerer, ok := adapter.(chatMidTurn)
if !ok {
return false, nil
}
if len(files) > 0 {
if _, ok := adapter.(chatPromptWithFiles); !ok {
return false, errChatAttachmentsUnsupported
}
}
return steerer.SteerPrompt(ctx, sessionID, text, messageID, files)
}
var errChatAttachmentsUnsupported = errors.New("this chat harness does not support attachments")
var errChatFormReadbackUnsupported = errors.New("this chat harness does not support pending question readback")
+476
View File
@@ -0,0 +1,476 @@
package server
import (
"context"
"encoding/json"
"errors"
"fmt"
"log"
"net/url"
"path/filepath"
"time"
"git.a-wan.net/alan/pipelines/internal/opencode"
"git.a-wan.net/alan/pipelines/internal/pipeline"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// A prompt that arrives while its session's turn is running belongs to the
// server, not to the connection that sent it. Where the harness accepts input
// mid-turn (Claude Code's stream-json stdin, Codex turn/steer) the prompt is
// forwarded at once and the harness reads it at its next step. Otherwise it is
// written to the durable chat_prompt_queue and delivered in order when the turn
// ends, whether or not any client is still attached, and after a restart.
// chatQueueBusyPoll is how often a room holding queued prompts re-checks a
// harness that reports its own turn in flight. TurnRunning performs no I/O.
var chatQueueBusyPoll = time.Second
// chatQueueRecoverySettle gives a restarted server's freshly attached stream a
// moment to announce a turn the harness is still running, so a recovered
// prompt is not delivered into a busy harness that only reports activity
// through its stream.
var chatQueueRecoverySettle = 1500 * time.Millisecond
// chatRecentOpsLimit bounds the remembered accepted operation ids used to
// refuse a duplicate delivery of a client retry.
const chatRecentOpsLimit = 256
// chatPromptQueueStore is the durable queue seam; *pipeline.Store implements it.
type chatPromptQueueStore interface {
EnqueueChatPrompt(ctx context.Context, prompt pipeline.ChatQueuedPrompt, limit int) (pipeline.ChatQueuedPrompt, bool, error)
DeleteChatQueuedPrompt(ctx context.Context, sessionID, operationID string) (bool, error)
ClearChatQueuedPrompts(ctx context.Context, sessionID string) error
ChatQueuedPrompts(ctx context.Context, sessionID string) ([]pipeline.ChatQueuedPrompt, error)
ChatQueuedSessions(ctx context.Context) ([]string, error)
}
// chatMidTurn is implemented by a broker that can hand a user message to a
// turn already running. delivered is false (with a nil error) when the session
// has no turn the harness can take input for right now, and the caller then
// queues the prompt instead. An error means the harness refused the message.
type chatMidTurn interface {
SteerPrompt(ctx context.Context, sessionID, text, messageID string, files []opencode.PromptFile) (bool, error)
}
// chatAdmission is the outcome of offering one prompt to a session.
type chatAdmission int
const (
chatAdmitRun chatAdmission = iota
chatAdmitQueued
chatAdmitSteered
chatAdmitRefused
)
type chatStoredFile struct {
URI string `json:"uri"`
Name string `json:"name"`
}
// admitPrompt starts p when the session is idle, forwards it into the running
// turn when the harness supports mid-turn input, and otherwise queues it
// (durably when a store is configured). It never blocks on the turn itself.
func (h *chatHub) admitPrompt(ctx context.Context, sessionID string, broker chatBroker, p *chatQueuedPrompt) (chatAdmission, error) {
h.mu.Lock()
room := h.roomLocked(sessionID)
if room.broker == nil {
room.broker = broker
}
busy := room.running || len(room.queue) > 0 || room.observedTurn
queuedAhead := len(room.queue) > 0
h.mu.Unlock()
if !busy {
busy = brokerTurnRunning(broker, sessionID)
}
if !busy {
h.mu.Lock()
room.queue = append(room.queue, p)
signalWake(room.wake)
h.mu.Unlock()
return chatAdmitRun, nil
}
if steerer, ok := broker.(chatMidTurn); ok && !queuedAhead {
delivered, err := steerer.SteerPrompt(ctx, sessionID, p.text, p.nativeID, p.files)
if err != nil {
return chatAdmitRefused, err
}
if delivered {
releaseChatAttachments(p.files)
return chatAdmitSteered, nil
}
}
p.acked = true
p.queuedAt = h.clock()
if store := h.queueStore; store != nil {
row, created, err := store.EnqueueChatPrompt(ctx, chatQueueRow(sessionID, p), chatRoomQueueLimit)
if errors.Is(err, pipeline.ErrChatQueueFull) {
return chatAdmitRefused, errChatQueueFull(sessionID)
}
if err != nil {
return chatAdmitRefused, fmt.Errorf("queue prompt: %w", err)
}
if !created {
// A retry of a prompt the server already holds: acknowledge it as
// queued again without a second entry.
releaseChatAttachments(p.files)
return chatAdmitQueued, nil
}
p.durable = true
p.queuedAt = row.CreatedAt
}
h.mu.Lock()
if !p.durable && len(room.queue) >= chatRoomQueueLimit {
h.mu.Unlock()
return chatAdmitRefused, errChatQueueFull(sessionID)
}
room.queue = append(room.queue, p)
signalWake(room.wake)
h.mu.Unlock()
h.fanoutQueue(sessionID, protocol.ChatQueueFrame{})
return chatAdmitQueued, nil
}
func errChatQueueFull(sessionID string) error {
return errors.New("session " + sessionID + " already has the maximum number of prompts queued")
}
// brokerTurnRunning asks a harness that knows its own turn state without I/O.
func brokerTurnRunning(broker chatBroker, sessionID string) bool {
reporter, ok := broker.(chatTurnReporter)
return ok && reporter.TurnRunning(sessionID)
}
func chatQueueRow(sessionID string, p *chatQueuedPrompt) pipeline.ChatQueuedPrompt {
files := make([]chatStoredFile, 0, len(p.files))
for _, file := range p.files {
files = append(files, chatStoredFile{URI: file.URI, Name: file.Name})
}
filesJSON, _ := json.Marshal(files)
parts := p.parts
if parts == nil {
parts = []protocol.ChatPart{}
}
partsJSON, _ := json.Marshal(parts)
return pipeline.ChatQueuedPrompt{
SessionID: sessionID,
OperationID: p.operationID,
MessageID: p.messageID,
NativeID: p.nativeID,
Text: p.text,
Client: p.client,
FilesJSON: string(filesJSON),
PartsJSON: string(partsJSON),
CreatedAt: p.queuedAt,
}
}
// promptFromRow rebuilds a queued prompt read back from the store. Its files
// must still name the server's own attachment directory; they are leased again
// so retention cannot collect them before delivery.
func promptFromRow(row pipeline.ChatQueuedPrompt) (*chatQueuedPrompt, error) {
p := &chatQueuedPrompt{
text: row.Text,
operationID: row.OperationID,
messageID: row.MessageID,
nativeID: row.NativeID,
client: row.Client,
acked: true,
durable: true,
queuedAt: row.CreatedAt,
}
_ = json.Unmarshal([]byte(row.PartsJSON), &p.parts)
var stored []chatStoredFile
if err := json.Unmarshal([]byte(row.FilesJSON), &stored); err != nil {
return p, fmt.Errorf("queued prompt attachments are unreadable")
}
if len(stored) == 0 {
return p, nil
}
dir, err := chatAttachmentDir()
if err != nil {
return p, err
}
chatAttachmentStore.Lock()
defer chatAttachmentStore.Unlock()
for _, file := range stored {
u, err := url.Parse(file.URI)
if err != nil || u.Scheme != "file" || filepath.Dir(u.Path) != dir {
return p, fmt.Errorf("queued prompt attachment %q is outside the attachment store", file.Name)
}
chatAttachmentStore.leased[u.Path] = true
p.files = append(p.files, opencode.NewPreparedPromptFile(file.URI, file.Name))
}
return p, nil
}
// queueFrame is the session's current server-held queue. A live room is the
// authority while it exists; otherwise the store answers.
func (h *chatHub) queueFrame(sessionID string) protocol.ChatQueueFrame {
frame := protocol.ChatQueueFrame{SessionID: sessionID, Prompts: []protocol.ChatQueuedPrompt{}}
h.mu.Lock()
room := h.rooms[sessionID]
if room != nil {
for _, p := range room.queue {
if p.acked {
frame.Prompts = append(frame.Prompts, p.wire())
}
}
h.mu.Unlock()
return frame
}
h.mu.Unlock()
if h.queueStore == nil {
return frame
}
rows, err := h.queueStore.ChatQueuedPrompts(h.baseCtx, sessionID)
if err != nil {
log.Printf("chat queue read session=%s: %v", sessionID, err)
return frame
}
for _, row := range rows {
p := &chatQueuedPrompt{text: row.Text, operationID: row.OperationID, messageID: row.MessageID, nativeID: row.NativeID, client: row.Client, queuedAt: row.CreatedAt}
_ = json.Unmarshal([]byte(row.PartsJSON), &p.parts)
frame.Prompts = append(frame.Prompts, p.wire())
}
return frame
}
func (p *chatQueuedPrompt) wire() protocol.ChatQueuedPrompt {
out := protocol.ChatQueuedPrompt{
OperationID: p.operationID,
MessageID: p.messageID,
NativeMessageID: p.nativeID,
Text: p.text,
Client: p.client,
Attachments: p.parts,
}
if !p.queuedAt.IsZero() {
out.QueuedAt = p.queuedAt.UnixMilli()
}
return out
}
// fanoutQueue pushes the session's current queue to every attached client,
// naming the change in change's Delivered/Removed/Failed/Error fields.
func (h *chatHub) fanoutQueue(sessionID string, change protocol.ChatQueueFrame) {
frame := h.queueFrame(sessionID)
frame.Delivered, frame.Removed, frame.Failed, frame.Error = change.Delivered, change.Removed, change.Failed, change.Error
h.fanout(sessionID, protocol.Message{Type: protocol.ChatQueue, ChatQueue: &frame}, "")
}
// forgetQueued drops a delivered or failed prompt's durable row.
func (h *chatHub) forgetQueued(sessionID string, p *chatQueuedPrompt) {
if !p.durable || h.queueStore == nil {
return
}
if _, err := h.queueStore.DeleteChatQueuedPrompt(h.baseCtx, sessionID, p.operationID); err != nil {
log.Printf("chat queue delete session=%s: %v", sessionID, err)
}
}
// unqueue removes one prompt still waiting in the session's queue. It reports
// false when the session holds no such prompt (it was delivered already).
func (h *chatHub) unqueue(ctx context.Context, sessionID, operationID string) (bool, error) {
var removed *chatQueuedPrompt
h.mu.Lock()
room := h.rooms[sessionID]
if room != nil {
// The live room is authoritative: a prompt its runner already took is
// being delivered and is no longer removable, even though its durable row
// is only deleted once the harness accepted it.
for i, p := range room.queue {
if p.acked && p.operationID == operationID {
removed = p
room.queue = append(room.queue[:i:i], room.queue[i+1:]...)
break
}
}
}
h.mu.Unlock()
found := removed != nil
if removed != nil {
releaseChatAttachments(removed.files)
}
if h.queueStore != nil && (room == nil || removed != nil) {
deleted, err := h.queueStore.DeleteChatQueuedPrompt(ctx, sessionID, operationID)
if err != nil {
return found, err
}
found = found || deleted
}
if found {
h.forgetOp(sessionID, operationID)
h.fanoutQueue(sessionID, protocol.ChatQueueFrame{Removed: operationID})
}
return found, nil
}
// clearQueue drops every prompt a closed session still holds.
func (h *chatHub) clearQueue(ctx context.Context, sessionID string) {
var dropped []*chatQueuedPrompt
h.mu.Lock()
if room := h.rooms[sessionID]; room != nil {
kept := room.queue[:0]
for _, p := range room.queue {
if p.acked {
dropped = append(dropped, p)
} else {
kept = append(kept, p)
}
}
room.queue = kept
}
h.mu.Unlock()
for _, p := range dropped {
releaseChatAttachments(p.files)
}
if h.queueStore != nil {
if err := h.queueStore.ClearChatQueuedPrompts(ctx, sessionID); err != nil {
log.Printf("chat queue clear session=%s: %v", sessionID, err)
}
}
if len(dropped) > 0 {
h.fanoutQueue(sessionID, protocol.ChatQueueFrame{})
}
}
// resumeQueued restores every session's durable queue after a restart: each
// session gets a room (with no client attached) whose runner delivers the
// prompts in order once the harness is idle.
func (h *chatHub) resumeQueued(ctx context.Context, broker chatBroker) {
if h.queueStore == nil || broker == nil {
return
}
sessions, err := h.queueStore.ChatQueuedSessions(ctx)
if err != nil {
log.Printf("chat queue recovery: %v", err)
return
}
for _, sessionID := range sessions {
rows, err := h.queueStore.ChatQueuedPrompts(ctx, sessionID)
if err != nil {
log.Printf("chat queue recovery session=%s: %v", sessionID, err)
continue
}
var prompts []*chatQueuedPrompt
for _, row := range rows {
p, err := promptFromRow(row)
if err != nil {
releaseChatAttachments(p.files)
log.Printf("chat queue recovery session=%s: %v", sessionID, err)
_, _ = h.queueStore.DeleteChatQueuedPrompt(ctx, sessionID, row.OperationID)
continue
}
prompts = append(prompts, p)
}
if len(prompts) == 0 {
continue
}
h.mu.Lock()
room := h.roomLocked(sessionID)
if room.broker == nil {
room.broker = broker
}
room.notBefore = time.Now().Add(chatQueueRecoverySettle)
for _, p := range prompts {
if !room.holdsOp(p.operationID) {
room.queue = append(room.queue, p)
h.rememberOpLocked(sessionID, p.operationID)
}
}
h.mu.Unlock()
go func(room *chatRoom) {
// Attach the stream first so a turn the harness is still running is
// observed before the settle window lets the runner deliver.
if err := h.ensureObserving(room, broker); err != nil && room.ctx.Err() == nil {
log.Printf("chat queue recovery observe session=%s: %v", room.sessionID, err)
}
h.mu.Lock()
signalWake(room.wake)
h.mu.Unlock()
}(room)
}
}
func (r *chatRoom) holdsOp(operationID string) bool {
for _, p := range r.queue {
if p.operationID == operationID {
return true
}
}
return false
}
// duplicateOp reports whether operationID is a prompt this session already
// accepted (queued reports it is still waiting in the queue), so a client retry
// is acknowledged again instead of delivered twice.
func (h *chatHub) duplicateOp(sessionID, operationID string) (duplicate, queued bool) {
if operationID == "" {
return false, false
}
h.mu.Lock()
defer h.mu.Unlock()
if room := h.rooms[sessionID]; room != nil {
for _, p := range room.queue {
if p.operationID == operationID {
return true, p.acked
}
}
}
_, seen := h.recentOps[sessionID+"\x00"+operationID]
return seen, false
}
func (h *chatHub) rememberOp(sessionID, operationID string) {
h.mu.Lock()
defer h.mu.Unlock()
h.rememberOpLocked(sessionID, operationID)
}
func (h *chatHub) rememberOpLocked(sessionID, operationID string) {
if operationID == "" {
return
}
key := sessionID + "\x00" + operationID
if h.recentOps == nil {
h.recentOps = map[string]struct{}{}
}
if _, ok := h.recentOps[key]; ok {
return
}
h.recentOps[key] = struct{}{}
h.recentOpOrder = append(h.recentOpOrder, key)
for len(h.recentOpOrder) > chatRecentOpsLimit {
delete(h.recentOps, h.recentOpOrder[0])
h.recentOpOrder = h.recentOpOrder[1:]
}
}
// forgetOp lets a prompt that never reached the harness be retried.
func (h *chatHub) forgetOp(sessionID, operationID string) {
h.mu.Lock()
defer h.mu.Unlock()
delete(h.recentOps, sessionID+"\x00"+operationID)
}
// handleChatUnqueue removes one queued prompt and replies with the queue.
func handleChatUnqueue(ctx context.Context, request protocol.Message, hub *chatHub, write func(protocol.Message) error) {
body := request.ChatUnqueue
if body == nil || !validChatSessionID(body.SessionID) || body.OperationID == "" {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid session id and operation id are required"})
return
}
found, err := hub.unqueue(ctx, body.SessionID, body.OperationID)
if err != nil {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
return
}
if !found {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "that message is no longer queued; it was already sent"})
return
}
frame := hub.queueFrame(body.SessionID)
frame.Removed = body.OperationID
_ = write(protocol.Message{Type: protocol.ChatUnqueue, ID: request.ID, ChatQueue: &frame})
}
+263
View File
@@ -0,0 +1,263 @@
package server
import (
"context"
"net/http/httptest"
"path/filepath"
"slices"
"sync"
"testing"
"time"
"github.com/coder/websocket"
"github.com/coder/websocket/wsjson"
"git.a-wan.net/alan/pipelines/internal/opencode"
"git.a-wan.net/alan/pipelines/internal/pipeline"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// steeringChat is a channelChat whose harness takes input mid-turn, the way
// Claude Code's stream-json stdin and Codex turn/steer do.
type steeringChat struct {
*channelChat
steerMu sync.Mutex
steered []string
}
func (c *steeringChat) SteerPrompt(_ context.Context, _, text, _ string, _ []opencode.PromptFile) (bool, error) {
c.steerMu.Lock()
defer c.steerMu.Unlock()
c.steered = append(c.steered, text)
return true, nil
}
type queueServer struct {
ctx context.Context
cancel context.CancelFunc
srv *httptest.Server
}
func startQueueServer(t *testing.T, broker chatBroker, store *pipeline.Store) *queueServer {
t.Helper()
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
srv := httptest.NewServer(HandlerWithOptions(ctx, Options{Chat: broker}, store))
s := &queueServer{ctx: ctx, cancel: cancel, srv: srv}
t.Cleanup(s.stop)
return s
}
func (s *queueServer) stop() {
s.srv.CloseClientConnections()
s.srv.Close()
s.cancel()
}
func openQueueStore(t *testing.T, path string) *pipeline.Store {
t.Helper()
store, err := pipeline.Open(path)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { store.Close() })
return store
}
func queuedOps(t *testing.T, store *pipeline.Store) []string {
t.Helper()
rows, err := store.ChatQueuedPrompts(context.Background(), "ses_1")
if err != nil {
t.Fatal(err)
}
var ops []string
for _, row := range rows {
ops = append(ops, row.OperationID)
}
return ops
}
func sendPrompt(t *testing.T, ctx context.Context, conn *websocket.Conn, id, text, operation string) protocol.Message {
t.Helper()
writeChat(t, ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: id, ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: text, OperationID: operation, Client: "Phone"}})
return readUntil(t, ctx, conn, protocol.ChatPrompt)
}
func waitFor(t *testing.T, what string, check func() bool) {
t.Helper()
deadline := time.Now().Add(5 * time.Second)
for time.Now().Before(deadline) {
if check() {
return
}
time.Sleep(5 * time.Millisecond)
}
t.Fatalf("timed out waiting for %s", what)
}
func endTurn(broker *channelChat) {
broker.push(protocol.ChatEventFrame{SessionID: "ses_1", Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepEnded}})
}
// A prompt sent while a turn runs on a harness with mid-turn input is handed
// to that turn at once: it is acknowledged as sent, never queued or stored.
func TestChatPromptDuringTurnIsSteeredImmediately(t *testing.T) {
store := openQueueStore(t, filepath.Join(t.TempDir(), "queue.db"))
broker := &steeringChat{channelChat: newChannelChat()}
server := startQueueServer(t, broker, store)
conn := dialChatConn(t, server.ctx, server.srv)
if ack := sendPrompt(t, server.ctx, conn, "p1", "one", "op-1"); ack.ChatQueued {
t.Fatalf("first prompt queued: %+v", ack)
}
waitFor(t, "first prompt", func() bool { return broker.promptCount() == 1 })
if ack := sendPrompt(t, server.ctx, conn, "p2", "two", "op-2"); ack.ChatQueued {
t.Fatalf("mid-turn prompt was queued instead of forwarded: %+v", ack)
}
broker.steerMu.Lock()
steered := slices.Clone(broker.steered)
broker.steerMu.Unlock()
if !slices.Equal(steered, []string{"two"}) || broker.promptCount() != 1 {
t.Fatalf("steered=%v prompts=%v", steered, broker.promptTexts())
}
if ops := queuedOps(t, store); len(ops) != 0 {
t.Fatalf("steered prompt was stored: %v", ops)
}
// A retry of the same operation is acknowledged, never forwarded again.
if ack := sendPrompt(t, server.ctx, conn, "p2-retry", "two", "op-2"); ack.ChatQueued {
t.Fatalf("retry ack = %+v", ack)
}
broker.steerMu.Lock()
defer broker.steerMu.Unlock()
if len(broker.steered) != 1 {
t.Fatalf("retry steered again: %v", broker.steered)
}
}
// Without mid-turn input the prompt is queued on the server: it is stored
// once (a retry of the same operation id is not a second entry), outlives the
// last client leaving, and is delivered when the turn ends with nobody
// watching.
func TestChatQueuedPromptSurvivesDetachAndDeliversUnwatched(t *testing.T) {
store := openQueueStore(t, filepath.Join(t.TempDir(), "queue.db"))
broker := newChannelChat()
server := startQueueServer(t, broker, store)
conn := dialChatConn(t, server.ctx, server.srv)
sendPrompt(t, server.ctx, conn, "p1", "one", "op-1")
if ack := sendPrompt(t, server.ctx, conn, "p2", "two", "op-2"); !ack.ChatQueued {
t.Fatalf("second prompt not queued: %+v", ack)
}
if ack := sendPrompt(t, server.ctx, conn, "p2-retry", "two", "op-2"); !ack.ChatQueued {
t.Fatalf("retry of a queued prompt not acknowledged as queued: %+v", ack)
}
if ops := queuedOps(t, store); !slices.Equal(ops, []string{"op-2"}) {
t.Fatalf("stored queue = %v, want op-2 once", ops)
}
conn.CloseNow()
time.Sleep(100 * time.Millisecond) // let the server notice the disconnect
endTurn(broker)
waitFor(t, "queued prompt delivered with no client", func() bool {
return slices.Equal(broker.promptTexts(), []string{"one", "two"})
})
waitFor(t, "delivered row deleted", func() bool { return len(queuedOps(t, store)) == 0 })
}
// The durable queue survives a server restart: the reopened store's prompts
// are delivered once the harness is idle, with no client connected.
func TestChatQueuedPromptSurvivesRestart(t *testing.T) {
previous := chatQueueRecoverySettle
chatQueueRecoverySettle = 10 * time.Millisecond
t.Cleanup(func() { chatQueueRecoverySettle = previous })
path := filepath.Join(t.TempDir(), "queue.db")
first := openQueueStore(t, path)
broker := newChannelChat()
server := startQueueServer(t, broker, first)
conn := dialChatConn(t, server.ctx, server.srv)
sendPrompt(t, server.ctx, conn, "p1", "one", "op-1")
if ack := sendPrompt(t, server.ctx, conn, "p2", "two", "op-2"); !ack.ChatQueued {
t.Fatalf("second prompt not queued: %+v", ack)
}
server.stop()
first.Close()
reopened := openQueueStore(t, path)
if ops := queuedOps(t, reopened); !slices.Equal(ops, []string{"op-2"}) {
t.Fatalf("queue after restart = %v", ops)
}
restarted := newChannelChat()
startQueueServer(t, restarted, reopened)
waitFor(t, "recovered prompt delivered", func() bool {
return slices.Equal(restarted.promptTexts(), []string{"two"})
})
waitFor(t, "recovered row deleted", func() bool { return len(queuedOps(t, reopened)) == 0 })
}
// A client that attaches later (a reload) is told what the server still holds
// in chat_subscribe, can remove a queued prompt, and a removed prompt is never
// delivered.
func TestChatSubscribeListsQueuedPromptsAndUnqueueRemoves(t *testing.T) {
store := openQueueStore(t, filepath.Join(t.TempDir(), "queue.db"))
broker := newChannelChat()
server := startQueueServer(t, broker, store)
phone := dialChatConn(t, server.ctx, server.srv)
sendPrompt(t, server.ctx, phone, "p1", "one", "op-1")
sendPrompt(t, server.ctx, phone, "p2", "two", "op-2")
sendPrompt(t, server.ctx, phone, "p3", "three", "op-3")
phone.CloseNow()
reloaded := dialChatConn(t, server.ctx, server.srv)
writeChat(t, server.ctx, reloaded, protocol.Message{Type: protocol.ChatSubscribe, ID: "sub", ChatSubscribe: &protocol.ChatQuery{SessionID: "ses_1"}})
ack := readUntil(t, server.ctx, reloaded, protocol.ChatSubscribe)
if ack.ChatQueue == nil || len(ack.ChatQueue.Prompts) != 2 {
t.Fatalf("subscribe queue = %+v", ack.ChatQueue)
}
got := ack.ChatQueue.Prompts[0]
if got.OperationID != "op-2" || got.Text != "two" || got.Client != "Phone" || got.MessageID == "" || ack.ChatQueue.Prompts[1].OperationID != "op-3" {
t.Fatalf("queued prompts = %+v", ack.ChatQueue.Prompts)
}
writeChat(t, server.ctx, reloaded, protocol.Message{Type: protocol.ChatUnqueue, ID: "rm", ChatUnqueue: &protocol.ChatUnqueueRequest{SessionID: "ses_1", OperationID: "op-2"}})
removed := readUntil(t, server.ctx, reloaded, protocol.ChatUnqueue)
if removed.ChatQueue == nil || removed.ChatQueue.Removed != "op-2" || len(removed.ChatQueue.Prompts) != 1 {
t.Fatalf("unqueue reply = %+v", removed.ChatQueue)
}
if ops := queuedOps(t, store); !slices.Equal(ops, []string{"op-3"}) {
t.Fatalf("stored queue after unqueue = %v", ops)
}
endTurn(broker)
// Delivery re-publishes the user turn and reports it sent to the client
// that attached after it was queued.
sawUser := false
for {
var message protocol.Message
if err := wsjson.Read(server.ctx, reloaded, &message); err != nil {
t.Fatalf("no delivery reported: %v", err)
}
if event := message.ChatEvent; event != nil && event.Kind == protocol.ChatEventUser && event.OperationID == "op-3" {
sawUser = true
}
if message.Type == protocol.ChatQueue && message.ChatQueue.Delivered != "" {
if message.ChatQueue.Delivered != "op-3" || len(message.ChatQueue.Prompts) != 0 || !sawUser {
t.Fatalf("delivery frame = %+v (user turn seen: %v)", message.ChatQueue, sawUser)
}
break
}
}
if texts := broker.promptTexts(); !slices.Equal(texts, []string{"one", "three"}) {
t.Fatalf("delivered prompts = %v, want the removed one skipped", texts)
}
if ops := queuedOps(t, store); len(ops) != 0 {
t.Fatalf("stored queue after delivery = %v", ops)
}
// A prompt already delivered can no longer be removed.
writeChat(t, server.ctx, reloaded, protocol.Message{Type: protocol.ChatUnqueue, ID: "rm-late", ChatUnqueue: &protocol.ChatUnqueueRequest{SessionID: "ses_1", OperationID: "op-3"}})
for {
var message protocol.Message
if err := wsjson.Read(server.ctx, reloaded, &message); err != nil {
t.Fatal(err)
}
if message.ID == "rm-late" {
if message.Type != protocol.Error {
t.Fatalf("late unqueue = %+v", message)
}
break
}
}
}
+134 -48
View File
@@ -101,14 +101,25 @@ func (s *chatSub) close() {
// turn runner does not send a second (success) acknowledgement for the same
// request id; write is kept either way so a later broker failure is still
// reported to the client that sent it.
//
// durable marks a prompt written to the chat_prompt_queue store: it outlives
// the connection that sent it (write may be nil after a restart) and its row is
// deleted once the harness accepted it. messageID, client and parts let the
// server re-publish the user turn when it is finally delivered, so a client
// that attached after it was queued still sees it enter the transcript.
type chatQueuedPrompt struct {
text string
files []opencode.PromptFile
operationID string
nativeID string
messageID string
client string
parts []protocol.ChatPart
requestID string
write func(protocol.Message) error
acked bool
durable bool
queuedAt time.Time
}
type chatObservation struct {
@@ -153,6 +164,9 @@ type chatRoom struct {
wake chan struct{}
turnDone chan struct{}
nativeTurnID string
// notBefore holds back a recovered queue until the restarted stream had a
// chance to report a turn the harness is still running.
notBefore time.Time
}
func newChatRoom(base context.Context, sessionID string) *chatRoom {
@@ -295,8 +309,11 @@ func (h *chatHub) attach(sessionID, clientID, label string, broker chatBroker, w
}
// detach drops one subscription. The room (and its broker stream and queue) is
// released once its last client leaves, so a session with no watchers holds no
// goroutine.
// released once its last client leaves and it has no prompt left to deliver,
// so a session with no watchers holds no goroutine. A room holding queued
// prompts stays (with its stream) until its runner has delivered them: the
// queue belongs to the session, not to the clients watching it. A running turn
// with nothing queued behind it needs no room; the harness finishes it alone.
func (h *chatHub) detach(sessionID string, sub *chatSub) {
h.mu.Lock()
room := h.rooms[sessionID]
@@ -305,19 +322,27 @@ func (h *chatHub) detach(sessionID string, sub *chatSub) {
return
}
delete(room.subs, sub.clientID)
if len(room.subs) == 0 {
h.clearCompactionLocked(room)
delete(h.rooms, sessionID)
room.cancel()
// ReleaseShells is a local identity-cache operation (no broker I/O).
// Complete it before a reconnect can acquire this session's new room.
if releaser, ok := room.broker.(chatShellReleaser); ok {
releaser.ReleaseShells(sessionID)
}
if len(room.subs) == 0 && len(room.queue) == 0 {
h.releaseRoomLocked(room)
}
h.mu.Unlock()
}
// releaseRoomLocked destroys an unwatched, idle room. Callers hold h.mu.
func (h *chatHub) releaseRoomLocked(room *chatRoom) {
if h.rooms[room.sessionID] != room {
return
}
h.clearCompactionLocked(room)
delete(h.rooms, room.sessionID)
room.cancel()
// ReleaseShells is a local identity-cache operation (no broker I/O).
// Complete it before a reconnect can acquire this session's new room.
if releaser, ok := room.broker.(chatShellReleaser); ok {
releaser.ReleaseShells(room.sessionID)
}
}
// detachClient drops every chat subscription one connection holds; the read loop
// calls it when the connection ends so no subscriber goroutine outlives it.
func (h *chatHub) detachClient(clientID string) {
@@ -530,6 +555,8 @@ func (h *chatHub) finishTurnLocked(room *chatRoom) {
close(room.turnDone)
room.turnDone = nil
}
// A queue held behind a turn this room only observed advances now.
signalWake(room.wake)
}
// turnInFlight reports whether sessionID has a turn in flight, so chat_close
@@ -576,32 +603,6 @@ func (h *chatHub) flushBuffered(sessionID string) {
}
}
// submitPrompt accepts one prompt: it starts the turn runner immediately when no
// turn is in flight, or queues it (bounded) when one is. It returns whether the
// prompt was queued or refused.
func (h *chatHub) submitPrompt(sessionID string, p *chatQueuedPrompt) (queued bool, refused bool) {
h.mu.Lock()
room := h.roomLocked(sessionID)
if room.running || len(room.queue) > 0 {
if len(room.queue) >= chatRoomQueueLimit {
h.mu.Unlock()
return false, true
}
// The client is acknowledged as queued by the handler, so the turn runner
// must not acknowledge the same request again once it runs. The write is
// still kept so a later broker failure reaches the client that sent it.
p.acked = true
room.queue = append(room.queue, p)
signalWake(room.wake)
h.mu.Unlock()
return true, false
}
room.queue = append(room.queue, p)
signalWake(room.wake)
h.mu.Unlock()
return false, false
}
// turnRunning reports whether the session has a turn in flight. A client that
// subscribes after a turn started (for example the operator's browser while the
// CLI harness is working) needs this to show Stop and the live activity line;
@@ -707,30 +708,68 @@ func (h *chatHub) runRoom(room *chatRoom) {
return
}
h.runTurn(room, p, done)
// The last client may have left while this turn ran; an unwatched room
// stays only while it still has prompts to deliver.
h.mu.Lock()
if len(room.subs) == 0 && !room.running && len(room.queue) == 0 {
h.releaseRoomLocked(room)
}
h.mu.Unlock()
}
}
// nextPrompt pops the next queued prompt, blocking until one arrives or the room
// is released. It marks the room running and creates the turn's completion
// channel so a stale signal from a previous turn can never end the next one.
// is released. A queued prompt also waits while the harness is still running a
// turn this room did not start (one announced by the stream, or one a harness
// reports in flight after a reload or restart). It marks the room running and
// creates the turn's completion channel so a stale signal from a previous turn
// can never end the next one.
func (h *chatHub) nextPrompt(room *chatRoom) (*chatQueuedPrompt, chan struct{}, bool) {
for {
h.mu.Lock()
if len(room.queue) > 0 {
p := room.queue[0]
room.queue = room.queue[1:]
room.running = true
room.nativeTurnID = ""
room.turnDone = make(chan struct{})
done := room.turnDone
if room.ctx.Err() != nil {
h.mu.Unlock()
return p, done, true
return nil, nil, false
}
var wait time.Duration
if len(room.queue) > 0 {
switch {
case room.observedTurn:
wait = chatQueueBusyPoll
case time.Until(room.notBefore) > 0:
wait = time.Until(room.notBefore)
default:
broker := room.broker
h.mu.Unlock()
busy := brokerTurnRunning(broker, room.sessionID)
h.mu.Lock()
if busy {
wait = chatQueueBusyPoll
} else if len(room.queue) > 0 && !room.observedTurn && room.ctx.Err() == nil {
p := room.queue[0]
room.queue = room.queue[1:]
room.running = true
room.nativeTurnID = ""
room.turnDone = make(chan struct{})
done := room.turnDone
h.mu.Unlock()
return p, done, true
} else {
h.mu.Unlock()
continue
}
}
}
h.mu.Unlock()
var timer <-chan time.Time
if wait > 0 {
timer = time.After(wait)
}
select {
case <-room.ctx.Done():
return nil, nil, false
case <-room.wake:
case <-timer:
}
}
}
@@ -751,6 +790,7 @@ func (h *chatHub) runTurn(room *chatRoom, p *chatQueuedPrompt, done chan struct{
if broker == nil {
h.failPrompt(room, p, errors.New("chat is not configured on this server"))
h.endRoomTurn(room)
return
}
if first {
@@ -760,6 +800,7 @@ func (h *chatHub) runTurn(room *chatRoom, p *chatQueuedPrompt, done chan struct{
return
}
}
h.publishDelivery(room, p)
var promptErr error
if withFiles, ok := broker.(chatPromptWithFiles); ok && len(p.files) > 0 {
promptErr = withFiles.PromptWithMessageIDFiles(room.ctx, room.sessionID, p.text, p.nativeID, p.files)
@@ -781,6 +822,13 @@ func (h *chatHub) runTurn(room *chatRoom, p *chatQueuedPrompt, done chan struct{
if p.write != nil && !p.acked {
_ = p.write(protocol.Message{Type: protocol.ChatPrompt, ID: p.requestID})
}
if p.acked {
// The harness has it now: drop the durable row and tell every client the
// queued prompt was sent.
h.rememberOp(room.sessionID, p.operationID)
h.forgetQueued(room.sessionID, p)
h.fanoutQueue(room.sessionID, protocol.ChatQueueFrame{Delivered: p.operationID})
}
h.flushBuffered(room.sessionID)
// Start the approval poller once, after the first ack, so a pending request
// is surfaced after the prompt is acknowledged and shared with every client.
@@ -804,13 +852,51 @@ func (h *chatHub) endRoomTurn(room *chatRoom) {
// that never reached the agent is visible on the device that sent it rather than
// leaving its composer waiting. It is reported for a queued prompt too, whose
// success ack was already sent but whose delivery may still fail.
//
// A queued prompt's durable row is dropped (the harness refused it, so it is
// not retried blindly) and every attached client is told through chat_queue,
// including a client that attached after the sender left.
func (h *chatHub) failPrompt(room *chatRoom, p *chatQueuedPrompt, err error) {
if p.write == nil || err == nil {
if err == nil {
return
}
h.forgetOp(room.sessionID, p.operationID)
if p.acked {
h.forgetQueued(room.sessionID, p)
h.fanoutQueue(room.sessionID, protocol.ChatQueueFrame{Failed: p.operationID, Error: err.Error()})
}
if p.write == nil {
return
}
_ = p.write(protocol.Message{Type: protocol.Error, ID: p.requestID, Error: err.Error()})
}
// publishDelivery re-publishes a queued prompt's user turn as it is handed to
// the harness, so a client that attached after it was queued (a reload, or the
// sender's other device) sees it enter the transcript before the reply. Clients
// that already hold it recognise the same message and operation ids.
func (h *chatHub) publishDelivery(room *chatRoom, p *chatQueuedPrompt) {
if !p.acked || p.messageID == "" {
return
}
frame := protocol.ChatEventFrame{
SessionID: room.sessionID,
MessageID: p.messageID,
Kind: protocol.ChatEventUser,
Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: p.text},
Attachments: p.parts,
Client: p.client,
OperationID: p.operationID,
}
h.mu.Lock()
turn := h.turnLocked(room.sessionID)
if _, retained := turn.messages[p.messageID]; !retained {
h.applyLocked(frame)
}
h.mu.Unlock()
h.fanout(room.sessionID, protocol.Message{Type: protocol.ChatEvent, ChatEvent: &frame}, "")
}
// roomBroker returns the broker bound to the room.
func (h *chatHub) roomBroker(room *chatRoom) chatBroker {
h.mu.Lock()
+36 -7
View File
@@ -59,6 +59,18 @@ func handleChatPrompt(ctx context.Context, request protocol.Message, broker chat
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()})
@@ -85,29 +97,43 @@ func handleChatPrompt(ctx context.Context, request protocol.Message, broker chat
Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: prompt.Text},
Attachments: attachmentParts,
Client: sub.label,
OperationID: prompt.OperationID,
OperationID: operationID,
}
if userFrame.MessageID == "" {
userFrame.MessageID = hub.nextUserMessageID()
}
queued, refused := hub.submitPrompt(sessionID, &chatQueuedPrompt{
queuedPrompt := &chatQueuedPrompt{
text: prompt.Text,
files: attachmentFiles,
operationID: prompt.OperationID,
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,
})
if refused {
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " already has the maximum number of prompts queued"})
}
// 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
@@ -200,7 +226,10 @@ func handleChatSubscribe(request protocol.Message, broker chatBroker, hub *chatH
}
// 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})
// 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})
+8
View File
@@ -118,6 +118,14 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin
settingsStore = stores[0]
}
hub.settings = settingsStore
if len(stores) > 0 {
// Prompts queued behind a running turn are durable and owned by their
// session; resume delivering any a previous process left queued.
hub.queueStore = stores[0]
if options.Chat != nil {
go hub.resumeQueued(ctx, options.Chat)
}
}
acks := newAttentionAckHub()
var ackStore attentionAckStore
var notes *appNotifier