feat(gateway): chat memory write path (unification slice 4) (#888)
Build a per-turn memory tool set (memory_create/update/delete/list) onto the turn's resolved Subject, matching slice 3's read-side scope model. The model picks a scope KIND from an enum built off Subject.WritableScopes() (never global); the agent and user ids a scope resolves to come from the turn's Subject, with no schema field either could ever land in. A subject with no writable scope, or a nil write store, gets no memory tools at all. TurnRunnerConfig gains MemoryWriter (MemoryWriteStore: Create/Update/ Forget/List), wired alongside the existing MemoryEngine read surface through the same active engine (boot.activeMemoryEngine, narrowed by memoryStore/memoryWriter).
This commit is contained in:
1 parent
c6b4fe237f
commit
5d04bea3d4
6 files changed
+667
-10
No files matched your search
@@ -690,6 +690,7 @@ func (b *boot) setupGateways(ctx context.Context, cfgPath, overlayPath string) b
|
||||
ChannelManager: b.channelManager, AgentStatus: b.agentStatus,
|
||||
RateLimiter: b.rateLimiter,
|
||||
MemoryEngine: b.memoryStore(),
|
||||
MemoryWriter: b.memoryWriter(),
|
||||
})
|
||||
if !ok {
|
||||
return false
|
||||
@@ -1157,21 +1158,40 @@ func (b *boot) setupMemoryAll() error {
|
||||
return b.setupMemoryEngine()
|
||||
}
|
||||
|
||||
// memoryStore resolves the active memory engine (the same one
|
||||
// setupMemoryEngine registered under cfg.Memory.Engine) as the narrow read
|
||||
// surface a chat turn runner needs. Nil when the registry was never set up
|
||||
// or the configured engine is not registered -- both cases the turn runner
|
||||
// already treats as "no memory block" (gateway.renderMemory), so a chat
|
||||
// turn degrades instead of failing.
|
||||
func (b *boot) memoryStore() gateway.MemoryStore {
|
||||
// activeMemoryEngine resolves the engine setupMemoryEngine registered under
|
||||
// cfg.Memory.Engine. Both memoryStore and memoryWriter narrow this same
|
||||
// engine to the read or write surface their caller needs; ok is false when
|
||||
// the registry was never set up or the configured engine is not registered.
|
||||
func (b *boot) activeMemoryEngine() (domainmemory.MemoryEngine, bool) {
|
||||
if b.memEngines == nil {
|
||||
return nil
|
||||
return nil, false
|
||||
}
|
||||
name := b.cfg.Memory.Engine
|
||||
if name == "" {
|
||||
name = infraMemory.EngineName
|
||||
}
|
||||
engine, ok := b.memEngines.Get(name)
|
||||
return b.memEngines.Get(name)
|
||||
}
|
||||
|
||||
// memoryStore resolves the active memory engine as the narrow read surface
|
||||
// a chat turn runner needs. Nil when activeMemoryEngine has none -- the
|
||||
// turn runner already treats that as "no memory block"
|
||||
// (gateway.renderMemory), so a chat turn degrades instead of failing.
|
||||
func (b *boot) memoryStore() gateway.MemoryStore {
|
||||
engine, ok := b.activeMemoryEngine()
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return engine
|
||||
}
|
||||
|
||||
// memoryWriter resolves the active memory engine as the narrow write
|
||||
// surface the per-turn memory tool needs (docs/prds/
|
||||
// memory-engine-unification.md §5). Nil when activeMemoryEngine has none --
|
||||
// MemoryTools already treats that as "no memory tools", so a chat turn
|
||||
// simply has no memory_create/update/delete/list tools rather than failing.
|
||||
func (b *boot) memoryWriter() gateway.MemoryWriteStore {
|
||||
engine, ok := b.activeMemoryEngine()
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -68,6 +68,7 @@ func (b *boot) setupGatewayChat(ctx context.Context, actor gateway.ChatTaskActor
|
||||
DefaultChatIdentity: b.defaultChatIdentity, SessionStore: b.chatSessionStore,
|
||||
Bus: b.bus, Log: b.log, Secrets: b.secrets,
|
||||
MemoryEngine: b.memoryStore(),
|
||||
MemoryWriter: b.memoryWriter(),
|
||||
}
|
||||
router.LLM, router.LLMStream = makeChatLLMResponder(ctx, "web", setup, b.chatSessionStore, router)
|
||||
router.Titles = newChatTitleGenerator(setup)
|
||||
|
||||
@@ -72,6 +72,10 @@ type telegramSetup struct {
|
||||
// engine, resolved by cfg.Memory.Engine). Nil disables the chat <memory>
|
||||
// block for every turn runner built from this setup.
|
||||
MemoryEngine gateway.MemoryStore
|
||||
// MemoryWriter is the same active engine's write surface, used to build
|
||||
// the per-turn memory_create/update/delete/list tools (docs/prds/
|
||||
// memory-engine-unification.md §5). Nil omits those tools.
|
||||
MemoryWriter gateway.MemoryWriteStore
|
||||
}
|
||||
|
||||
// telegramValidateConfigMap builds the map Gateway.ValidateConfig expects
|
||||
@@ -360,6 +364,7 @@ func newChatTurnRunner(
|
||||
Workspace: cfg.Chat.Workspace,
|
||||
Repos: chatRepoEnv(cfg, s.DefaultChatIdentity),
|
||||
MemoryEngine: s.MemoryEngine,
|
||||
MemoryWriter: s.MemoryWriter,
|
||||
UserIdentity: userIdentityResolver(channel),
|
||||
Log: s.Log,
|
||||
})
|
||||
|
||||
@@ -104,6 +104,11 @@ type TurnRunnerConfig struct {
|
||||
// in prepareTurn. Nil disables the <memory> block entirely (renderMemory
|
||||
// treats a nil store the same as a failed read).
|
||||
MemoryEngine MemoryStore
|
||||
// MemoryWriter is the write surface the per-turn memory tool (slice 4)
|
||||
// uses to build memory_create/memory_update/memory_delete/memory_list.
|
||||
// Nil omits those tools entirely (MemoryTools treats a nil store the
|
||||
// same as a subject with no writable scope: no tools registered).
|
||||
MemoryWriter MemoryWriteStore
|
||||
// UserIdentity resolves the initiating user's identity for one inbound
|
||||
// message, per channel. False (or a nil UserIdentity) means the channel
|
||||
// carries no per-person identity -- the dashboard's one bearer token, or a
|
||||
@@ -298,6 +303,7 @@ type preparedTurn struct {
|
||||
// for one turn's generation call.
|
||||
func (r *TurnRunner) prepareTurn(ctx context.Context, sessionID string, in Inbound, history []messaging.Message) (preparedTurn, error) {
|
||||
compressed := compressTurnHistory(history)
|
||||
subject := r.resolveSubject(in.Message)
|
||||
extraTools := append(
|
||||
TaskTools(r.TaskLister, r.Tasks, r.TaskLogs, r.TaskActor, r.TaskIdentity),
|
||||
SessionTools(r.Sessions, r.Router.SessionTracker(), r.Channel, in.Message)...,
|
||||
@@ -306,6 +312,7 @@ func (r *TurnRunner) prepareTurn(ctx context.Context, sessionID string, in Inbou
|
||||
// The dashboard tools (page_index, dashboard_navigate) belong to the web
|
||||
// UI only: a non-web channel has no dashboard to point at.
|
||||
extraTools = append(extraTools, PageIndexTools(r.Channel)...)
|
||||
extraTools = append(extraTools, MemoryTools(r.MemoryWriter, subject)...)
|
||||
modelName := r.Models.ActiveModel()
|
||||
modelDetails := ModelDetails{}
|
||||
if detailed, ok := r.Models.(DetailedModelManager); ok {
|
||||
@@ -326,7 +333,7 @@ func (r *TurnRunner) prepareTurn(ctx context.Context, sessionID string, in Inbou
|
||||
if r.Personas != nil {
|
||||
persona = r.Personas.GetActive(sessionID)
|
||||
}
|
||||
memoryBlock := renderMemory(ctx, r.MemoryEngine, r.resolveSubject(in.Message), r.Log)
|
||||
memoryBlock := renderMemory(ctx, r.MemoryEngine, subject, r.Log)
|
||||
systemPrompt := BuildSystemPrompt(SystemPromptConfig{
|
||||
Persona: persona,
|
||||
Tools: prepared.ToolSummaries(),
|
||||
|
||||
@@ -0,0 +1,260 @@
|
||||
package gateway
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
domainmemory "github.com/samcharles93/archie-core/internal/domain/memory"
|
||||
"github.com/samcharles93/archie-core/internal/tools"
|
||||
)
|
||||
|
||||
// MemoryWriteStore is the write surface the per-turn memory tool needs:
|
||||
// Create/Update/Forget/List, the four operations docs/prds/
|
||||
// memory-engine-unification.md §5 maps the tool's create/update/delete/list
|
||||
// actions onto. Narrowed from domainmemory.Store (which also carries Get,
|
||||
// Query and Revisions) so this package's write path cannot accidentally
|
||||
// reach for read operations the tool does not expose.
|
||||
type MemoryWriteStore interface {
|
||||
Create(ctx context.Context, in domainmemory.NewRecord) (domainmemory.Record, error)
|
||||
Update(ctx context.Context, in domainmemory.RecordUpdate) (domainmemory.Record, error)
|
||||
Forget(ctx context.Context, scope domainmemory.Scope, id domainmemory.RecordID) error
|
||||
List(ctx context.Context, scope domainmemory.Scope) ([]domainmemory.Record, error)
|
||||
}
|
||||
|
||||
// memoryToolAuthor and memoryToolSource are the provenance the memory tool
|
||||
// stamps on every record it writes, matching NewRecord/RecordUpdate's
|
||||
// "free text, the engine retains it, it does not interpret it" contract.
|
||||
const (
|
||||
memoryToolAuthor = "chat"
|
||||
memoryToolSource = "memory tool"
|
||||
)
|
||||
|
||||
// MemoryRecordSummary is the per-record view the memory tool returns to the
|
||||
// model: enough to act on (id, scope, content, revision) without exposing
|
||||
// engine-internal fields.
|
||||
type MemoryRecordSummary struct {
|
||||
ID string `json:"id"`
|
||||
Scope string `json:"scope"`
|
||||
Kind string `json:"kind"`
|
||||
Content string `json:"content"`
|
||||
Revision int `json:"revision"`
|
||||
}
|
||||
|
||||
func recordSummary(r domainmemory.Record) MemoryRecordSummary {
|
||||
return MemoryRecordSummary{
|
||||
ID: string(r.ID), Scope: string(r.Scope.Kind), Kind: r.Kind,
|
||||
Content: r.Content, Revision: r.Revision,
|
||||
}
|
||||
}
|
||||
|
||||
// MemoryTools builds the chat tools that let the model manage its own
|
||||
// durable memory, scoped to one turn's resolved Subject
|
||||
// (docs/prds/memory-engine-unification.md §5).
|
||||
//
|
||||
// Built per turn, not registered once at boot, because the writable scope
|
||||
// set is a function of the turn's Subject: two different users talking to
|
||||
// the same agent get two different sets of tools, each only able to
|
||||
// address that user's own scopes.
|
||||
//
|
||||
// The model chooses the scope KIND (an enum built from
|
||||
// subject.WritableScopes(), which never includes global); it never chooses
|
||||
// the agent or user id a scope resolves to -- there is no schema field for
|
||||
// either, so even a model that tries to emit another user's id has nowhere
|
||||
// to write it. A nil store, or a subject with no writable scope at all
|
||||
// (no resolvable agent and no resolvable user), omits every tool rather
|
||||
// than registering ones that always fail.
|
||||
func MemoryTools(store MemoryWriteStore, subject domainmemory.Subject) []tools.ToolEntry {
|
||||
if store == nil {
|
||||
return nil
|
||||
}
|
||||
writable := subject.WritableScopes()
|
||||
if len(writable) == 0 {
|
||||
return nil
|
||||
}
|
||||
kinds := make([]string, 0, len(writable))
|
||||
for _, s := range writable {
|
||||
kinds = append(kinds, string(s.Kind))
|
||||
}
|
||||
resolve := func(kind string) (domainmemory.Scope, error) {
|
||||
for _, s := range writable {
|
||||
if string(s.Kind) == kind {
|
||||
return s, nil
|
||||
}
|
||||
}
|
||||
return domainmemory.Scope{}, fmt.Errorf("memory: scope %q is not writable for this conversation (available: %s)",
|
||||
kind, strings.Join(kinds, ", "))
|
||||
}
|
||||
return []tools.ToolEntry{
|
||||
memoryCreateTool(store, resolve, kinds),
|
||||
memoryUpdateTool(store, resolve, kinds),
|
||||
memoryDeleteTool(store, resolve, kinds),
|
||||
memoryListTool(store, resolve, kinds),
|
||||
}
|
||||
}
|
||||
|
||||
// memoryScopeSchemaProperty is the schema fragment every memory tool shares
|
||||
// for its scope argument: an enum of the kinds this turn's subject may
|
||||
// write to. It carries no agent or user field -- resolve (built from the
|
||||
// turn's Subject) supplies those, never the model.
|
||||
func memoryScopeSchemaProperty(kinds []string) map[string]any {
|
||||
enum := make([]any, len(kinds))
|
||||
for i, k := range kinds {
|
||||
enum[i] = k
|
||||
}
|
||||
return map[string]any{
|
||||
"type": "string",
|
||||
"enum": enum,
|
||||
"description": "Which memory scope to use. This names a KIND only -- the agent and user " +
|
||||
"this scope belongs to are resolved from the current conversation, never from this call.",
|
||||
}
|
||||
}
|
||||
|
||||
func memoryCreateTool(store MemoryWriteStore, resolve func(string) (domainmemory.Scope, error), kinds []string) tools.ToolEntry {
|
||||
return tools.ToolEntry{
|
||||
Name: "memory_create",
|
||||
Toolset: "memory",
|
||||
Description: "Save a new durable memory record. Use this to remember a fact, preference, " +
|
||||
"or piece of context that should persist across conversations.",
|
||||
Classification: tools.ClassMutating,
|
||||
Schema: tools.JSONSchema{
|
||||
"type": "object",
|
||||
"properties": map[string]any{
|
||||
"scope": memoryScopeSchemaProperty(kinds),
|
||||
"content": map[string]any{"type": "string", "description": "The memory to record."},
|
||||
"kind": map[string]any{
|
||||
"type": "string",
|
||||
"description": "Free-text category for the record (e.g. \"note\", \"preference\"). Defaults to \"note\".",
|
||||
},
|
||||
},
|
||||
"required": []any{"scope", "content"},
|
||||
},
|
||||
Handler: func(ctx context.Context, input map[string]any) (any, error) {
|
||||
scope, err := resolve(asString(input["scope"]))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
content := strings.TrimSpace(asString(input["content"]))
|
||||
if content == "" {
|
||||
return nil, fmt.Errorf("memory_create: content is required")
|
||||
}
|
||||
kind := strings.TrimSpace(asString(input["kind"]))
|
||||
if kind == "" {
|
||||
kind = "note"
|
||||
}
|
||||
rec, err := store.Create(ctx, domainmemory.NewRecord{
|
||||
Scope: scope, Kind: kind, Content: content,
|
||||
Author: memoryToolAuthor, OriginUser: scope.User, Source: memoryToolSource,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("memory_create: %w", err)
|
||||
}
|
||||
return recordSummary(rec), nil
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func memoryUpdateTool(store MemoryWriteStore, resolve func(string) (domainmemory.Scope, error), kinds []string) tools.ToolEntry {
|
||||
return tools.ToolEntry{
|
||||
Name: "memory_update",
|
||||
Toolset: "memory",
|
||||
Description: "Replace the content of an existing memory record, addressed by the id shown " +
|
||||
"in the <memory> block. The prior content remains available as a revision.",
|
||||
Classification: tools.ClassMutating,
|
||||
Schema: tools.JSONSchema{
|
||||
"type": "object",
|
||||
"properties": map[string]any{
|
||||
"scope": memoryScopeSchemaProperty(kinds),
|
||||
"id": map[string]any{"type": "string", "description": "The record id from the <memory> block."},
|
||||
"content": map[string]any{"type": "string", "description": "The new content, replacing the old."},
|
||||
},
|
||||
"required": []any{"scope", "id", "content"},
|
||||
},
|
||||
Handler: func(ctx context.Context, input map[string]any) (any, error) {
|
||||
scope, err := resolve(asString(input["scope"]))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
id := strings.TrimSpace(asString(input["id"]))
|
||||
if id == "" {
|
||||
return nil, fmt.Errorf("memory_update: id is required")
|
||||
}
|
||||
content := strings.TrimSpace(asString(input["content"]))
|
||||
if content == "" {
|
||||
return nil, fmt.Errorf("memory_update: content is required")
|
||||
}
|
||||
rec, err := store.Update(ctx, domainmemory.RecordUpdate{
|
||||
Scope: scope, ID: domainmemory.RecordID(id), Content: content,
|
||||
Author: memoryToolAuthor, Source: memoryToolSource,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("memory_update: %w", err)
|
||||
}
|
||||
return recordSummary(rec), nil
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func memoryDeleteTool(store MemoryWriteStore, resolve func(string) (domainmemory.Scope, error), kinds []string) tools.ToolEntry {
|
||||
return tools.ToolEntry{
|
||||
Name: "memory_delete",
|
||||
Toolset: "memory",
|
||||
Description: "Forget a memory record, addressed by the id shown in the <memory> block. " +
|
||||
"Its content is removed from future prompts; its provenance is retained as a revision.",
|
||||
Classification: tools.ClassMutating,
|
||||
Schema: tools.JSONSchema{
|
||||
"type": "object",
|
||||
"properties": map[string]any{
|
||||
"scope": memoryScopeSchemaProperty(kinds),
|
||||
"id": map[string]any{"type": "string", "description": "The record id from the <memory> block."},
|
||||
},
|
||||
"required": []any{"scope", "id"},
|
||||
},
|
||||
Handler: func(ctx context.Context, input map[string]any) (any, error) {
|
||||
scope, err := resolve(asString(input["scope"]))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
id := strings.TrimSpace(asString(input["id"]))
|
||||
if id == "" {
|
||||
return nil, fmt.Errorf("memory_delete: id is required")
|
||||
}
|
||||
if err := store.Forget(ctx, scope, domainmemory.RecordID(id)); err != nil {
|
||||
return nil, fmt.Errorf("memory_delete: %w", err)
|
||||
}
|
||||
return map[string]any{"id": id, "scope": string(scope.Kind), "message": "forgotten"}, nil
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func memoryListTool(store MemoryWriteStore, resolve func(string) (domainmemory.Scope, error), kinds []string) tools.ToolEntry {
|
||||
return tools.ToolEntry{
|
||||
Name: "memory_list",
|
||||
Toolset: "memory",
|
||||
Description: "List the live memory records in one writable scope. Use this to find a " +
|
||||
"record's id before calling memory_update or memory_delete.",
|
||||
Classification: tools.ClassIdempotent,
|
||||
Schema: tools.JSONSchema{
|
||||
"type": "object",
|
||||
"properties": map[string]any{
|
||||
"scope": memoryScopeSchemaProperty(kinds),
|
||||
},
|
||||
"required": []any{"scope"},
|
||||
},
|
||||
Handler: func(ctx context.Context, input map[string]any) (any, error) {
|
||||
scope, err := resolve(asString(input["scope"]))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
records, err := store.List(ctx, scope)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("memory_list: %w", err)
|
||||
}
|
||||
summaries := make([]MemoryRecordSummary, 0, len(records))
|
||||
for _, r := range records {
|
||||
summaries = append(summaries, recordSummary(r))
|
||||
}
|
||||
return map[string]any{"records": summaries}, nil
|
||||
},
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,364 @@
|
||||
package gateway
|
||||
|
||||
import (
|
||||
"context"
|
||||
"log/slog"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
domainmemory "github.com/samcharles93/archie-core/internal/domain/memory"
|
||||
infraMemory "github.com/samcharles93/archie-core/internal/infrastructure/memory"
|
||||
"github.com/samcharles93/archie-core/internal/tools"
|
||||
)
|
||||
|
||||
// findTool returns the named entry from a tool slice, failing the test if
|
||||
// it is missing.
|
||||
func findTool(t *testing.T, entries []tools.ToolEntry, name string) tools.ToolEntry {
|
||||
t.Helper()
|
||||
for _, e := range entries {
|
||||
if e.Name == name {
|
||||
return e
|
||||
}
|
||||
}
|
||||
t.Fatalf("tool %q not found among %d entries", name, len(entries))
|
||||
return tools.ToolEntry{}
|
||||
}
|
||||
|
||||
// schemaEnum extracts the "enum" list of a scope property as a string set.
|
||||
func schemaEnum(t *testing.T, entry tools.ToolEntry) []string {
|
||||
t.Helper()
|
||||
props, ok := entry.Schema["properties"].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("tool %q schema has no properties", entry.Name)
|
||||
}
|
||||
scope, ok := props["scope"].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("tool %q schema has no scope property", entry.Name)
|
||||
}
|
||||
enum, ok := scope["enum"].([]any)
|
||||
if !ok {
|
||||
t.Fatalf("tool %q scope property has no enum", entry.Name)
|
||||
}
|
||||
out := make([]string, len(enum))
|
||||
for i, v := range enum {
|
||||
s, ok := v.(string)
|
||||
if !ok {
|
||||
t.Fatalf("enum entry %v is not a string", v)
|
||||
}
|
||||
out[i] = s
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// asRecordSummary checks and unwraps a tool handler's MemoryRecordSummary
|
||||
// output, failing the test on any unexpected shape.
|
||||
func asRecordSummary(t *testing.T, out any) MemoryRecordSummary {
|
||||
t.Helper()
|
||||
rec, ok := out.(MemoryRecordSummary)
|
||||
if !ok {
|
||||
t.Fatalf("output type = %T, want MemoryRecordSummary", out)
|
||||
}
|
||||
return rec
|
||||
}
|
||||
|
||||
// listRecords checks and unwraps memory_list's output shape, failing the
|
||||
// test on any unexpected shape.
|
||||
func listRecords(t *testing.T, out any) []MemoryRecordSummary {
|
||||
t.Helper()
|
||||
result, ok := out.(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("memory_list output type = %T, want map[string]any", out)
|
||||
}
|
||||
records, ok := result["records"].([]MemoryRecordSummary)
|
||||
if !ok {
|
||||
t.Fatalf("memory_list \"records\" type = %T, want []MemoryRecordSummary", result["records"])
|
||||
}
|
||||
return records
|
||||
}
|
||||
|
||||
// TestMemoryToolsNilStoreOmitsEverything guards the composition case where
|
||||
// no memory engine is registered: a nil store must not panic MemoryTools
|
||||
// and must offer nothing, matching the read path's degrade-to-nothing
|
||||
// contract.
|
||||
func TestMemoryToolsNilStoreOmitsEverything(t *testing.T) {
|
||||
got := MemoryTools(nil, domainmemory.Subject{AgentID: "archie", UserID: "alice"})
|
||||
if got != nil {
|
||||
t.Fatalf("MemoryTools(nil store) = %d tools, want none", len(got))
|
||||
}
|
||||
}
|
||||
|
||||
// TestMemoryToolsNoWritableScopeOmitsEverything is the structural half of
|
||||
// acceptance criterion 7: a subject with no agent and no user id (nothing
|
||||
// writable) gets no memory tools at all, not tools that always error.
|
||||
func TestMemoryToolsNoWritableScopeOmitsEverything(t *testing.T) {
|
||||
engine := infraMemory.NewBuiltinEngine(t.TempDir(), 0)
|
||||
got := MemoryTools(engine, domainmemory.Subject{})
|
||||
if got != nil {
|
||||
t.Fatalf("MemoryTools(no writable scope) = %d tools, want none", len(got))
|
||||
}
|
||||
}
|
||||
|
||||
// TestMemoryToolsScopeEnumNeverIncludesGlobal is acceptance criterion 9's
|
||||
// global half: global is never model-writable, so it must never appear in
|
||||
// any memory tool's scope enum, regardless of subject.
|
||||
func TestMemoryToolsScopeEnumNeverIncludesGlobal(t *testing.T) {
|
||||
engine := infraMemory.NewBuiltinEngine(t.TempDir(), 0)
|
||||
entries := MemoryTools(engine, domainmemory.Subject{AgentID: "archie", UserID: "alice"})
|
||||
for _, e := range entries {
|
||||
for _, kind := range schemaEnum(t, e) {
|
||||
if kind == string(domainmemory.ScopeGlobal) {
|
||||
t.Fatalf("tool %q offers global in its scope enum", e.Name)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestMemoryToolsScopeEnumMatchesWritableScopes: with no resolvable user
|
||||
// (agent scope only), the tools must offer exactly "agent", never "user" or
|
||||
// "agent-user" -- the structural form of fail-closed.
|
||||
func TestMemoryToolsScopeEnumMatchesWritableScopes(t *testing.T) {
|
||||
engine := infraMemory.NewBuiltinEngine(t.TempDir(), 0)
|
||||
entries := MemoryTools(engine, domainmemory.Subject{AgentID: "archie"})
|
||||
create := findTool(t, entries, "memory_create")
|
||||
enum := schemaEnum(t, create)
|
||||
if len(enum) != 1 || enum[0] != string(domainmemory.ScopeAgent) {
|
||||
t.Fatalf("scope enum = %v, want exactly [agent]", enum)
|
||||
}
|
||||
}
|
||||
|
||||
// TestMemoryToolsSchemaHasNoIdentityField is acceptance criterion 9: the
|
||||
// tool schemas structurally carry no field the model could put an agent or
|
||||
// user id into. Only "scope" (a kind enum), "id", "content" and "kind" are
|
||||
// permitted.
|
||||
func TestMemoryToolsSchemaHasNoIdentityField(t *testing.T) {
|
||||
engine := infraMemory.NewBuiltinEngine(t.TempDir(), 0)
|
||||
entries := MemoryTools(engine, domainmemory.Subject{AgentID: "archie", UserID: "alice"})
|
||||
allowed := map[string]bool{"scope": true, "id": true, "content": true, "kind": true}
|
||||
for _, e := range entries {
|
||||
props, ok := e.Schema["properties"].(map[string]any)
|
||||
if !ok {
|
||||
t.Fatalf("tool %q schema has no properties", e.Name)
|
||||
}
|
||||
for k := range props {
|
||||
if !allowed[k] {
|
||||
t.Fatalf("tool %q schema exposes unexpected field %q -- possible identity leak", e.Name, k)
|
||||
}
|
||||
if strings.Contains(strings.ToLower(k), "agent") || strings.Contains(strings.ToLower(k), "user") ||
|
||||
strings.Contains(strings.ToLower(k), "owner") {
|
||||
t.Fatalf("tool %q schema field %q looks like an identity field", e.Name, k)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestMemoryToolsFailClosedOnDisallowedScope is acceptance criterion 7's
|
||||
// tool-layer half: a handler call naming a scope kind the subject cannot
|
||||
// write to (bypassing the schema enum, as a model that ignores the schema
|
||||
// might) is refused with a clear reason, never silently widened.
|
||||
func TestMemoryToolsFailClosedOnDisallowedScope(t *testing.T) {
|
||||
engine := infraMemory.NewBuiltinEngine(t.TempDir(), 0)
|
||||
entries := MemoryTools(engine, domainmemory.Subject{AgentID: "archie"}) // no user id
|
||||
create := findTool(t, entries, "memory_create")
|
||||
|
||||
_, err := create.Handler(context.Background(), map[string]any{
|
||||
"scope": "user", "content": "should never be written",
|
||||
})
|
||||
if err == nil {
|
||||
t.Fatal("memory_create with disallowed scope kind succeeded, want an error")
|
||||
}
|
||||
if !strings.Contains(err.Error(), "not writable") {
|
||||
t.Fatalf("error = %v, want a clear \"not writable\" reason", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestMemoryToolsCreateUpdateDeleteRoundTrip drives the four handlers
|
||||
// directly against a real engine and asserts each engine-level effect:
|
||||
// create is retrievable via list, update supersedes content and is visible
|
||||
// in Revisions with author and time, delete removes it from list while
|
||||
// Revisions retains the deleted state. This is acceptance criterion 5 at
|
||||
// the tool/engine boundary.
|
||||
func TestMemoryToolsCreateUpdateDeleteRoundTrip(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
engine := infraMemory.NewBuiltinEngine(t.TempDir(), 0)
|
||||
subject := domainmemory.Subject{AgentID: "archie", UserID: "alice"}
|
||||
entries := MemoryTools(engine, subject)
|
||||
create := findTool(t, entries, "memory_create")
|
||||
update := findTool(t, entries, "memory_update")
|
||||
del := findTool(t, entries, "memory_delete")
|
||||
list := findTool(t, entries, "memory_list")
|
||||
|
||||
createOut, err := create.Handler(ctx, map[string]any{
|
||||
"scope": "agent-user", "content": "alice prefers dark roast coffee",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("memory_create: %v", err)
|
||||
}
|
||||
created := asRecordSummary(t, createOut)
|
||||
if created.ID == "" {
|
||||
t.Fatal("memory_create returned an empty id")
|
||||
}
|
||||
|
||||
listOut, err := list.Handler(ctx, map[string]any{"scope": "agent-user"})
|
||||
if err != nil {
|
||||
t.Fatalf("memory_list: %v", err)
|
||||
}
|
||||
records := listRecords(t, listOut)
|
||||
if len(records) != 1 || records[0].Content != "alice prefers dark roast coffee" {
|
||||
t.Fatalf("memory_list after create = %+v, want the planted record", records)
|
||||
}
|
||||
|
||||
updateOut, err := update.Handler(ctx, map[string]any{
|
||||
"scope": "agent-user", "id": created.ID, "content": "alice prefers oat milk lattes",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("memory_update: %v", err)
|
||||
}
|
||||
updated := asRecordSummary(t, updateOut)
|
||||
if updated.Content != "alice prefers oat milk lattes" {
|
||||
t.Fatalf("memory_update content = %q, want the new content", updated.Content)
|
||||
}
|
||||
|
||||
scope := domainmemory.Scope{Kind: domainmemory.ScopeAgentUser, Agent: "archie", User: "alice"}
|
||||
revisions, err := engine.Revisions(ctx, scope, domainmemory.RecordID(created.ID))
|
||||
if err != nil {
|
||||
t.Fatalf("Revisions() error = %v", err)
|
||||
}
|
||||
found := false
|
||||
for _, rev := range revisions {
|
||||
if rev.Record.Content == "alice prefers dark roast coffee" {
|
||||
found = true
|
||||
if rev.Record.Author != memoryToolAuthor {
|
||||
t.Fatalf("superseded revision author = %q, want %q", rev.Record.Author, memoryToolAuthor)
|
||||
}
|
||||
if rev.SupersededAt.IsZero() {
|
||||
t.Fatal("superseded revision has a zero SupersededAt")
|
||||
}
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Fatalf("Revisions() = %+v, missing the pre-update content", revisions)
|
||||
}
|
||||
|
||||
if _, err := del.Handler(ctx, map[string]any{"scope": "agent-user", "id": created.ID}); err != nil {
|
||||
t.Fatalf("memory_delete: %v", err)
|
||||
}
|
||||
listOut2, err := list.Handler(ctx, map[string]any{"scope": "agent-user"})
|
||||
if err != nil {
|
||||
t.Fatalf("memory_list after delete: %v", err)
|
||||
}
|
||||
records2 := listRecords(t, listOut2)
|
||||
if len(records2) != 0 {
|
||||
t.Fatalf("memory_list after delete = %+v, want empty", records2)
|
||||
}
|
||||
revisionsAfterDelete, err := engine.Revisions(ctx, scope, domainmemory.RecordID(created.ID))
|
||||
if err != nil {
|
||||
t.Fatalf("Revisions() after delete error = %v", err)
|
||||
}
|
||||
deletedFound := false
|
||||
for _, rev := range revisionsAfterDelete {
|
||||
if rev.Deleted {
|
||||
deletedFound = true
|
||||
}
|
||||
}
|
||||
if !deletedFound {
|
||||
t.Fatal("Revisions() after delete has no deleted marker; provenance was not retained")
|
||||
}
|
||||
}
|
||||
|
||||
// TestTurnMemoryWriteRoundTripVisibleNextTurn drives the round trip through
|
||||
// the actual turn path: prepareTurn builds the memory tools for turn 1, the
|
||||
// test calls memory_create the way a dispatched tool call would, and turn
|
||||
// 2's prompt shows the new record by id. This is acceptance criterion 5 at
|
||||
// the turn boundary, and also confirms the write path inherits the read
|
||||
// path's Subject rather than re-deriving identity a second way.
|
||||
func TestTurnMemoryWriteRoundTripVisibleNextTurn(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
engine := infraMemory.NewBuiltinEngine(t.TempDir(), 0)
|
||||
store := NewSessionStoreMemory()
|
||||
router := NewRouter(nil, nil, "telegram")
|
||||
router.Identity = "archie"
|
||||
router.InitSessions(store)
|
||||
prepared := &turnTestPreparedModel{reply: "ok"}
|
||||
model := &turnTestModel{prepared: prepared}
|
||||
runner := NewTurnRunner(TurnRunnerConfig{
|
||||
Router: router,
|
||||
Sessions: store,
|
||||
Models: &fakeModelManager{models: []string{"test/model"}, activeModel: "test/model"},
|
||||
Personas: NewPersonaRegistry(DefaultPersonas()),
|
||||
Model: model,
|
||||
BotUser: "archie",
|
||||
Channel: "telegram",
|
||||
Log: slog.New(slog.DiscardHandler),
|
||||
MemoryEngine: engine,
|
||||
MemoryWriter: engine,
|
||||
UserIdentity: telegramIdentity,
|
||||
})
|
||||
|
||||
msg := chatMsg("s1", "chat-1", "alice", "remember I like dark roast")
|
||||
if _, err := runner.Run(ctx, msg, nil); err != nil {
|
||||
t.Fatalf("Run() turn 1 error = %v", err)
|
||||
}
|
||||
|
||||
create := findTool(t, model.gotExtra, "memory_create")
|
||||
out, err := create.Handler(ctx, map[string]any{
|
||||
"scope": "agent-user", "content": "alice prefers dark roast coffee",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("memory_create: %v", err)
|
||||
}
|
||||
created := asRecordSummary(t, out)
|
||||
|
||||
if _, err := runner.Run(ctx, chatMsg("s2", "chat-1", "alice", "hi again"), nil); err != nil {
|
||||
t.Fatalf("Run() turn 2 error = %v", err)
|
||||
}
|
||||
prompt := lastSystemPrompt(prepared)
|
||||
if !strings.Contains(prompt, "alice prefers dark roast coffee") {
|
||||
t.Fatalf("turn 2 prompt missing the record written in turn 1, prompt = %q", prompt)
|
||||
}
|
||||
if !strings.Contains(prompt, created.ID) {
|
||||
t.Fatalf("turn 2 prompt missing the record's id %q, prompt = %q", created.ID, prompt)
|
||||
}
|
||||
}
|
||||
|
||||
// TestTurnMemoryWriteNoResolvableUserOmitsUserTools is acceptance criterion
|
||||
// 7 at the turn boundary: a channel with no resolvable user (nil
|
||||
// UserIdentity, the dashboard/webhook shape) gets a memory_create tool that
|
||||
// only offers agent scope, never user or agent-user.
|
||||
func TestTurnMemoryWriteNoResolvableUserOmitsUserTools(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
engine := infraMemory.NewBuiltinEngine(t.TempDir(), 0)
|
||||
store := NewSessionStoreMemory()
|
||||
router := NewRouter(nil, nil, "web")
|
||||
router.Identity = "archie"
|
||||
router.InitSessions(store)
|
||||
prepared := &turnTestPreparedModel{reply: "ok"}
|
||||
model := &turnTestModel{prepared: prepared}
|
||||
runner := NewTurnRunner(TurnRunnerConfig{
|
||||
Router: router,
|
||||
Sessions: store,
|
||||
Models: &fakeModelManager{models: []string{"test/model"}, activeModel: "test/model"},
|
||||
Personas: NewPersonaRegistry(DefaultPersonas()),
|
||||
Model: model,
|
||||
BotUser: "archie",
|
||||
Channel: "web",
|
||||
Log: slog.New(slog.DiscardHandler),
|
||||
MemoryEngine: engine,
|
||||
MemoryWriter: engine,
|
||||
UserIdentity: nil,
|
||||
})
|
||||
|
||||
if _, err := runner.Run(ctx, chatMsg("s1", "chat-1", "webhook-route", "hi"), nil); err != nil {
|
||||
t.Fatalf("Run() error = %v", err)
|
||||
}
|
||||
create := findTool(t, model.gotExtra, "memory_create")
|
||||
for _, kind := range schemaEnum(t, create) {
|
||||
if kind == string(domainmemory.ScopeUser) || kind == string(domainmemory.ScopeAgentUser) {
|
||||
t.Fatalf("resolverless channel's memory_create offers scope %q, want agent only", kind)
|
||||
}
|
||||
}
|
||||
|
||||
_, err := create.Handler(ctx, map[string]any{"scope": "user", "content": "should never write"})
|
||||
if err == nil {
|
||||
t.Fatal("memory_create with scope=user on a resolverless channel succeeded, want an error")
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user