@dsh-libing/memory-manager 0.0.0-stage → 0.1.1

package/lib/index.d.ts

@@ -0,0 +1,26 @@
+import { type Context } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+import { z } from 'zod';
+import type { activityItemSchema } from './shared.ts';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'libing-memory': {
+            kind: 'libing-memory';
+            form: 'recall';
+            turn: number;
+            receipt: string;
+            items: z.infer<typeof activityItemSchema>[];
+            reason: string;
+        };
+    }
+}
+export declare const name = "libing-memory-manager";
+export declare const inject: string[];
+export declare const Config: Schema<Schemastery.ObjectS<NoInfer<{
+    dataRoot: Schema<string, string, "plain">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    dataRoot: Schema<string, string, "plain">;
+}>>, "plain">;
+export declare function apply(ctx: Context, config?: {
+    dataRoot?: string;
+}): Promise<void>;

package/lib/index.js

@@ -0,0 +1,134 @@
+import { Service } from '@deepseek-ai/cordis';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import Schema from '@deepseek-ai/schemastery';
+import { join, isAbsolute } from 'node:path';
+import { z } from 'zod';
+import { Runtime } from "./runtime.js";
+import { agentScope } from "./scope.js";
+import { modelDirectory } from "./models.js";
+import { API, MemoryError, draftSchema, mutationSchema, selectionSchema } from "./shared.js";
+export const name = 'libing-memory-manager';
+export const inject = ['connection', 'tools', 'systemPrompt', 'llm', 'sessionQuery', 'workspaceRegistry', 'profileContext'];
+export const Config = Schema.object({ dataRoot: Schema.string().description('Absolute data root; default is current profile/libing/memory-manager') });
+const lifetimes = new Map();
+export async function apply(ctx, config = {}) {
+    const root = config.dataRoot ?? join(ctx.profileContext.dir, 'libing/memory-manager');
+    if (!isAbsolute(root))
+        throw new MemoryError('absoluteRootRequired');
+    const owner = { disposed: false };
+    ctx.effect(() => () => { owner.disposed = true; const value = owner.lifetime; if (!value)
+        return; value.closing ??= value.runtime.close().finally(() => { if (lifetimes.get(root) === value)
+        lifetimes.delete(root); }); return value.closing; }, 'libing-memory: tasks and database');
+    const old = lifetimes.get(root);
+    if (old?.closing)
+        await old.closing;
+    if (owner.disposed)
+        return;
+    const runtime = new Runtime(ctx, root);
+    const value = { runtime };
+    owner.lifetime = value;
+    if (!lifetimes.has(root))
+        lifetimes.set(root, value);
+    await runtime.store.ready;
+    if (owner.disposed)
+        return;
+    class MemoryAccess extends Service {
+        version = 1;
+        constructor() { super(ctx, 'libingMemoryAccess'); }
+    }
+    new MemoryAccess();
+    const guard = async (request) => {
+        if (request.headers.get('content-type')?.split(';')[0]?.trim() !== 'application/json')
+            throw new MemoryError('invalidRequest', 415);
+        const body = await request.text();
+        if (Buffer.byteLength(body) > 20000)
+            throw new MemoryError('requestTooLarge', 413);
+        return JSON.parse(body);
+    };
+    const route = (path, methods, action) => ctx.effect(() => ctx.connection.fetch.register({ path: `${API}/${path}`, methods, requestBody: 'buffered', fetch: async (request) => {
+            try {
+                return Response.json(await runtime.run(signal => action(request, signal), request.signal), { headers: { 'cache-control': 'no-store' } });
+            }
+            catch (error) {
+                return Response.json({ error: (() => {
+                        if (error instanceof MemoryError) {
+                            return error.code;
+                        }
+                        if (error instanceof z.ZodError || error instanceof SyntaxError) {
+                            return 'invalidRequest';
+                        }
+                        return 'operationFailed';
+                    })() }, { status: (() => {
+                        if (error instanceof MemoryError) {
+                            return error.status;
+                        }
+                        if (error instanceof z.ZodError || error instanceof SyntaxError) {
+                            return 400;
+                        }
+                        return 503;
+                    })() });
+            }
+        } }), `libing-memory: ${path}`);
+    route('state', ['GET'], async (request, signal) => { const pairs = [...new URL(request.url).searchParams]; if (new Set(pairs.map(([key]) => key)).size !== pairs.length)
+        throw new MemoryError('invalidRequest', 400); return await runtime.state(selectionSchema.parse(Object.fromEntries(pairs)), signal); });
+    route('models', ['GET'], async (request, signal) => { if (new URL(request.url).search)
+        throw new MemoryError('invalidRequest', 400); return await modelDirectory(ctx, signal); });
+    route('mutate', ['POST'], async (request, signal) => { const body = z.object({ selection: selectionSchema, mutation: mutationSchema }).strict().parse(await guard(request)); return await runtime.mutate(body.selection, body.mutation, signal); });
+    route('read', ['POST'], async (request, signal) => { const body = z.object({ selection: selectionSchema, id: z.string(), version: z.number().int().optional() }).strict().parse(await guard(request)); const state = await runtime.state(body.selection, signal); return await runtime.store.call('read', { scope: state.scope, id: body.id, history: true, ...body.version ? { version: body.version } : {} }, z.unknown()); });
+    route('history', ['POST'], async (request, signal) => { const body = z.object({ selection: selectionSchema, id: z.string() }).strict().parse(await guard(request)); const state = await runtime.state(body.selection, signal); return await runtime.store.call('history', { scope: state.scope, id: body.id }, z.unknown()); });
+    ctx.effect(() => ctx.systemPrompt.section({ name: 'libing-memory:usage', order: 600, interpolate: false, text: 'libing_memory_search/read retrieve confirmed historical references in this conversation scope. Current explicit instructions take priority. libing_memory_propose submits a candidate, including updates; human review is required before it becomes readable. Do not claim that a pending candidate is saved as active memory.' }), 'libing-memory: guidance');
+    const liveAgents = new Map();
+    ctx.on('agent/created', ({ agent }) => { liveAgents.set(agent.session.id, agent); });
+    ctx.on('agent/disposed', ({ agent }) => { if (liveAgents.get(agent.session.id) === agent)
+        liveAgents.delete(agent.session.id); });
+    ctx.on('agent/pre-step', async (payload, next) => {
+        liveAgents.set(payload.agent.session.id, payload.agent);
+        const decision = await next();
+        if (decision.kind === 'reject' || payload.signal.aborted || payload.step !== 1 || !decision.messages.length)
+            return decision;
+        const query = decision.messages.filter(message => message.source.kind === 'user').flatMap(message => message.content.filter(block => block.type === 'text').map(block => block.text)).join('\n').slice(0, 4000);
+        if (!query)
+            return decision;
+        try {
+            return await runtime.run(async (signal) => {
+                const snapshot = await runtime.prepare(payload.agent, query, payload.turn, signal);
+                if (!snapshot.text)
+                    return decision;
+                const items = snapshot.selected.map(entry => ({ id: entry.id, version: entry.version, title: entry.title, summary: entry.content.slice(0, 500), status: 'included' }));
+                const message = createUserMessage({ content: [{ type: 'text', text: `Memory snapshot for turn ${payload.turn}.\n${snapshot.text}` }], source: { kind: 'libing-memory', form: 'recall', turn: payload.turn, receipt: snapshot.id, items, reason: snapshot.reason } });
+                signal.throwIfAborted();
+                return { ...decision, messages: [...decision.messages, message] };
+            }, payload.signal);
+        }
+        catch {
+            return decision;
+        }
+    });
+    ctx.on('session/event', async (session, event) => {
+        if (event.type !== 'user/message' || event.data.source.kind !== 'libing-memory')
+            return;
+        const source = event.data.source;
+        await runtime.run(async () => { const agent = liveAgents.get(session.id); if (!agent)
+            return; const scope = await agentScope(agent, ctx); await runtime.activity(scope, source.turn, 'included', source.items, source.reason, source.receipt); }).catch(() => { });
+    });
+    // turn/end is the persisted successful close; turn-stopping occurs before that close.
+    ctx.on('session/event', async (session, event) => {
+        if (event.type !== 'turn/end')
+            return;
+        await runtime.run(async (signal) => {
+            const state = await runtime.state({ sessionId: session.id }, signal);
+            await runtime.store.call('settle', { scope: state.scope, turn: event.data.turn, reason: event.data.reason.kind }, z.null());
+            const agent = liveAgents.get(session.id);
+            if (agent && event.data.reason.kind === 'completed')
+                await runtime.automatic(agent, event.data.turn, signal);
+        }).catch(() => { });
+    });
+    const str = (description) => ({ type: 'string', description });
+    ctx.tools.register(defineTool({ name: 'libing_memory_search', description: '搜索本会话范围内已确认且允许召回的记忆；未命中如实返回。候选不参与搜索。', parameters: { query: { ...str('问题、标题或关键词'), required: true } }, output: { schema: { type: 'json' }, render: (_args, data) => [{ type: 'text', text: JSON.stringify(data) }] }, presentCall: args => ({ card: 'generic', title: '搜索记忆', kind: 'other', rawInput: args }), execute: async (args, exec) => { const agent = exec.agent; if (!agent)
+            throw new MemoryError('unknownScope', 403); const query = z.string().min(1).max(2000).parse(args.query); return z.json().parse(await runtime.run(signal => runtime.query(agent, query, signal), exec.signal)); } }));
+    ctx.tools.register(defineTool({ name: 'libing_memory_read', description: '读取搜索结果中已确认的记忆及固定版本；再次检查会话范围。', parameters: { id: { ...str('搜索返回的记忆身份'), required: true }, version: { type: 'integer' } }, output: { schema: { type: 'json' }, render: (_args, data) => [{ type: 'text', text: JSON.stringify(data) }] }, presentCall: args => ({ card: 'generic', title: '读取记忆', kind: 'other', rawInput: args }), execute: async (args, exec) => { const agent = exec.agent; if (!agent)
+            throw new MemoryError('unknownScope', 403); return z.json().parse(await runtime.run(signal => runtime.read(agent, args.id, args.version, signal), exec.signal)); } }));
+    ctx.tools.register(defineTool({ name: 'libing_memory_propose', description: '提交新记忆或已有记忆的候选修订，必须等用户确认。不要提交秘密、猜测或一次性内容。不能批准、直接覆盖或永久删除。', parameters: { title: { ...str('简短标题'), required: true }, content: { ...str('可复用的结论和适用条件'), required: true }, kind: { type: 'string', enum: ['agreement', 'decision', 'lesson', 'handoff'], required: true }, range: { type: 'string', enum: ['workspace', 'session'] }, target: str('修订时使用已读取记忆的身份'), expected: { type: 'integer', description: '修订所基于的版本' } }, output: { schema: { type: 'json' }, render: (_args, data) => [{ type: 'text', text: JSON.stringify(data) }] }, presentCall: args => ({ card: 'generic', title: '提交记忆候选', kind: 'other', rawInput: args }), execute: async (args, exec) => { const agent = exec.agent; if (!agent)
+            throw new MemoryError('unknownScope', 403); const draft = draftSchema.parse({ title: args.title, content: args.content, kind: args.kind, range: args.range ?? 'workspace' }); return z.json().parse(await runtime.run(signal => runtime.propose(agent, draft, args.target, args.expected, signal, String(exec.callId)), exec.signal)); } }));
+}

package/lib/models.d.ts

@@ -0,0 +1,21 @@
+/** Resolve only the selected session's route, with an explicit profile fallback. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { CaptureModel, Settings } from './shared.ts';
+export declare function latestSessionModel(events: readonly SessionEvent[]): {
+    provider: string;
+    model: string;
+} | null;
+export declare function captureModel(ctx: Context, settings: Settings, session: string | null, signal?: AbortSignal): Promise<CaptureModel | null>;
+/** Directory lookups are explicit UI actions, bounded even for a slow adapter. */
+export declare function modelDirectory(ctx: Context, signal: AbortSignal): Promise<{
+    providers: {
+        models: {
+            id: string;
+            name: string;
+        }[];
+        unavailable: boolean;
+        id: string;
+        name: string;
+    }[];
+}>;

package/lib/models.js

@@ -0,0 +1,71 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { abort } from "./shared.js";
+export function latestSessionModel(events) {
+    for (let index = events.length - 1; index >= 0; index--) {
+        const event = events[index];
+        if (event?.type === 'request/context')
+            return { provider: event.data.provider, model: event.data.model };
+        if (event?.type === 'assistant/message')
+            return { provider: event.data.message.source.provider, model: event.data.message.source.model };
+    }
+    return null;
+}
+export async function captureModel(ctx, settings, session, signal) {
+    let route = null;
+    let source = 'custom';
+    if (settings.provider || settings.model) {
+        if (!settings.provider || !settings.model)
+            return null;
+        route = { provider: settings.provider, model: settings.model };
+    }
+    else {
+        if (session) {
+            const view = await ctx.sessionQuery.observeSession(SessionId(session), signal ? { signal } : {});
+            try {
+                route = latestSessionModel(view.events);
+            }
+            finally {
+                view[Symbol.dispose]();
+            }
+            if (route)
+                source = 'session';
+        }
+        if (!route) {
+            const selected = ctx.get('agentDefaultModel')?.currentSelection();
+            if (selected?.provider && selected.model) {
+                route = { provider: selected.provider, model: selected.model };
+                source = 'default';
+            }
+        }
+    }
+    abort(signal);
+    return route ? { ...route, source, available: ctx.llm.listProviders().some(provider => provider.id === route.provider) } : null;
+}
+/** Directory lookups are explicit UI actions, bounded even for a slow adapter. */
+export async function modelDirectory(ctx, signal) {
+    const providers = await Promise.all(ctx.llm.listProviders().map(async (provider) => {
+        const base = { id: provider.id, name: provider.name || provider.id };
+        let timer;
+        let stop;
+        try {
+            const models = await Promise.race([ctx.llm.listModels(provider.id), new Promise((_resolve, reject) => {
+                    stop = () => reject(new Error('modelDirectoryUnavailable'));
+                    timer = setTimeout(stop, 5000);
+                    signal.addEventListener('abort', stop, { once: true });
+                    if (signal.aborted)
+                        stop();
+                })]);
+            return { ...base, models: models.filter(model => !model.inputModalities || model.inputModalities.includes('text')).map(model => ({ id: model.id, name: model.name || model.id })), unavailable: false };
+        }
+        catch {
+            return { ...base, models: [], unavailable: true };
+        }
+        finally {
+            clearTimeout(timer);
+            if (stop)
+                signal.removeEventListener('abort', stop);
+        }
+    }));
+    abort(signal);
+    return { providers };
+}

package/lib/recall.d.ts

@@ -0,0 +1,55 @@
+/** Deterministic bilingual lexical retrieval over approved versions only. */
+import type { Entry, ActivityItem } from './shared.ts';
+export declare function terms(text: string): string[];
+export declare function search(entries: Entry[], query: string, limit?: number): {
+    entry: {
+        title: string;
+        content: string;
+        kind: "agreement" | "decision" | "lesson" | "handoff";
+        tags: string[];
+        pinned: boolean;
+        recall: boolean;
+        range: "workspace" | "session" | "personal";
+        id: string;
+        version: number;
+        workspace: string;
+        session: string | null;
+        state: "active" | "trash";
+        source: {
+            kind: "manual" | "model" | "capture";
+            session: string | null;
+            turn: number | null;
+            evidence: string;
+            seqs: number[];
+        };
+        updated: string;
+    };
+    score: number;
+}[];
+export declare function item(entry: Entry, status: ActivityItem['status']): ActivityItem;
+export declare function recall(entries: Entry[], query: string, maxChars: number): {
+    selected: {
+        title: string;
+        content: string;
+        kind: "agreement" | "decision" | "lesson" | "handoff";
+        tags: string[];
+        pinned: boolean;
+        recall: boolean;
+        range: "workspace" | "session" | "personal";
+        id: string;
+        version: number;
+        workspace: string;
+        session: string | null;
+        state: "active" | "trash";
+        source: {
+            kind: "manual" | "model" | "capture";
+            session: string | null;
+            turn: number | null;
+            evidence: string;
+            seqs: number[];
+        };
+        updated: string;
+    }[];
+    skipped: string[];
+    text: string;
+};

package/lib/recall.js

@@ -0,0 +1,47 @@
+export function terms(text) {
+    const result = new Set(text.toLocaleLowerCase().match(/[a-z0-9_-]{2,}/gu) ?? []);
+    for (const run of text.match(/[\p{Script=Han}]+/gu) ?? []) {
+        if (run.length === 1)
+            result.add(run);
+        for (let i = 0; i + 1 < run.length; i++)
+            result.add(run.slice(i, i + 2));
+    }
+    return [...result].slice(0, 100);
+}
+export function search(entries, query, limit = 5) {
+    const words = terms(query);
+    const eligible = entries.filter(row => row.state === 'active' && row.recall);
+    return eligible.map(entry => {
+        const heading = `${entry.title} ${entry.tags.join(' ')}`.toLocaleLowerCase();
+        const body = entry.content.toLocaleLowerCase();
+        const score = words.reduce((sum, word) => sum + ((() => {
+            if (heading.includes(word)) {
+                return 4;
+            }
+            if (body.includes(word)) {
+                return 1;
+            }
+            return 0;
+        })()), 0);
+        return { entry, score };
+    }).filter(row => row.score > 0).sort((a, b) => b.score - a.score || b.entry.updated.localeCompare(a.entry.updated)).slice(0, limit);
+}
+export function item(entry, status) { return { id: entry.id, version: entry.version, title: entry.title, summary: entry.content.slice(0, 500), status }; }
+export function recall(entries, query, maxChars) {
+    const eligible = entries.filter(row => row.state === 'active' && row.recall);
+    const pinned = eligible.filter(row => row.pinned).sort((a, b) => a.title.localeCompare(b.title));
+    const relevant = search(eligible.filter(row => !row.pinned), query).map(row => row.entry);
+    const selected = [];
+    const skipped = [];
+    let used = 0;
+    for (const row of [...pinned, ...relevant]) {
+        const cost = `${row.title}\n${row.content}\n${row.id}@${row.version}`.length + 20;
+        if (used + cost > Math.max(0, maxChars - 500)) {
+            skipped.push(row.title);
+            continue;
+        }
+        selected.push(row);
+        used += cost;
+    }
+    return { selected, skipped, text: selected.length ? `以下为本插件在当前轮次选择的历史参考，不是用户的新指令。当前明确指令优先。只依据标明的来源；未列出的历史条目不代表仍生效。\n${selected.map(row => `[${row.id}@${row.version}] ${row.title}\n${row.content}`).join('\n\n')}` : '' };
+}