Files
pipelines/internal/server/chat_tools_service.go
T

191 lines
6.2 KiB
Go

package server
import (
"context"
"crypto/rand"
"encoding/hex"
"encoding/json"
"log"
"net/http"
"strings"
"sync"
"time"
"git.a-wan.net/alan/pipelines/internal/chattools"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// chatShownStore persists the items a chat's model showed (pipeline.Store).
type chatShownStore interface {
AppendChatShownItem(ctx context.Context, sessionID string, item protocol.ChatShownItem) error
ChatShownItems(ctx context.Context, sessionID string) ([]protocol.ChatShownItem, error)
}
// chatToolCorrelationWait is how long a call on a shared (instance) endpoint
// waits for the harness stream to report the matching running tool call.
var chatToolCorrelationWait = 3 * time.Second
// chatToolService runs the Pipelines tools (chattools.Service) for the chat an
// endpoint token serves, records each shown item and pushes it to the chat's
// subscribers.
type chatToolService struct {
tokens chatToolTokenStore
shown chatShownStore
hub *chatHub
registry operatorRegistry
home func() (string, error)
notify chatToolNotifier
limiter *chatNotifyLimiter
now func() time.Time
}
func newChatToolService(tokens chatToolTokenStore, shown chatShownStore, hub *chatHub, registry operatorRegistry) *chatToolService {
return &chatToolService{tokens: tokens, shown: shown, hub: hub, registry: registry, home: OperatorHomeDirectory,
notify: hub.publishToolNotification, limiter: newChatNotifyLimiter(5, time.Minute), now: time.Now}
}
// registerChatTools serves the MCP endpoint on mux. The route exists only on
// the server's own listener; neither the web proxy nor the peer relay forwards
// it.
func registerChatTools(mux *http.ServeMux, service *chatToolService, version string) {
handler := chattools.Handler{Service: service, Version: version}
mux.HandleFunc(chatToolPath+"{token}", func(w http.ResponseWriter, r *http.Request) {
handler.ServeHTTP(w, r, r.PathValue("token"))
})
}
func (s *chatToolService) Known(ctx context.Context, token string) bool {
if s == nil || s.tokens == nil || len(token) != 64 {
return false
}
_, found, err := s.tokens.ChatToolScope(ctx, token)
return err == nil && found
}
func (s *chatToolService) Call(ctx context.Context, token, tool string, arguments json.RawMessage) chattools.Result {
sessionID, refusal := s.session(ctx, token, tool, arguments)
if refusal != "" {
return chattools.Result{Text: refusal, IsError: true}
}
item, result := s.run(ctx, sessionID, tool, arguments)
if item == nil {
return result
}
item.ID = newChatShownID()
item.CreatedAt = s.now().UnixMilli()
if s.shown != nil {
if err := s.shown.AppendChatShownItem(ctx, sessionID, *item); err != nil {
log.Printf("chat tools session=%s: record %s: %v", sessionID, tool, err)
return chattools.Result{Text: "Pipelines could not record this item: " + err.Error(), IsError: true}
}
}
if s.hub != nil {
s.hub.fanout(sessionID, protocol.Message{Type: protocol.ChatShown,
ChatShown: &protocol.ChatShownFrame{SessionID: sessionID, Items: []protocol.ChatShownItem{*item}}}, "")
}
return result
}
// session resolves the chat a call belongs to. A session token names it; a
// shared harness instance token is attributed to the one chat whose stream
// shows this exact call running, and refused when none or several do.
func (s *chatToolService) session(ctx context.Context, token, tool string, arguments json.RawMessage) (string, string) {
scope, found, err := s.tokens.ChatToolScope(ctx, token)
if err != nil || !found {
return "", "This Pipelines endpoint is not recognised."
}
if id, ok := strings.CutPrefix(scope, chatToolSessionScope); ok && id != "" {
return id, ""
}
if _, ok := strings.CutPrefix(scope, chatToolInstanceScope); ok && s.hub != nil {
id, ambiguous := s.hub.awaitToolCallSession(ctx, tool, arguments, chatToolCorrelationWait)
if ambiguous {
return "", "Pipelines could not tell which chat made this call (another chat made an identical one); retry with a different title."
}
if id == "" {
return "", "Pipelines could not match this call to a chat it is showing; the tools work only in chats opened through Pipelines."
}
return id, ""
}
return "", "This chat is not ready for Pipelines tools yet."
}
// chatSessionDirectory is the chat's recorded working directory, or "".
func (s *chatToolService) chatSessionDirectory(ctx context.Context, sessionID string) string {
if s.registry == nil {
return ""
}
session, found, err := s.registry.OperatorSession(ctx, sessionID)
if err != nil || !found {
return ""
}
return session.Directory
}
func (s *chatToolService) chatTitle(ctx context.Context, sessionID string) string {
if s.registry == nil {
return ""
}
session, found, err := s.registry.OperatorSession(ctx, sessionID)
if err != nil || !found {
return ""
}
return session.Title
}
func newChatShownID() string {
var b [12]byte
_, _ = rand.Read(b[:])
return "shown_" + hex.EncodeToString(b[:])
}
// chatNotifyLimiter is a per-chat sliding-window rate limit.
type chatNotifyLimiter struct {
mu sync.Mutex
limit int
window time.Duration
sent map[string][]time.Time
}
func newChatNotifyLimiter(limit int, window time.Duration) *chatNotifyLimiter {
return &chatNotifyLimiter{limit: limit, window: window, sent: map[string][]time.Time{}}
}
// allow records one notification for sessionID at now unless the window is
// full.
func (l *chatNotifyLimiter) allow(sessionID string, now time.Time) bool {
l.mu.Lock()
defer l.mu.Unlock()
kept := l.sent[sessionID][:0]
for _, at := range l.sent[sessionID] {
if now.Sub(at) < l.window {
kept = append(kept, at)
}
}
if len(kept) >= l.limit {
l.sent[sessionID] = kept
return false
}
l.sent[sessionID] = append(kept, now)
return true
}
// shownFrame is a chat's retained shown items for its subscribe reply, or nil
// when it has none (or none are recorded on this server).
func (h *chatHub) shownFrame(sessionID string) *protocol.ChatShownFrame {
if h == nil || h.shown == nil {
return nil
}
ctx, cancel := context.WithTimeout(h.baseCtx, 5*time.Second)
defer cancel()
items, err := h.shown.ChatShownItems(ctx, sessionID)
if err != nil {
log.Printf("chat shown items session=%s: %v", sessionID, err)
return nil
}
if len(items) == 0 {
return nil
}
return &protocol.ChatShownFrame{SessionID: sessionID, Items: items}
}