f7a3a49f94
Store a chat's harness with its operator session, expose chat_backends and a backend choice in New chat, and route each session through a manager. The Codex adapter uses the App Server's Unix WebSocket for threads, turns, history, questions and interrupt; OpenCode remains the default and Claude is not advertised until its sidecar and login are wired.
293 lines
8.1 KiB
Go
293 lines
8.1 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"sort"
|
|
"sync"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/codex"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// chatManager routes one session to the harness that owns it. OpenCode remains
|
|
// the default; Codex is attached when its app-server control socket exists.
|
|
// The operator registry is the durable record of the backend, so a restart does
|
|
// not have to guess from a session id.
|
|
type chatManager struct {
|
|
opencode chatBroker
|
|
codex chatBroker
|
|
registry operatorRegistry
|
|
|
|
mu sync.Mutex
|
|
cache map[string]string // session id -> backend
|
|
}
|
|
|
|
func NewChatManager(ctx context.Context, open chatBroker, registry operatorRegistry) *chatManager {
|
|
m := &chatManager{opencode: open, registry: registry, cache: map[string]string{}}
|
|
if codex.Available() {
|
|
client, err := codex.Open(ctx)
|
|
if err == nil {
|
|
m.codex = client
|
|
}
|
|
}
|
|
return m
|
|
}
|
|
|
|
// Close releases the owned Codex client, if any.
|
|
func (m *chatManager) Close() {
|
|
if closer, ok := m.codex.(interface{ Close() }); ok {
|
|
closer.Close()
|
|
}
|
|
}
|
|
|
|
// Backends lists the harnesses available for a new session.
|
|
func (m *chatManager) Backends() []string {
|
|
backends := []string{}
|
|
if m.opencode != nil {
|
|
backends = append(backends, "opencode")
|
|
}
|
|
if m.codex != nil {
|
|
backends = append(backends, codex.Backend)
|
|
}
|
|
sort.Strings(backends)
|
|
return backends
|
|
}
|
|
|
|
func (m *chatManager) adapter(backend string) chatBroker {
|
|
switch backend {
|
|
case "", "opencode":
|
|
return m.opencode
|
|
case codex.Backend:
|
|
return m.codex
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func (m *chatManager) backendFor(ctx context.Context, sessionID string) string {
|
|
m.mu.Lock()
|
|
backend := m.cache[sessionID]
|
|
m.mu.Unlock()
|
|
if backend != "" {
|
|
return backend
|
|
}
|
|
if m.registry != nil {
|
|
if row, found, err := m.registry.OperatorSession(ctx, sessionID); err == nil && found && row.Backend != "" {
|
|
m.mu.Lock()
|
|
m.cache[sessionID] = row.Backend
|
|
m.mu.Unlock()
|
|
return row.Backend
|
|
}
|
|
}
|
|
return "opencode"
|
|
}
|
|
|
|
func (m *chatManager) brokerFor(ctx context.Context, sessionID string) (chatBroker, error) {
|
|
backend := m.backendFor(ctx, sessionID)
|
|
adapter := m.adapter(backend)
|
|
if adapter == nil {
|
|
return nil, errors.New("chat backend " + backend + " is not available")
|
|
}
|
|
return adapter, nil
|
|
}
|
|
|
|
// CreateBackend creates a session on the requested harness. An empty backend
|
|
// keeps the OpenCode default.
|
|
func (m *chatManager) CreateBackend(ctx context.Context, title, directory, backend string) (protocol.ChatSession, error) {
|
|
if backend == "" {
|
|
backend = "opencode"
|
|
}
|
|
adapter := m.adapter(backend)
|
|
if adapter == nil {
|
|
return protocol.ChatSession{}, errors.New("chat backend " + backend + " is not available")
|
|
}
|
|
session, err := adapter.Create(ctx, title, directory)
|
|
if err != nil {
|
|
return protocol.ChatSession{}, err
|
|
}
|
|
session.Backend = backend
|
|
m.mu.Lock()
|
|
m.cache[session.ID] = backend
|
|
m.mu.Unlock()
|
|
return session, nil
|
|
}
|
|
|
|
func (m *chatManager) Create(ctx context.Context, title, directory string) (protocol.ChatSession, error) {
|
|
return m.CreateBackend(ctx, title, directory, "opencode")
|
|
}
|
|
|
|
func (m *chatManager) Prompt(ctx context.Context, sessionID, text string) error {
|
|
adapter, err := m.brokerFor(ctx, sessionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return adapter.Prompt(ctx, sessionID, text)
|
|
}
|
|
|
|
func (m *chatManager) PromptWithMessageID(ctx context.Context, sessionID, text, messageID string) error {
|
|
adapter, err := m.brokerFor(ctx, sessionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if withID, ok := adapter.(chatPromptWithMessageID); ok {
|
|
return withID.PromptWithMessageID(ctx, sessionID, text, messageID)
|
|
}
|
|
return adapter.Prompt(ctx, sessionID, text)
|
|
}
|
|
|
|
func (m *chatManager) Stream(ctx context.Context, sessionID string, ready func(), emit func(protocol.ChatEventFrame) error) error {
|
|
adapter, err := m.brokerFor(ctx, sessionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return adapter.Stream(ctx, sessionID, ready, emit)
|
|
}
|
|
|
|
func (m *chatManager) Interrupt(ctx context.Context, sessionID string) error {
|
|
adapter, err := m.brokerFor(ctx, sessionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return adapter.Interrupt(ctx, sessionID)
|
|
}
|
|
|
|
func (m *chatManager) Messages(ctx context.Context, sessionID string, limit int, cursor string) (protocol.ChatHistoryPage, error) {
|
|
adapter, err := m.brokerFor(ctx, sessionID)
|
|
if err != nil {
|
|
return protocol.ChatHistoryPage{}, err
|
|
}
|
|
return adapter.Messages(ctx, sessionID, limit, cursor)
|
|
}
|
|
|
|
func (m *chatManager) Sessions(ctx context.Context) ([]protocol.ChatSession, error) {
|
|
sessions := []protocol.ChatSession{}
|
|
seen := map[string]bool{}
|
|
for _, adapter := range []chatBroker{m.opencode, m.codex} {
|
|
if adapter == nil {
|
|
continue
|
|
}
|
|
list, err := adapter.Sessions(ctx)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
for _, session := range list {
|
|
if session.ID == "" || seen[session.ID] {
|
|
continue
|
|
}
|
|
seen[session.ID] = true
|
|
sessions = append(sessions, session)
|
|
}
|
|
}
|
|
// A backend that cannot enumerate its own store still has registry rows.
|
|
// Resolve those individually so an older/restarted backend never silently
|
|
// drops a chat from the list.
|
|
if m.registry != nil {
|
|
if rows, err := m.registry.OperatorSessions(ctx); err == nil {
|
|
for _, row := range rows {
|
|
if seen[row.ID] || row.Backend == "" || row.Backend == "opencode" {
|
|
continue
|
|
}
|
|
adapter := m.adapter(row.Backend)
|
|
if adapter == nil {
|
|
continue
|
|
}
|
|
if session, found, err := adapter.Session(ctx, row.ID); err == nil && found {
|
|
seen[row.ID] = true
|
|
sessions = append(sessions, session)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return sessions, nil
|
|
}
|
|
|
|
func (m *chatManager) Session(ctx context.Context, sessionID string) (protocol.ChatSession, bool, error) {
|
|
adapter, err := m.brokerFor(ctx, sessionID)
|
|
if err != nil {
|
|
return protocol.ChatSession{}, false, err
|
|
}
|
|
return adapter.Session(ctx, sessionID)
|
|
}
|
|
|
|
func (m *chatManager) Permissions(ctx context.Context, sessionID string) ([]protocol.ChatPermissionFrame, error) {
|
|
adapter, err := m.brokerFor(ctx, sessionID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if permissions, ok := adapter.(interface {
|
|
Permissions(context.Context, string) ([]protocol.ChatPermissionFrame, error)
|
|
}); ok {
|
|
return permissions.Permissions(ctx, sessionID)
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func (m *chatManager) Shells(ctx context.Context, sessionID string) ([]protocol.ChatShell, error) {
|
|
adapter, err := m.brokerFor(ctx, sessionID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if shells, ok := adapter.(interface {
|
|
Shells(context.Context, string) ([]protocol.ChatShell, error)
|
|
}); ok {
|
|
return shells.Shells(ctx, sessionID)
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func (m *chatManager) Reply(ctx context.Context, request protocol.ChatReplyRequest) error {
|
|
adapter, err := m.brokerFor(ctx, request.SessionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return adapter.Reply(ctx, request)
|
|
}
|
|
|
|
func (m *chatManager) ActivateSkill(ctx context.Context, sessionID, skill string) error {
|
|
// Skill bootstrap is an OpenCode chat concept. Other harnesses return from
|
|
// create without a manager skill and must not fail the create.
|
|
if m.backendFor(ctx, sessionID) != "opencode" {
|
|
return nil
|
|
}
|
|
adapter, err := m.brokerFor(ctx, sessionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return adapter.ActivateSkill(ctx, sessionID, skill)
|
|
}
|
|
|
|
func (m *chatManager) Answer(ctx context.Context, request protocol.ChatAnswerRequest) error {
|
|
adapter, err := m.brokerFor(ctx, request.SessionID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
answerer, ok := adapter.(chatAnswerer)
|
|
if !ok {
|
|
return errors.New("this chat backend cannot answer questions")
|
|
}
|
|
return answerer.Answer(ctx, request)
|
|
}
|
|
|
|
func (m *chatManager) ShellOutput(ctx context.Context, query protocol.ChatShellOutputQuery) (protocol.ChatShellOutputPage, error) {
|
|
adapter, err := m.brokerFor(ctx, query.SessionID)
|
|
if err != nil {
|
|
return protocol.ChatShellOutputPage{}, err
|
|
}
|
|
reader, ok := adapter.(chatShellOutputReader)
|
|
if !ok {
|
|
return protocol.ChatShellOutputPage{}, errors.New("this chat backend has no shell output")
|
|
}
|
|
return reader.ShellOutput(ctx, query)
|
|
}
|
|
|
|
func (m *chatManager) ReleaseShells(sessionID string) {
|
|
m.mu.Lock()
|
|
backend := m.cache[sessionID]
|
|
m.mu.Unlock()
|
|
adapter := m.adapter(backend)
|
|
if releaser, ok := adapter.(chatShellReleaser); ok {
|
|
releaser.ReleaseShells(sessionID)
|
|
}
|
|
}
|