Andy Dixon
777e8f50b5
Phase 8, completing milestone M1. A user message is stored and appended as an observation event carrying trust, actor, channel and reference. The perceive process analyses it deterministically (intent, introspection kind, entities, claims, urgency) and, within the per-cycle model allowance, enriches it through the perceive prompt. Its handler writes a perception event, an episodic memory with participants, turns claims into beliefs whose evidence is the message, and builds a response intent from state: beliefs and memories for the topic, evidence rows for why-questions, the uncertain band, contested beliefs and their links, recent learning, status changes, and honest declines for subsystems that do not exist yet or for requests with no capabilities. The respond prompt phrases the intent when a model is assigned; otherwise the reply is a direct rendering of the intent. response_generated cites the message, the perception, every belief and memory used, the episode and the model call. API: conversations, messages with optional wait, one-shot ask; chat UI with live refresh and a per-reply intent view. Sample mind Dani as a strictly decoded seed document with an import endpoint and noemactl mind import. tests/m1 drives all fourteen milestone steps including restart.
255 lines
7.4 KiB
Go
255 lines
7.4 KiB
Go
package api
|
|
|
|
import (
|
|
"errors"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/andydixon/noema/internal/auth"
|
|
"github.com/andydixon/noema/internal/conversation"
|
|
"github.com/andydixon/noema/internal/storage"
|
|
"github.com/andydixon/noema/pkg/events"
|
|
"github.com/andydixon/noema/pkg/ids"
|
|
)
|
|
|
|
func (s *Server) conversationRoutes() {
|
|
m := s.mux
|
|
m.Handle("GET /api/v1/minds/{mind}/conversations", require(auth.RoleObserver, s.conversationsList))
|
|
m.Handle("POST /api/v1/minds/{mind}/conversations", require(auth.RoleOperator, s.conversationsCreate))
|
|
m.Handle("GET /api/v1/minds/{mind}/conversations/{id}", require(auth.RoleObserver, s.conversationGet))
|
|
m.Handle("POST /api/v1/minds/{mind}/conversations/{id}/messages", require(auth.RoleOperator, s.messagePost))
|
|
m.Handle("POST /api/v1/minds/{mind}/ask", require(auth.RoleOperator, s.ask))
|
|
}
|
|
|
|
func convErr(err error) error {
|
|
if errors.Is(err, conversation.ErrInvalid) {
|
|
return ValidationError(err.Error())
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (s *Server) conversationsList(w http.ResponseWriter, r *http.Request) {
|
|
m, ok := s.mind(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
list, err := s.deps.Conversations.List(r.Context(), m.ID, 100)
|
|
if err != nil {
|
|
fail(w, r, err)
|
|
return
|
|
}
|
|
if list == nil {
|
|
list = []conversation.Conversation{}
|
|
}
|
|
writeJSON(w, http.StatusOK, page[conversation.Conversation]{Items: list})
|
|
}
|
|
|
|
type conversationIn struct {
|
|
Title string `json:"title"`
|
|
Channel string `json:"channel"`
|
|
Person string `json:"person"`
|
|
Project string `json:"project"`
|
|
}
|
|
|
|
func (s *Server) conversationsCreate(w http.ResponseWriter, r *http.Request) {
|
|
m, ok := s.mind(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
var in conversationIn
|
|
if r.ContentLength != 0 {
|
|
if err := decode(r, &in); err != nil {
|
|
fail(w, r, err)
|
|
return
|
|
}
|
|
}
|
|
if in.Person == "" {
|
|
in.Person = actor(r)
|
|
}
|
|
c, err := s.deps.Conversations.Create(r.Context(), m.ID, in.Title, firstNonEmpty(in.Channel, "api"), in.Person, in.Project)
|
|
if err != nil {
|
|
fail(w, r, err)
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusCreated, c)
|
|
}
|
|
|
|
// ConversationView is a conversation with its messages.
|
|
type ConversationView struct {
|
|
Conversation conversation.Conversation `json:"conversation"`
|
|
Messages []conversation.Message `json:"messages"`
|
|
}
|
|
|
|
func (s *Server) conversationGet(w http.ResponseWriter, r *http.Request) {
|
|
m, ok := s.mind(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
id, err := ids.Parse(r.PathValue("id"))
|
|
if err != nil {
|
|
fail(w, r, ValidationError("bad id"))
|
|
return
|
|
}
|
|
c, err := s.deps.Conversations.Get(r.Context(), m.ID, id)
|
|
if err != nil {
|
|
fail(w, r, err)
|
|
return
|
|
}
|
|
msgs, _ := s.deps.Conversations.Messages(r.Context(), m.ID, id, 200)
|
|
if msgs == nil {
|
|
msgs = []conversation.Message{}
|
|
}
|
|
writeJSON(w, http.StatusOK, ConversationView{Conversation: c, Messages: msgs})
|
|
}
|
|
|
|
// PostMessage records a user message as an observation event so the cognitive
|
|
// cycle perceives it. Shared with the UI. It returns the stored message.
|
|
func (s *Server) PostMessage(r *http.Request, mindID ids.ID, conv conversation.Conversation, text, who string) (conversation.Message, error) {
|
|
text = strings.TrimSpace(text)
|
|
if text == "" || len(text) > 20000 {
|
|
return conversation.Message{}, ValidationError("message required (max 20000 chars)")
|
|
}
|
|
trust := events.TrustUser
|
|
if p, ok := auth.PrincipalFrom(r.Context()); ok && p.User.Role.AtLeast(auth.RoleAdministrator) {
|
|
trust = events.TrustOperator
|
|
}
|
|
msg, err := s.deps.Conversations.AddMessage(r.Context(), s.deps.DB, conversation.Message{ConversationID: conv.ID, MindID: mindID, Role: "user", Actor: who, Content: text})
|
|
if err != nil {
|
|
return conversation.Message{}, convErr(err)
|
|
}
|
|
summary := text
|
|
if len(summary) > 160 {
|
|
summary = summary[:157] + "..."
|
|
}
|
|
evs, err := s.deps.Events.Append(r.Context(), events.New{MindID: mindID, Type: events.Observation, Source: "conversation", Summary: who + ": " + summary, Salience: 0.8, Confidence: 1,
|
|
Metadata: map[string]any{"conversation_id": string(conv.ID), "message_id": string(msg.ID), "trust": trust, "actor": who, "channel": conv.Channel, "person": conv.Person, "project": conv.Project},
|
|
Payload: events.ObservationPayload{Text: text, ContentType: "text/plain", Source: "conversation", Trust: trust, Method: "chat", Reference: string(msg.ID), Channel: string(conv.ID), Actor: who}})
|
|
if err != nil {
|
|
return msg, err
|
|
}
|
|
s.deps.Conversations.SetEventID(r.Context(), s.deps.DB, msg.ID, evs[0].ID) //nolint:errcheck
|
|
msg.EventID = evs[0].ID
|
|
return msg, nil
|
|
}
|
|
|
|
// WaitReply polls for the mind's reply to a message for up to d.
|
|
func (s *Server) WaitReply(r *http.Request, mindID, msgID ids.ID, d time.Duration) (conversation.Message, bool) {
|
|
deadline := time.Now().Add(d)
|
|
for {
|
|
if reply, err := s.deps.Conversations.Reply(r.Context(), mindID, msgID); err == nil {
|
|
return reply, true
|
|
} else if !errors.Is(err, storage.ErrNotFound) {
|
|
return conversation.Message{}, false
|
|
}
|
|
if time.Now().After(deadline) || r.Context().Err() != nil {
|
|
return conversation.Message{}, false
|
|
}
|
|
select {
|
|
case <-time.After(250 * time.Millisecond):
|
|
case <-r.Context().Done():
|
|
return conversation.Message{}, false
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Server) messagePost(w http.ResponseWriter, r *http.Request) {
|
|
m, ok := s.mind(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
id, err := ids.Parse(r.PathValue("id"))
|
|
if err != nil {
|
|
fail(w, r, ValidationError("bad id"))
|
|
return
|
|
}
|
|
conv, err := s.deps.Conversations.Get(r.Context(), m.ID, id)
|
|
if err != nil {
|
|
fail(w, r, err)
|
|
return
|
|
}
|
|
var in struct {
|
|
Text string `json:"text"`
|
|
Wait int `json:"wait_seconds"`
|
|
}
|
|
if err := decode(r, &in); err != nil {
|
|
fail(w, r, err)
|
|
return
|
|
}
|
|
msg, err := s.PostMessage(r, m.ID, conv, in.Text, actor(r))
|
|
if err != nil {
|
|
fail(w, r, err)
|
|
return
|
|
}
|
|
out := map[string]any{"message": msg}
|
|
if in.Wait > 0 {
|
|
if in.Wait > 120 {
|
|
in.Wait = 120
|
|
}
|
|
if reply, ok := s.WaitReply(r, m.ID, msg.ID, time.Duration(in.Wait)*time.Second); ok {
|
|
out["reply"] = reply
|
|
} else {
|
|
out["reply"] = nil
|
|
out["note"] = "no reply within the wait window; the mind may be paused, busy or over budget"
|
|
}
|
|
}
|
|
writeJSON(w, http.StatusCreated, out)
|
|
}
|
|
|
|
// ask is the one-shot conversational endpoint used by noemactl ask: it posts
|
|
// into (or creates) the caller's CLI conversation and waits for the reply.
|
|
func (s *Server) ask(w http.ResponseWriter, r *http.Request) {
|
|
m, ok := s.mind(w, r)
|
|
if !ok {
|
|
return
|
|
}
|
|
var in struct {
|
|
Text string `json:"text"`
|
|
ConversationID ids.ID `json:"conversation_id"`
|
|
Wait int `json:"wait_seconds"`
|
|
}
|
|
if err := decode(r, &in); err != nil {
|
|
fail(w, r, err)
|
|
return
|
|
}
|
|
var conv conversation.Conversation
|
|
var err error
|
|
if !in.ConversationID.IsZero() {
|
|
conv, err = s.deps.Conversations.Get(r.Context(), m.ID, in.ConversationID)
|
|
} else {
|
|
list, _ := s.deps.Conversations.List(r.Context(), m.ID, 50)
|
|
for _, c := range list {
|
|
if c.Channel == "cli" && c.Person == actor(r) {
|
|
conv = c
|
|
break
|
|
}
|
|
}
|
|
if conv.ID.IsZero() {
|
|
conv, err = s.deps.Conversations.Create(r.Context(), m.ID, "", "cli", actor(r), "")
|
|
}
|
|
}
|
|
if err != nil {
|
|
fail(w, r, err)
|
|
return
|
|
}
|
|
msg, err := s.PostMessage(r, m.ID, conv, in.Text, actor(r))
|
|
if err != nil {
|
|
fail(w, r, err)
|
|
return
|
|
}
|
|
if in.Wait <= 0 {
|
|
in.Wait = 30
|
|
}
|
|
if in.Wait > 120 {
|
|
in.Wait = 120
|
|
}
|
|
out := map[string]any{"conversation_id": conv.ID, "message": msg}
|
|
if reply, ok := s.WaitReply(r, m.ID, msg.ID, time.Duration(in.Wait)*time.Second); ok {
|
|
out["reply"] = reply
|
|
} else {
|
|
out["note"] = "no reply within " + strconv.Itoa(in.Wait) + "s"
|
|
}
|
|
writeJSON(w, http.StatusOK, out)
|
|
}
|