Pass deligate subagents full history, improved memory managment
This commit is contained in:
48
src/llm.ts
48
src/llm.ts
@@ -122,27 +122,25 @@ class LLM {
|
||||
this.memoryManager = new MemoryManager(this);
|
||||
}
|
||||
|
||||
private setupAgent(agents: Agent[] = [], allAgents: Agent[], pending: Map<string, any>, aborts: (() => void)[], depth = 0): AiTool[] {
|
||||
private setupAgent(agents: Agent[] = [], allAgents: Agent[], history: LLMMessage[], aborts: (() => void)[], depth = 0, delegateState: {resp: string | null}): AiTool[] {
|
||||
return agents.map(a => {
|
||||
const toolName = `${a.delegate ? '' : 'sub'}agent_${snakeCase(a.name)}`;
|
||||
return {
|
||||
name: toolName,
|
||||
description: `${a.delegate ? 'Delegate to ' : ''}Subagent: ${a.description || a.name}`,
|
||||
args: {
|
||||
args: <any>(a.delegate ? {} : {
|
||||
context: {type: 'string', description: 'Summary of related messages, samples, files, etc...', required: true},
|
||||
instructions: {type: 'string', description: 'Detailed instructions for subagent to complete', required: true},
|
||||
},
|
||||
}),
|
||||
fn: async (args: any, stream: any, ai: any, id?: string) => {
|
||||
if(depth >= MAX_AGENT_DEPTH) return 'Max agent delegation depth exceeded';
|
||||
const subHistory: LLMMessage[] = [];
|
||||
|
||||
// Opt-in only, self always excluded regardless of whitelist
|
||||
const nested = (a.agents || [])
|
||||
.map(name => allAgents.find(x => x.name === name))
|
||||
.filter((x): x is Agent => !!x && x.name !== a.name);
|
||||
|
||||
const start = Date.now();
|
||||
const request = this.ask(`${args.instructions}${args.context ? `\n\n<context>${args.context}</context>` : ''}`, {
|
||||
const request = this.ask(a.delegate ? '' : `${args.instructions}${args.context ? `\n\n<context>${args.context}</context>` : ''}`, {
|
||||
system: `You are a specialized subagent. ${a.delegate ? 'Your output streams directly to the user for the remainder of this turn. You are mid conversation - dispense with greetings.' : 'You are wrapped in a tool call that will be analysis by an LLM - dispense with conversation'}
|
||||
As a subagent, focus on executing your task completely using available tools and returning only the final result - no commentary, questions, or dialogue.
|
||||
|
||||
@@ -150,7 +148,7 @@ ${a.system}`,
|
||||
model: a.model || undefined,
|
||||
temperature: a.temperature,
|
||||
stream: a.delegate ? stream : undefined,
|
||||
history: subHistory,
|
||||
history: a.delegate ? history : [],
|
||||
mcp: a.mcp || undefined,
|
||||
skills: a.skills || undefined,
|
||||
tools: a.tools || undefined,
|
||||
@@ -159,14 +157,9 @@ ${a.system}`,
|
||||
} as any);
|
||||
aborts.push(request.abort);
|
||||
const resp = await request;
|
||||
const duration = Date.now() - start;
|
||||
const assistantTurns = subHistory.filter((h: any) => h.role === 'assistant' && h.duration);
|
||||
const genTime = assistantTurns.reduce((s, h: any) => s + h.duration, 0);
|
||||
const genTokens = assistantTurns.reduce((s, h: any) => s + (h.tps || 0) * (h.duration / 1000), 0);
|
||||
const tps = genTime > 0 ? genTokens / (genTime / 1000) : 0;
|
||||
|
||||
if(a.delegate) {
|
||||
pending.set(<string>id, {resp, subHistory, duration, tps});
|
||||
delegateState.resp = resp;
|
||||
return '';
|
||||
}
|
||||
return resp;
|
||||
@@ -292,8 +285,8 @@ ${a.system}`,
|
||||
|
||||
// Agents
|
||||
const agents = options.agents || this.ai.options?.llm?.agents;
|
||||
const pendingDelegates = new Map<string, any>();
|
||||
if(agents?.length) tools.push(...this.setupAgent(agents, agents, pendingDelegates, nestedAborts, options._agentDepth || 0));
|
||||
const delegateState: {resp: string | null} = {resp: null};
|
||||
if(agents?.length) tools.push(...this.setupAgent(agents, agents, history, nestedAborts, options._agentDepth || 0, delegateState));
|
||||
|
||||
// Memory
|
||||
const mem = MemoryManager.normalize(options.memory);
|
||||
@@ -335,7 +328,6 @@ Also relevant but not preloaded (use \`memory_recall\`): ${listed.map(r => r.nam
|
||||
|
||||
if(aborted) throw Object.assign(new Error('Aborted'), {name: 'AbortError'});
|
||||
|
||||
// Time each tool call's real execution so its history entry gets its own duration/tps
|
||||
const toolTimings = new Map<string, {duration: number, tps: number}>();
|
||||
tools = this.wrapToolTiming(tools, toolTimings);
|
||||
|
||||
@@ -345,34 +337,14 @@ Also relevant but not preloaded (use \`memory_recall\`): ${listed.map(r => r.nam
|
||||
request = this.models[m].ask(message, {...options, tools, system: prompts.filter(Boolean).join('\n\n')});
|
||||
let resp = await request;
|
||||
|
||||
// Providers stamp duration/tps on assistant entries themselves (from real API usage).
|
||||
// Overwrite tool entries with actual tool-execution timing instead of the LLM call timing.
|
||||
// Capture meta (duration / tps)
|
||||
for(const h of history) {
|
||||
if(h.role === 'tool' && toolTimings.has(h.id)) Object.assign(h, toolTimings.get(h.id));
|
||||
}
|
||||
|
||||
// Spice delegated agents response into history
|
||||
let lastDelegateResp: string | null = null;
|
||||
if(pendingDelegates.size) {
|
||||
for(let i = 0; i < history.length; i++) {
|
||||
const h: any = history[i];
|
||||
if(h.role !== 'tool' || !pendingDelegates.has(h.id)) continue;
|
||||
const {resp: delegateResp, subHistory, duration, tps} = pendingDelegates.get(h.id)!;
|
||||
pendingDelegates.delete(h.id);
|
||||
const insert: LLMMessage[] = [...subHistory.filter(sh => sh.role === 'tool'), {role: 'assistant', content: delegateResp, timestamp: Date.now(), duration, tps}];
|
||||
history.splice(i + 1, 0, ...insert);
|
||||
lastDelegateResp = delegateResp;
|
||||
i += insert.length;
|
||||
}
|
||||
}
|
||||
if(typeof resp === 'string' && !resp.trim() && delegateState.resp !== null) resp = delegateState.resp;
|
||||
|
||||
// If the orchestrator added no commentary of its own, its answer IS the delegate's answer
|
||||
if(typeof resp === 'string' && !resp.trim() && lastDelegateResp !== null) resp = lastDelegateResp;
|
||||
|
||||
// Trim memory injections from history
|
||||
if(mem?.tool) history.splice(0, history.length, ...history.filter(h => h.role !== 'tool' || h.name !== 'memory_recall'));
|
||||
|
||||
// Auto-memorize before compressing
|
||||
if(options.compress && this.estimateTokens(history) >= options.compress.max) {
|
||||
if(mem?.update) await this.memoryManager.memorize(history, mem.memory, {model: options.memoryModel || this.defaultModel, ...options});
|
||||
const compressed = await this.compressHistory(history, options.compress.max, options.compress.min, options);
|
||||
|
||||
469
src/memory.ts
469
src/memory.ts
@@ -2,6 +2,16 @@ import {LLMRequest, LLMMessage} from './llm.ts';
|
||||
import {AiTool} from './tools.ts';
|
||||
import {KDPoint, KDTree} from './kd-tree.ts';
|
||||
|
||||
const FACTS_HEADING = '## Facts';
|
||||
|
||||
const GENERIC_TEMPLATE = `# {{Title}}
|
||||
|
||||
## Summary
|
||||
|
||||
## Details
|
||||
|
||||
## Related`;
|
||||
|
||||
export class MemoryCache {
|
||||
private tree: KDTree<MemoryRef>;
|
||||
public memories: Memory[];
|
||||
@@ -77,46 +87,35 @@ export type Memory = {
|
||||
description: string;
|
||||
content: string;
|
||||
embedding: number[];
|
||||
}
|
||||
|
||||
export type MemoryRef = {
|
||||
name: string;
|
||||
description: string;
|
||||
}
|
||||
|
||||
export type FactBucket = {
|
||||
subject: string;
|
||||
facts: string[];
|
||||
}
|
||||
|
||||
export type MemoryNode = {
|
||||
name: string;
|
||||
missing: boolean;
|
||||
links: string[];
|
||||
backlinks: string[];
|
||||
}
|
||||
|
||||
type MemoryRef = {
|
||||
name: string;
|
||||
description: string;
|
||||
}
|
||||
|
||||
type FactBucket = {
|
||||
subject: string;
|
||||
facts: string[];
|
||||
}
|
||||
|
||||
function extractLinks(content: string): string[] {
|
||||
if(!content) return [];
|
||||
if (!content) return [];
|
||||
const matches = content.matchAll(/\[\[([^\]]+)\]\]/g);
|
||||
return [...new Set([...matches].map(m => m[1].trim()))];
|
||||
}
|
||||
|
||||
export function extractMetadata(content: string): {links: string[], backlinks: string[]} {
|
||||
const match = content.match(/^---\n([\s\S]*?)\n---/);
|
||||
if (!match) return {links: [], backlinks: []};
|
||||
|
||||
const fm = match[1];
|
||||
const getList = (key: string): string[] => {
|
||||
const m = fm.match(new RegExp(`^${key}:\\s*\\[(.*)\\]$`, 'm'));
|
||||
if (!m || !m[1].trim()) return [];
|
||||
return m[1].split(',').map(s => s.trim().replace(/^"|"$/g, '')).filter(Boolean);
|
||||
};
|
||||
|
||||
return {
|
||||
links: getList('links'),
|
||||
backlinks: getList('backlinks'),
|
||||
};
|
||||
export function rebuildGraph(memories: Memory[]): void {
|
||||
for (const m of memories) m.links = extractLinks(m.content).filter(l => l !== m.name);
|
||||
for (const m of memories) m.backlinks = [];
|
||||
for (const m of memories) {
|
||||
for (const link of m.links) {
|
||||
const target = memories.find(t => t.name === link);
|
||||
if (target) target.backlinks.push(m.name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function dedupeFacts(facts: string[]): string[] {
|
||||
@@ -147,23 +146,11 @@ function getWeekMonday(date: Date = new Date()): string {
|
||||
return d.toISOString().slice(0, 10);
|
||||
}
|
||||
|
||||
function getWeekSunday(monday: string): string {
|
||||
const d = new Date(`${monday}T00:00:00Z`);
|
||||
d.setUTCDate(d.getUTCDate() + 6);
|
||||
return d.toISOString().slice(0, 10);
|
||||
}
|
||||
|
||||
export class MemoryManager {
|
||||
private recentlyTouched = new Map<string, number>();
|
||||
|
||||
private pendingMemorizations = new Map<string, {
|
||||
memories: Memory[] | MemoryCache,
|
||||
tempMemoryName: string,
|
||||
timestamp: number,
|
||||
}>();
|
||||
|
||||
private queues = new Map<string, {
|
||||
pending: string[],
|
||||
dirty: boolean,
|
||||
request: {abort?: () => void} | null,
|
||||
task: Promise<void>,
|
||||
}>();
|
||||
@@ -176,7 +163,7 @@ export class MemoryManager {
|
||||
name: {type: 'string', description: 'Exact memory name', required: true},
|
||||
},
|
||||
fn: (args: any) => {
|
||||
const mems = memories instanceof MemoryCache ? memories.memories : memories;
|
||||
const mems = this.unwrap(memories);
|
||||
const mem = mems.find(m => m.name === args.name);
|
||||
if (!mem) return 'Document not found';
|
||||
this.touch(mem.name);
|
||||
@@ -205,110 +192,58 @@ export class MemoryManager {
|
||||
return raw ? {memory: <Memory[] | MemoryCache>m, inject: true, tool: true, update: true} : {inject: true, tool: true, update: true, ...m};
|
||||
}
|
||||
|
||||
private async createTempMemory(conversation: string): Promise<Memory> {
|
||||
const timestamp = Date.now();
|
||||
const content = `---
|
||||
name: _temp_${timestamp}
|
||||
description: Temporary memory - processing in background
|
||||
tags: [_temporary]
|
||||
links: []
|
||||
backlinks: []
|
||||
modified: ${new Date().toISOString()}
|
||||
---
|
||||
|
||||
# Recent Conversation (Processing)
|
||||
|
||||
${conversation}`;
|
||||
const [e] = await this.llm.embedding(content);
|
||||
return {
|
||||
name: `_temp_${timestamp}`,
|
||||
description: 'Temporary memory - processing in background',
|
||||
content,
|
||||
embedding: e?.embedding || [],
|
||||
};
|
||||
private unwrap(memories: Memory[] | MemoryCache): Memory[] {
|
||||
return memories instanceof MemoryCache ? memories.memories : memories;
|
||||
}
|
||||
|
||||
private applyHeader(content: string, header: string): string {
|
||||
return `${header}\n\n${this.stripHeader(content)}`;
|
||||
private sync(memories: Memory[] | MemoryCache): void {
|
||||
if (memories instanceof MemoryCache) memories.rebuild();
|
||||
}
|
||||
|
||||
private async backgroundMemorization(conversation: string, memories: Memory[] | MemoryCache, options: LLMRequest, tempName: string): Promise<void> {
|
||||
const mem = memories instanceof MemoryCache ? memories.memories : memories;
|
||||
const monday = getWeekMonday();
|
||||
const sunday = getWeekSunday(monday);
|
||||
const buckets = await this.factAgent(conversation, mem, options, monday);
|
||||
if(!buckets.length) return;
|
||||
const jobs = [...buckets].map(({subject, facts}) => {
|
||||
let node = mem.find(m => m.name === subject);
|
||||
if(!node) {
|
||||
node = {name: subject, description: '', content: '', embedding: [],};
|
||||
mem.push(node);
|
||||
}
|
||||
const week = subject.startsWith('Journal/') ? {monday, sunday} : undefined;
|
||||
return this.enqueue(node, facts, mem, options, tempName, week);
|
||||
});
|
||||
await Promise.all(jobs);
|
||||
}
|
||||
|
||||
private buildHeader(node: Memory, week?: {monday: string, sunday: string}, links: string[] = [], backlinks: string[] = []): string {
|
||||
const tags = node.name.split('/')[0]?.toLowerCase();
|
||||
const lines = [
|
||||
'---',
|
||||
`name: ${node.name}`,
|
||||
`description: ${node.description || ''}`,
|
||||
tags ? `tags: [${tags}]` : '',
|
||||
links.length ? `links: [${links.map(l => `"${l}"`).join(', ')}]` : 'links: []',
|
||||
backlinks.length ? `backlinks: [${backlinks.map(l => `"${l}"`).join(', ')}]` : 'backlinks: []',
|
||||
week ? `week: ${week.monday} – ${week.sunday}` : '',
|
||||
`modified: ${new Date().toISOString()}`,
|
||||
'---',
|
||||
].filter(Boolean);
|
||||
return lines.join('\n');
|
||||
}
|
||||
|
||||
private cosineSearch(query: number[], memories: Memory[], limit: number): MemoryRef[] {
|
||||
const scored = memories
|
||||
.filter(m => m.embedding?.length)
|
||||
.map(m => ({
|
||||
ref: {name: m.name, description: m.description},
|
||||
distance: cosineDistance(query, m.embedding),
|
||||
}))
|
||||
.sort((a, b) => a.distance - b.distance)
|
||||
.slice(0, limit);
|
||||
return scored.map(s => s.ref);
|
||||
}
|
||||
|
||||
/**
|
||||
* Coalescing queue: if a doc is already compiling, abort the in-flight run, merge its
|
||||
* facts with the new ones and restart. Never blocks a pending update, never drops facts.
|
||||
*/
|
||||
private enqueue(node: Memory, facts: string[], memories: Memory[] | MemoryCache, options: LLMRequest, tempName: string, week?: {monday: string, sunday: string}): Promise<void> {
|
||||
const key = node.name;
|
||||
const existing = this.queues.get(key);
|
||||
if (existing) {
|
||||
existing.pending.push(...facts);
|
||||
existing.request?.abort?.();
|
||||
return existing.task;
|
||||
private parseFrontmatter(content: string): {fm: Map<string, string>, body: string} {
|
||||
const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
|
||||
if (!match) return {fm: new Map(), body: content};
|
||||
const fm = new Map<string, string>();
|
||||
for (const line of match[1].split('\n')) {
|
||||
const i = line.indexOf(':');
|
||||
if (i === -1) continue;
|
||||
fm.set(line.slice(0, i).trim(), line.slice(i + 1).trim());
|
||||
}
|
||||
|
||||
const entry: {pending: string[], request: {abort?: () => void} | null, task: Promise<void>} = {pending: [...facts], request: null, task: Promise.resolve()};
|
||||
this.queues.set(key, entry);
|
||||
const m = memories instanceof MemoryCache ? memories.memories : memories;
|
||||
entry.task = (async () => {
|
||||
while (entry.pending.length) {
|
||||
const batch = dedupeFacts(entry.pending.splice(0, entry.pending.length));
|
||||
const written = await this.docAgent(node, batch, m, options, tempName, week, entry);
|
||||
if (!written) entry.pending.unshift(...batch);
|
||||
}
|
||||
})().finally(() => {
|
||||
this.queues.delete(key);
|
||||
if(!this.queues.size && memories instanceof MemoryCache) memories.rebuild();
|
||||
});
|
||||
return entry.task;
|
||||
return {fm, body: match[2]};
|
||||
}
|
||||
|
||||
private listNodes(memories: Memory[]): MemoryRef[] {
|
||||
return memories.map(m => ({name: m.name, description: m.description}));
|
||||
private writeFrontmatter(fm: Map<string, string>, body: string): string {
|
||||
const lines = [...fm.entries()].map(([k, v]) => `${k}: ${v}`);
|
||||
return `---\n${lines.join('\n')}\n---\n\n${body.trimStart()}`;
|
||||
}
|
||||
|
||||
private stripHeader(content: string): string {
|
||||
return content.replace(/^---[\s\S]*?\n---\n?/, '').trimStart();
|
||||
}
|
||||
|
||||
private touchHeader(node: Memory, body: string): string {
|
||||
const {fm} = this.parseFrontmatter(node.content);
|
||||
fm.set('name', node.name);
|
||||
fm.set('description', node.description || '');
|
||||
fm.set('modified', new Date().toISOString());
|
||||
return this.writeFrontmatter(fm, body);
|
||||
}
|
||||
|
||||
private ensureDoc(node: Memory): void {
|
||||
if (node.content) return;
|
||||
const title = node.name.split('/').pop() ?? node.name;
|
||||
node.content = this.touchHeader(node, `# ${title}\n`);
|
||||
}
|
||||
|
||||
private appendFacts(node: Memory, facts: string[]): void {
|
||||
this.ensureDoc(node);
|
||||
const body = this.stripHeader(node.content);
|
||||
const bullets = facts.map(f => `- ${f}`).join('\n');
|
||||
const idx = body.indexOf(FACTS_HEADING);
|
||||
const newBody = idx === -1
|
||||
? `${body.trimEnd()}\n\n${FACTS_HEADING}\n${bullets}\n`
|
||||
: `${body.slice(0, idx + FACTS_HEADING.length)}\n${bullets}${body.slice(idx + FACTS_HEADING.length)}`;
|
||||
node.content = this.touchHeader(node, newBody);
|
||||
}
|
||||
|
||||
decay() {
|
||||
@@ -318,71 +253,27 @@ ${conversation}`;
|
||||
}
|
||||
}
|
||||
|
||||
forget(name: string, memories: Memory[] | MemoryCache): boolean {
|
||||
const mem = memories instanceof MemoryCache ? memories.memories : memories;
|
||||
const idx = mem.findIndex(m => m.name === name);
|
||||
if (idx === -1) return false;
|
||||
|
||||
for (const node of mem) {
|
||||
const {links, backlinks} = extractMetadata(node.content);
|
||||
const newBacklinks = backlinks.filter(b => b !== name);
|
||||
const newLinks = links.filter(l => l !== name);
|
||||
|
||||
if (newBacklinks.length !== backlinks.length || newLinks.length !== links.length) {
|
||||
node.content = this.updateFrontmatter(node.content, {
|
||||
links: newLinks,
|
||||
backlinks: newBacklinks,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
mem.splice(idx, 1);
|
||||
|
||||
if (memories instanceof MemoryCache) memories.rebuild();
|
||||
return true;
|
||||
touch(name: string, ttl = 2) {
|
||||
this.recentlyTouched.set(name, ttl);
|
||||
}
|
||||
|
||||
getTouched(): string[] {
|
||||
return [...this.recentlyTouched.keys()];
|
||||
}
|
||||
|
||||
async memorize(history: LLMMessage[], memories: Memory[] | MemoryCache, options: LLMRequest): Promise<Memory[]> {
|
||||
const conversation = history
|
||||
.filter(h => h.role === 'user' || h.role === 'assistant')
|
||||
.map(h => `[${h.role}]: ${h.content}`).join('\n\n').trim();
|
||||
if(!conversation) return [];
|
||||
forget(name: string, memories: Memory[] | MemoryCache): boolean {
|
||||
const mem = this.unwrap(memories);
|
||||
const idx = mem.findIndex(m => m.name === name);
|
||||
if (idx === -1) return false;
|
||||
|
||||
const trackingId = `${Date.now()}_${Math.random()}`;
|
||||
const tempMemory = await this.createTempMemory(conversation);
|
||||
const mem = memories instanceof MemoryCache ? memories.memories : memories;
|
||||
mem.push(tempMemory);
|
||||
if (memories instanceof MemoryCache) memories.rebuild();
|
||||
this.pendingMemorizations.set(trackingId, {
|
||||
memories,
|
||||
tempMemoryName: tempMemory.name,
|
||||
timestamp: Date.now(),
|
||||
});
|
||||
|
||||
try {
|
||||
await this.backgroundMemorization(conversation, memories, options, tempMemory.name);
|
||||
const finalMem = memories instanceof MemoryCache ? memories.memories : memories;
|
||||
return finalMem.filter(m => !m.name.startsWith('_temp_'));
|
||||
} finally {
|
||||
const pending = this.pendingMemorizations.get(trackingId);
|
||||
if (pending) {
|
||||
const cleanMem = pending.memories instanceof MemoryCache
|
||||
? pending.memories.memories
|
||||
: pending.memories;
|
||||
const idx = cleanMem.findIndex(m => m.name === pending.tempMemoryName);
|
||||
if (idx !== -1) cleanMem.splice(idx, 1);
|
||||
if (pending.memories instanceof MemoryCache) pending.memories.rebuild();
|
||||
}
|
||||
this.pendingMemorizations.delete(trackingId);
|
||||
}
|
||||
mem.splice(idx, 1);
|
||||
rebuildGraph(mem);
|
||||
this.sync(memories);
|
||||
return true;
|
||||
}
|
||||
|
||||
async recollect(query: string, memories: Memory[] | MemoryCache, limit = 5, graphDepth = 1): Promise<Memory[]> {
|
||||
const mem: Memory[] = memories instanceof MemoryCache ? memories.memories : memories;
|
||||
const mem = this.unwrap(memories);
|
||||
if (!mem.length) return [];
|
||||
|
||||
const [e] = await this.llm.embedding(query);
|
||||
@@ -400,8 +291,7 @@ ${conversation}`;
|
||||
for (const name of frontier) {
|
||||
const node = mem.find(m => m.name === name);
|
||||
if (!node) continue;
|
||||
const {links} = extractMetadata(node.content);
|
||||
for (const link of links) {
|
||||
for (const link of node.links) {
|
||||
if (!found.has(link) && mem.find(m => m.name === link)) {
|
||||
found.add(link);
|
||||
next.push(link);
|
||||
@@ -419,114 +309,151 @@ ${conversation}`;
|
||||
return ordered.map(n => mem.find(m => m.name === n)!).filter(Boolean);
|
||||
}
|
||||
|
||||
touch(name: string, ttl = 2) {
|
||||
this.recentlyTouched.set(name, ttl);
|
||||
private cosineSearch(query: number[], memories: Memory[], limit: number): MemoryRef[] {
|
||||
const scored = memories
|
||||
.filter(m => m.embedding?.length)
|
||||
.map(m => ({
|
||||
ref: {name: m.name, description: m.description},
|
||||
distance: cosineDistance(query, m.embedding),
|
||||
}))
|
||||
.sort((a, b) => a.distance - b.distance)
|
||||
.slice(0, limit);
|
||||
return scored.map(s => s.ref);
|
||||
}
|
||||
|
||||
private updateFrontmatter(content: string, updates: {links?: string[], backlinks?: string[]}): string {
|
||||
const match = content.match(/^---\n([\s\S]*?)\n---\n\n?([\s\S]*)$/);
|
||||
if (!match) return content;
|
||||
private listNodes(memories: Memory[]): MemoryRef[] {
|
||||
return memories.map(m => ({name: m.name, description: m.description}));
|
||||
}
|
||||
|
||||
const [, fm, body] = match;
|
||||
let newFm = fm;
|
||||
async memorize(history: LLMMessage[], memories: Memory[] | MemoryCache, options: LLMRequest): Promise<Memory[]> {
|
||||
const conversation = history
|
||||
.filter(h => h.role === 'user' || h.role === 'assistant')
|
||||
.map(h => `[${h.role}]: ${h.content}`).join('\n\n').trim();
|
||||
if (!conversation) return [];
|
||||
|
||||
if (updates.links !== undefined) {
|
||||
const linksList = updates.links.length ? `[${updates.links.map(l => `"${l}"`).join(', ')}]` : '[]';
|
||||
newFm = newFm.replace(/^links:.*$/m, `links: ${linksList}`);
|
||||
const uid = `${Date.now()}_${Math.random().toString(36).slice(2)}`;
|
||||
// NOTE: adjust field names below (id/tool_call_id/name) to match your LLMMessage/tool-call schema.
|
||||
const pending = {role: 'tool', name: 'memory_process', id: uid, content: 'Processing…'} as unknown as LLMMessage;
|
||||
history.push(pending);
|
||||
|
||||
const mem = this.unwrap(memories);
|
||||
const buckets = await this.factAgent(conversation, mem, options, getWeekMonday());
|
||||
const touched: Memory[] = [];
|
||||
|
||||
for (const {subject, facts} of buckets) {
|
||||
let node = mem.find(m => m.name === subject);
|
||||
if (!node) {
|
||||
node = {name: subject, description: '', content: '', embedding: [], links: [], backlinks: []};
|
||||
mem.push(node);
|
||||
}
|
||||
this.appendFacts(node, facts);
|
||||
const [e] = await this.llm.embedding(node.content);
|
||||
if (e) node.embedding = e.embedding;
|
||||
this.touch(node.name);
|
||||
touched.push(node);
|
||||
}
|
||||
|
||||
if (updates.backlinks !== undefined) {
|
||||
const backlinksList = updates.backlinks.length ? `[${updates.backlinks.map(l => `"${l}"`).join(', ')}]` : '[]';
|
||||
newFm = newFm.replace(/^backlinks:.*$/m, `backlinks: ${backlinksList}`);
|
||||
if (touched.length) {
|
||||
rebuildGraph(mem);
|
||||
this.sync(memories);
|
||||
(pending as any).content = `Saved to ${touched.map(n => `[[${n.name}]]`).join(', ')}`;
|
||||
for (const node of touched) this.reconcile(node, memories, options).catch(() => {});
|
||||
} else {
|
||||
(pending as any).content = 'Nothing worth remembering.';
|
||||
}
|
||||
|
||||
newFm = newFm.replace(/^modified:.*$/m, `modified: ${new Date().toISOString()}`);
|
||||
|
||||
return `---\n${newFm}\n---\n\n${body}`;
|
||||
return touched;
|
||||
}
|
||||
|
||||
private stripHeader(content: string): string {
|
||||
return content.replace(/^---[\s\S]*?\n---\n?/, '').trimStart();
|
||||
/** Manual/cron entry point. scope 'touched' only reconciles docs with a pending Facts inbox. */
|
||||
async reconcileVault(memories: Memory[] | MemoryCache, options: LLMRequest, scope: 'touched' | 'all' = 'touched'): Promise<void> {
|
||||
const mem = this.unwrap(memories);
|
||||
const targets = scope === 'all' ? mem : mem.filter(m => m.content.includes(FACTS_HEADING));
|
||||
await Promise.all(targets.map(node => this.reconcile(node, memories, options)));
|
||||
this.sync(memories);
|
||||
}
|
||||
|
||||
private async docAgent(node: Memory, facts: string[], memories: Memory[], options: LLMRequest, tempName: string, week: {monday: string, sunday: string} | undefined, entry: {request: {abort?: () => void} | null}): Promise<boolean> {
|
||||
const {links: oldLinks} = extractMetadata(node.content);
|
||||
/**
|
||||
* Coalescing queue: if a doc is already reconciling, mark it dirty and abort the in-flight
|
||||
* request. The loop below always re-reads node.content fresh, so nothing is ever dropped.
|
||||
*/
|
||||
private reconcile(node: Memory, memories: Memory[] | MemoryCache, options: LLMRequest): Promise<void> {
|
||||
const key = node.name;
|
||||
const existing = this.queues.get(key);
|
||||
if (existing) {
|
||||
existing.dirty = true;
|
||||
existing.request?.abort?.();
|
||||
return existing.task;
|
||||
}
|
||||
|
||||
const entry = {dirty: false, request: null, task: Promise.resolve()};
|
||||
this.queues.set(key, entry);
|
||||
const mem = this.unwrap(memories);
|
||||
entry.task = (async () => {
|
||||
do {
|
||||
entry.dirty = false;
|
||||
await this.reconcileDoc(node, mem, options, entry);
|
||||
} while (entry.dirty);
|
||||
})().finally(() => {
|
||||
this.queues.delete(key);
|
||||
rebuildGraph(mem);
|
||||
this.sync(memories);
|
||||
});
|
||||
return entry.task;
|
||||
}
|
||||
|
||||
private async reconcileDoc(node: Memory, memories: Memory[], options: LLMRequest, entry: {request: {abort?: () => void} | null}): Promise<void> {
|
||||
const currentBody = this.stripHeader(node.content);
|
||||
let update;
|
||||
try {
|
||||
for(let i = 0; i < 3 && !update?.content; i++) {
|
||||
const request = this.llm.ask(`New Facts:\n${facts.map(f => `- ${f}`).join('\n')}`, {
|
||||
for (let i = 0; i < 2 && !update?.content; i++) {
|
||||
const request = this.llm.ask(currentBody, {
|
||||
model: options.model,
|
||||
temperature: 0.3,
|
||||
schema: {
|
||||
description: {type: 'string', description: 'One-line description of what this document covers, no formatting or emojis', required: true},
|
||||
content: {type: 'string', description: 'Rewritten document in markdown, without the frontmatter block', required: true},
|
||||
content: {type: 'string', description: 'Rewritten document body in markdown, without the frontmatter block', required: true},
|
||||
},
|
||||
system: `You are a knowledge base editor. Rewrite the current document below so it incorporates the new facts.
|
||||
system: `You are a knowledge base editor maintaining one document in an Obsidian-style vault.
|
||||
|
||||
If the document has a "${FACTS_HEADING}" section, integrate every bullet under it into the appropriate part of the document, then remove the "${FACTS_HEADING}" section entirely. If there is no such section, just tidy the document per the rules below.
|
||||
|
||||
Structure: follow this generic shape loosely, adapting section names/order to what the content actually needs (e.g. journal-style docs may want a timeline instead of "Details"):
|
||||
\`\`\`markdown
|
||||
${GENERIC_TEMPLATE}
|
||||
\`\`\`
|
||||
|
||||
Formatting rules:
|
||||
- Use Obsidian-style markdown: # headings, **bold** to add emphasis, __italics__ for titles, terms, etc, bullet & numbered lists for grouped 1D data and tables for 2D data
|
||||
- Use Obsidian-style markdown: # headings, **bold** for emphasis, bullet & numbered lists for grouped 1D data, tables for 2D data
|
||||
- Link related concepts with [[WikiLink]] notation using full paths like [[People/Sarah]] or [[Projects/Website]]
|
||||
- Create links for specific entities (person, place, project, program) and abstract concepts (quantum mechanics, entropy) but skip generics (car, red, dog)
|
||||
- Create links for specific entities (person, place, project, program) and abstract concepts, but skip generics (car, red, dog)
|
||||
- Keep the document concise, factual, and human-readable
|
||||
- Resolve contradictions: the new facts always win — delete the outdated statement entirely, never keep both
|
||||
- Later facts in the list override earlier ones
|
||||
- Resolve contradictions: newer facts always win — delete the outdated statement entirely, never keep both
|
||||
- Do not add frontmatter blocks, filler, preamble, or AI commentary
|
||||
${week ? '- This is a weekly journal entry.\n' : ''}
|
||||
All nodes:
|
||||
${this.listNodes(memories).map(n => n.name).join(', ') || 'none'}
|
||||
|
||||
Other nodes in the vault (link to these instead of duplicating their content):
|
||||
${this.listNodes(memories).filter(n => n.name !== node.name).map(n => n.name).join(', ') || 'none'}
|
||||
|
||||
Current document:
|
||||
\`\`\`markdown
|
||||
${currentBody}
|
||||
\`\`\``}
|
||||
);
|
||||
\`\`\``,
|
||||
});
|
||||
entry.request = request;
|
||||
update = await request;
|
||||
}
|
||||
} catch (err: any) {
|
||||
if (err?.name === 'AbortError') return false;
|
||||
if (err?.name === 'AbortError') return;
|
||||
throw err;
|
||||
} finally {
|
||||
entry.request = null;
|
||||
}
|
||||
|
||||
if(!update?.content) return false;
|
||||
const newLinks = extractLinks(update.content).filter(l => l !== node.name && l !== tempName);
|
||||
const newLinkSet = new Set(newLinks);
|
||||
const oldLinkSet = new Set(oldLinks);
|
||||
|
||||
for (const added of newLinkSet) {
|
||||
if (!oldLinkSet.has(added)) {
|
||||
const target = memories.find(m => m.name === added);
|
||||
if (target) {
|
||||
const {backlinks} = extractMetadata(target.content);
|
||||
if (!backlinks.includes(node.name)) {
|
||||
target.content = this.updateFrontmatter(target.content, {
|
||||
backlinks: [...backlinks, node.name],
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const removed of oldLinkSet) {
|
||||
if (!newLinkSet.has(removed)) {
|
||||
const target = memories.find(m => m.name === removed);
|
||||
if (target) {
|
||||
const {backlinks} = extractMetadata(target.content);
|
||||
target.content = this.updateFrontmatter(target.content, {
|
||||
backlinks: backlinks.filter(b => b !== node.name),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const {backlinks} = extractMetadata(node.content);
|
||||
node.description = node.name !== 'Person/User' ? update.description : 'All information about the current user';
|
||||
node.content = this.applyHeader(update.content, this.buildHeader(node, week, newLinks, backlinks));
|
||||
if (!update?.content) return;
|
||||
node.description = node.name !== 'People/User' ? update.description : 'All information about the current user';
|
||||
node.content = this.touchHeader(node, update.content);
|
||||
const [e] = await this.llm.embedding(node.content);
|
||||
if(e) node.embedding = e.embedding;
|
||||
return true;
|
||||
if (e) node.embedding = e.embedding;
|
||||
}
|
||||
|
||||
private async factAgent(conversation: string, memories: Memory[], options: LLMRequest, weekKey: string): Promise<FactBucket[]> {
|
||||
@@ -546,13 +473,13 @@ Rules:
|
||||
|
||||
When extracting facts, you MUST also decide the exact destination path:
|
||||
- Use an existing node name if the facts clearly belong there
|
||||
- All information primary about the user should go under "People/User"
|
||||
- When required, create a new path following collection/subject format (e.g., People/Sarah, Projects/Oxide)
|
||||
- All information primarily about the user should go under "People/User"
|
||||
- When required, create a new path following collection/subject format (e.g., People/Sarah, Projects/Oxide) — you are not limited to any fixed list of collections, use whatever fits
|
||||
- For journal entries, use "Journal"
|
||||
|
||||
Available nodes:
|
||||
- Journal
|
||||
${this.listNodes(memories).filter(n => !n.name.includes('_temp_') && !n.name.includes('Journal')).map(n => `- ${n.name}: ${n.description}`).join('\n') || 'None yet.'}`,
|
||||
${this.listNodes(memories).filter(n => !n.name.includes('Journal')).map(n => `- ${n.name}: ${n.description}`).join('\n') || 'None yet.'}`,
|
||||
tools: [{
|
||||
name: 'facts_extract',
|
||||
description: 'Submit facts with their destination',
|
||||
|
||||
Reference in New Issue
Block a user