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.
171 lines
5.8 KiB
Go
171 lines
5.8 KiB
Go
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
|
|
}
|