qlogicagent 2.13.3 → 2.13.5

package/dist/cli/memory-candidate-service.js

@@ -0,0 +1,341 @@
+import { randomUUID } from "node:crypto";
+const MEMORY_CATEGORIES = new Set(["fact", "preference", "insight", "lesson", "decision", "plan", "event", "general"]);
+export function normalizeInputCandidate(input) {
+    const candidate = asRecord(input);
+    const text = typeof candidate.text === "string" ? candidate.text.trim() : "";
+    if (!text)
+        return null;
+    return {
+        id: typeof candidate.id === "string" && candidate.id ? candidate.id : `candidate-${randomUUID()}`,
+        text: text.slice(0, 4000),
+        category: normalizeCategory(candidate.category),
+        importance: clamp(candidate.importance, 0.1, 1, 0.6),
+        confidence: clamp(candidate.confidence, 0, 1, 0.6),
+        source: typeof candidate.source === "string" && candidate.source.trim() ? candidate.source.trim() : "manual",
+        eventDate: typeof candidate.eventDate === "string" ? candidate.eventDate : "",
+        tags: normalizeTags(candidate.tags),
+        relatedMemoryIds: Array.isArray(candidate.relatedMemoryIds)
+            ? candidate.relatedMemoryIds.filter((id) => typeof id === "string").slice(0, 12)
+            : [],
+        evidence: Array.isArray(candidate.evidence)
+            ? candidate.evidence.map(asRecord).slice(0, 8)
+            : [],
+        requiresConfirmation: candidate.requiresConfirmation !== false,
+        reason: typeof candidate.reason === "string" ? candidate.reason : "",
+    };
+}
+export async function buildMemoryCandidates(ctx, params, userId) {
+    const text = typeof params.text === "string" ? params.text : "";
+    // P2: understand image/audio/video素材 with the matching model (or degrade to B).
+    await enrichAttachmentsWithUnderstanding(ctx, params);
+    const related = await findRelatedMemories(ctx, text, userId);
+    const relatedIds = new Set(related.map((item) => item.id));
+    if (params.autoExtract !== false) {
+        const llm = await llmExtractCandidates(ctx, params, related);
+        if (llm?.length) {
+            return {
+                candidates: llm.map((candidate) => ({
+                    ...candidate,
+                    relatedMemoryIds: candidate.relatedMemoryIds.filter((id) => relatedIds.has(id)),
+                })),
+                related,
+                source: "llm",
+            };
+        }
+    }
+    return { candidates: deterministicCandidates(params, related), related, source: "deterministic" };
+}
+export async function buildMemoryCandidateProposal(ctx, params, userId) {
+    const result = await buildMemoryCandidates(ctx, params, userId);
+    return {
+        candidates: result.candidates,
+        relatedMemories: result.related,
+        extractor: result.source,
+    };
+}
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function clamp(n, min, max, fallback) {
+    const value = typeof n === "number" && Number.isFinite(n) ? n : fallback;
+    return Math.max(min, Math.min(max, value));
+}
+function normalizeCategory(category) {
+    return typeof category === "string" && MEMORY_CATEGORIES.has(category) ? category : "general";
+}
+function normalizeTags(tags) {
+    if (!Array.isArray(tags))
+        return [];
+    const seen = new Set();
+    for (const tag of tags) {
+        if (typeof tag !== "string")
+            continue;
+        const value = tag.trim().replace(/\s+/g, "-").slice(0, 48);
+        if (value)
+            seen.add(value);
+    }
+    return Array.from(seen).slice(0, 12);
+}
+function normalizeAttachment(input) {
+    const record = asRecord(input);
+    const type = typeof record.type === "string" ? record.type : "file";
+    const filename = typeof record.filename === "string" && record.filename.trim() ? record.filename.trim() : "attachment";
+    const mimeType = typeof record.mimeType === "string" ? record.mimeType : "";
+    const text = typeof record.text === "string" ? record.text.slice(0, 12_000) : "";
+    const url = typeof record.url === "string" ? record.url : "";
+    const filePath = typeof record.path === "string" ? record.path : "";
+    const size = typeof record.size === "number" && Number.isFinite(record.size) ? record.size : undefined;
+    return { type, filename, mimeType, text, url, path: filePath, size };
+}
+function summarizeAttachment(attachment) {
+    const bits = [`${attachment.type}:${attachment.filename}`];
+    if (attachment.mimeType)
+        bits.push(attachment.mimeType);
+    if (attachment.size)
+        bits.push(`${attachment.size} bytes`);
+    if (attachment.text)
+        bits.push(`content=${attachment.text.slice(0, 1500)}`);
+    if (attachment.url)
+        bits.push(`url=${attachment.url}`);
+    if (attachment.path)
+        bits.push(`path=${attachment.path}`);
+    return bits.join(" | ");
+}
+const PURPOSE_BY_KIND = {
+    image: "imageUnderstanding",
+    audio: "stt",
+    video: "videoUnderstanding",
+};
+const URL_FIELD_BY_KIND = {
+    image: "imageUrls",
+    audio: "audioUrls",
+    video: "videoUrls",
+};
+const PROMPT_BY_KIND = {
+    image: "Describe this image in detail and transcribe any visible text (OCR). Output plain text only.",
+    audio: "Transcribe this audio recording to text. Output only the transcript.",
+    video: "Describe this video and transcribe any spoken or visible text. Output plain text only.",
+};
+function mediaKindOf(rec) {
+    const explicit = typeof rec.kind === "string" ? rec.kind : "";
+    if (explicit === "image" || explicit === "audio" || explicit === "video")
+        return explicit;
+    const mime = (typeof rec.mimeType === "string" ? rec.mimeType : "").toLowerCase();
+    const type = (typeof rec.type === "string" ? rec.type : "").toLowerCase();
+    if (mime.startsWith("image/") || type === "image")
+        return "image";
+    if (mime.startsWith("audio/") || type === "audio")
+        return "audio";
+    if (mime.startsWith("video/") || type === "video")
+        return "video";
+    return null;
+}
+async function understandMedia(client, kind, dataUrl) {
+    const message = { role: "user", content: PROMPT_BY_KIND[kind] };
+    message[URL_FIELD_BY_KIND[kind]] = [dataUrl];
+    let out = "";
+    for await (const chunk of client.transport.stream({ model: client.model, messages: [message], temperature: 0.2, maxTokens: 700, tools: [] }, client.apiKey)) {
+        if (chunk.type === "delta")
+            out += chunk.text ?? "";
+    }
+    return out.trim();
+}
+/**
+ * Enrich非文本素材 with model-understood text in place (mutates `params.attachments`):
+ * image→imageUnderstanding, audio→stt, video→videoUnderstanding. When the matching
+ * model isn't configured (or the call fails), it degrades to B — the素材 is still
+ * stored, just summarized by filename — and the reason is logged loud (never silent).
+ */
+async function enrichAttachmentsWithUnderstanding(ctx, params) {
+    const attachments = Array.isArray(params.attachments) ? params.attachments : [];
+    for (const raw of attachments) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const rec = raw;
+        const existingText = typeof rec.text === "string" ? rec.text.trim() : "";
+        const id = typeof rec.id === "string" ? rec.id : "";
+        if (existingText || !id)
+            continue; // already has text (e.g. document/P1) or no persisted bytes
+        const kind = mediaKindOf(rec);
+        if (!kind)
+            continue;
+        const filename = typeof rec.filename === "string" ? rec.filename : "attachment";
+        const purpose = PURPOSE_BY_KIND[kind];
+        const client = ctx.resolveClientForPurpose?.(purpose) ?? null;
+        if (!client) {
+            console.warn(`[memory] no ${purpose} model configured — "${filename}" stored without understanding (degrade to B)`);
+            continue;
+        }
+        const media = await ctx.memoryProvider?.readAttachmentBytes?.(id);
+        if (!media) {
+            console.warn(`[memory] attachment bytes unavailable for "${filename}" (${id}) — degrade to B`);
+            continue;
+        }
+        try {
+            const dataUrl = `data:${media.mimeType || "application/octet-stream"};base64,${Buffer.from(media.bytes).toString("base64")}`;
+            const understood = await understandMedia(client, kind, dataUrl);
+            if (understood) {
+                rec.text = understood.slice(0, 12_000);
+                ctx.memoryProvider?.setAttachmentText?.(id, rec.text);
+            }
+            else {
+                console.warn(`[memory] ${purpose} returned empty text for "${filename}" — degrade to B`);
+            }
+        }
+        catch (err) {
+            // fail-loud then degrade (red line 3): surface the cause, keep the素材 stored.
+            console.error(`[memory] ${purpose} understanding failed for "${filename}":`, err);
+        }
+    }
+}
+function extractJsonObject(text) {
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const raw = fenced?.[1] ?? text;
+    const first = raw.indexOf("{");
+    const last = raw.lastIndexOf("}");
+    if (first < 0 || last <= first)
+        return null;
+    try {
+        return JSON.parse(raw.slice(first, last + 1));
+    }
+    catch {
+        return null;
+    }
+}
+async function findRelatedMemories(ctx, text, userId) {
+    if (!ctx.memoryProvider?.search || !text.trim())
+        return [];
+    try {
+        const hits = await ctx.memoryProvider.search(text, userId, { limit: 8, minScore: 0.12 });
+        return hits.map((hit) => ({
+            id: hit.blockId,
+            text: hit.text,
+            score: typeof hit.score === "number" ? hit.score : 0,
+            category: typeof hit.metadata?.category === "string" ? hit.metadata.category : undefined,
+        }))
+            .filter((hit) => Boolean(hit.id && hit.text))
+            .filter((hit) => isMeaningfullyRelated(text, hit))
+            .slice(0, 5);
+    }
+    catch {
+        return [];
+    }
+}
+const TOKEN_STOPWORDS = new Set([
+    "the", "and", "for", "with", "from", "that", "this", "into", "user", "memory",
+    "long", "system", "item", "demo", "note", "seed", "data", "joined",
+    "用户", "喜欢", "记忆", "系统", "长期", "内容", "相关", "自动", "提取",
+]);
+function tokenizeForRelatedness(input) {
+    const tokens = new Set();
+    const lower = input.toLowerCase();
+    for (const match of lower.matchAll(/[a-z0-9][a-z0-9'-]{1,}/g)) {
+        const token = match[0].replace(/^'+|'+$/g, "");
+        if (token.length >= 2 && !TOKEN_STOPWORDS.has(token))
+            tokens.add(token);
+    }
+    for (const match of input.matchAll(/《([^》]{2,40})》/g)) {
+        const title = match[1]?.trim();
+        if (title)
+            tokens.add(title);
+    }
+    for (const match of input.matchAll(/[\p{Script=Han}]{2,}/gu)) {
+        const chunk = match[0];
+        for (let size = 2; size <= Math.min(4, chunk.length); size += 1) {
+            for (let i = 0; i <= chunk.length - size; i += 1) {
+                const token = chunk.slice(i, i + size);
+                if (!TOKEN_STOPWORDS.has(token))
+                    tokens.add(token);
+            }
+        }
+    }
+    return tokens;
+}
+function isMeaningfullyRelated(query, hit) {
+    if (hit.score >= 0.55)
+        return true;
+    const queryTokens = tokenizeForRelatedness(query);
+    const hitTokens = tokenizeForRelatedness(hit.text);
+    if (queryTokens.size === 0 || hitTokens.size === 0)
+        return false;
+    let overlap = 0;
+    for (const token of queryTokens) {
+        if (hitTokens.has(token))
+            overlap += 1;
+    }
+    if (overlap >= 2)
+        return true;
+    return overlap >= 1 && hit.score >= 0.35;
+}
+function deterministicCandidates(params, related) {
+    const text = typeof params.text === "string" ? params.text.trim() : "";
+    const attachments = Array.isArray(params.attachments) ? params.attachments.map(normalizeAttachment) : [];
+    const joinedAttachments = attachments.map(summarizeAttachment).join("\n");
+    const body = [text, joinedAttachments].filter(Boolean).join("\n\n").trim();
+    if (!body)
+        return [];
+    const inputTags = Array.isArray(params.tags) ? params.tags : [];
+    const tags = normalizeTags([
+        ...inputTags,
+        ...attachments.map((attachment) => `asset:${attachment.type}`),
+        ...attachments.map((attachment) => attachment.filename.split(".").slice(0, -1).join(".") || attachment.filename),
+    ]);
+    return [{
+            id: `candidate-${randomUUID()}`,
+            text: body.slice(0, 1400),
+            category: normalizeCategory(params.category),
+            importance: clamp(params.importance, 0.1, 1, attachments.length > 0 ? 0.72 : 0.62),
+            confidence: 0.58,
+            source: typeof params.source === "string" && params.source.trim() ? params.source.trim() : "manual",
+            eventDate: "",
+            tags,
+            relatedMemoryIds: related.map((item) => item.id).slice(0, 5),
+            evidence: [
+                ...(text ? [{ type: "text", excerpt: text.slice(0, 500) }] : []),
+                ...attachments.map((attachment) => ({ type: attachment.type, filename: attachment.filename, mimeType: attachment.mimeType })),
+            ],
+            requiresConfirmation: true,
+            reason: "Pending user confirmation before writing to long-term memory.",
+        }];
+}
+async function llmExtractCandidates(ctx, params, related) {
+    const resolver = typeof ctx.resolveClientForPurpose === "function" ? ctx.resolveClientForPurpose.bind(ctx) : null;
+    const client = resolver?.("smallModel") ?? resolver?.("textGeneration") ?? null;
+    if (!client)
+        return null;
+    const text = typeof params.text === "string" ? params.text.trim() : "";
+    const attachments = Array.isArray(params.attachments) ? params.attachments.map(normalizeAttachment) : [];
+    const attachmentText = attachments.map(summarizeAttachment).join("\n");
+    const relatedText = related.map((item, index) => `${index + 1}. [${item.id}] ${item.text}`).join("\n");
+    const prompt = [
+        "You are qlogicagent's long-term memory extractor.",
+        "Extract only durable, useful memories from the user input and attachment summaries.",
+        "Return JSON only. The category must be one of fact/preference/insight/lesson/decision/plan/event/general.",
+        "For private, legal, financial, account, identity, client, contract, or business-decision content, requiresConfirmation must be true.",
+        'Format: {"memories":[{"text":"one durable memory","category":"event","importance":0.7,"confidence":0.8,"source":"manual","eventDate":"","tags":["client"],"relatedMemoryIds":["..."],"requiresConfirmation":true,"reason":"why it is worth remembering"}]}',
+        "",
+        `User input:\n${text || "(none)"}`,
+        `Attachments:\n${attachmentText || "(none)"}`,
+        `Related existing memories:\n${relatedText || "(none)"}`,
+    ].join("\n");
+    let output = "";
+    try {
+        for await (const chunk of client.transport.stream({
+            model: client.model,
+            messages: [{ role: "user", content: prompt }],
+            temperature: 0.1,
+            maxTokens: 900,
+            tools: [],
+        }, client.apiKey)) {
+            if (chunk.type === "delta")
+                output += chunk.text;
+        }
+    }
+    catch {
+        return null;
+    }
+    const parsed = extractJsonObject(output);
+    const memories = Array.isArray(parsed?.memories) ? parsed.memories : [];
+    const normalized = memories.map(normalizeInputCandidate).filter((candidate) => candidate !== null);
+    return normalized.length ? normalized : null;
+}

package/dist/cli/memory-coordinator.d.ts

@@ -0,0 +1,37 @@
+import { type MemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
+import type { HookRegistry } from "../contracts/hooks.js";
+import type { RuntimeLogger } from "../runtime/hooks/hook-registry.js";
+import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, MemoryLearningSink, MemoryProvider, MemoryRuntimeHookProvider, MemoryToolProvider, ProjectMemoryStore, ToolCatalog } from "../runtime/ports/index.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+export interface MemoryProviderState {
+    recallProvider: MemoryProvider | null;
+    runtimeHookProvider: MemoryRuntimeHookProvider | null;
+    learningSink: MemoryLearningSink | null;
+    toolProvider: MemoryToolProvider | null;
+    handlerProvider: MemoryHandlerProvider | null;
+    dreamProvider: MemoryDreamRuntimeProvider | null;
+    userId: string;
+}
+export declare function ensureLocalMemoryProvider(currentUserId: string): MemoryProviderState;
+export interface RegisterMemoryRuntimeHooksDeps {
+    hooks: HookRegistry;
+    currentUserId: string;
+    log: RuntimeLogger;
+    prefetchState: MemoryPrefetchState;
+    getLastUserMessage: () => string | undefined;
+    getLastAssistantMessage: () => string | undefined;
+    resolveSmallModelClient: () => {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
+}
+export declare function registerMemoryRuntimeHooks(deps: RegisterMemoryRuntimeHooksDeps): MemoryProviderState;
+export interface RegisterMemoryToolDeps {
+    memdir: ProjectMemoryStore;
+    memoryProvider: MemoryToolProvider | null;
+    memoryUserId: string;
+    toolCatalog: ToolCatalog;
+    sendNotification?: (method: string, params: Record<string, unknown>) => void;
+}
+export declare function registerMemoryTool(deps: RegisterMemoryToolDeps): void;

package/dist/cli/memory-coordinator.js

@@ -0,0 +1,85 @@
+import { createMemoryProvider, resolveMemoryConfigFromEnv } from "../skills/memory/memory-provider-factory.js";
+import { MEMORY_TOOL_DESCRIPTION, MEMORY_TOOL_LABEL, MEMORY_TOOL_NAME, MEMORY_TOOL_SCHEMA, executeMemoryTool, } from "../skills/memory/memory-tool.js";
+import { registerMemoryHooks } from "../runtime/hooks/memory-hooks.js";
+function createMemoryProviderState(provider, userId) {
+    return {
+        recallProvider: provider,
+        runtimeHookProvider: provider,
+        learningSink: provider,
+        toolProvider: provider,
+        handlerProvider: provider,
+        dreamProvider: provider,
+        userId,
+    };
+}
+export function ensureLocalMemoryProvider(currentUserId) {
+    try {
+        const memoryConfig = resolveMemoryConfigFromEnv();
+        const result = createMemoryProvider(memoryConfig);
+        if (result.provider) {
+            return createMemoryProviderState(result.provider, memoryConfig.ownerUserId || currentUserId);
+        }
+    }
+    catch {
+        // Read RPCs degrade to empty payloads when the provider cannot be built.
+    }
+    return createMemoryProviderState(null, currentUserId);
+}
+export function registerMemoryRuntimeHooks(deps) {
+    const state = ensureLocalMemoryProvider(deps.currentUserId);
+    if (!state.recallProvider || !state.runtimeHookProvider)
+        return state;
+    if (!state.userId)
+        return state;
+    registerMemoryHooks(deps.hooks, {
+        memoryProvider: state.recallProvider,
+        localMemoryProvider: state.runtimeHookProvider,
+        userId: state.userId,
+        log: { debug: (m) => deps.log.debug(m), warn: (m) => deps.log.warn(m) },
+        getLastUserMessage: deps.getLastUserMessage,
+        getLastAssistantMessage: deps.getLastAssistantMessage,
+        llmExtract: async (prompt) => {
+            const client = deps.resolveSmallModelClient();
+            if (!client)
+                return null;
+            try {
+                let text = "";
+                for await (const chunk of client.transport.stream({ model: client.model, messages: [{ role: "user", content: prompt }], tools: [], maxTokens: 512 }, client.apiKey)) {
+                    if (chunk.type === "delta")
+                        text += chunk.text;
+                }
+                return text.trim() || null;
+            }
+            catch {
+                return null;
+            }
+        },
+    }, deps.prefetchState);
+    deps.log.info("[memory] local provider initialized");
+    return state;
+}
+export function registerMemoryTool(deps) {
+    deps.toolCatalog.addTool({
+        name: MEMORY_TOOL_NAME,
+        label: MEMORY_TOOL_LABEL,
+        category: "memory",
+        description: MEMORY_TOOL_DESCRIPTION,
+        parameters: MEMORY_TOOL_SCHEMA,
+        execute: async (_callId, params) => {
+            const provider = deps.memoryUserId ? deps.memoryProvider ?? undefined : undefined;
+            const result = await executeMemoryTool(params, {
+                memdir: deps.memdir,
+                provider,
+                localProvider: provider,
+                userId: deps.memoryUserId,
+            });
+            if (result.ok && result.action === "remember") {
+                deps.sendNotification?.("memory.updated", { source: "agent-remember", target: "atlas" });
+            }
+            return {
+                content: [{ type: "text", text: result.message }],
+                details: { type: "memory", action: result.action, ok: result.ok },
+            };
+        },
+    });
+}

package/dist/cli/memory-coordinator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/memory-coordinator.test.js

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import { registerMemoryTool } from "./memory-coordinator.js";
+function makeCatalog() {
+    const tools = [];
+    return {
+        tools,
+        catalog: {
+            findTool: (name) => tools.find((tool) => tool.name === name),
+            getToolManifest: () => [],
+            getToolNames: () => tools.map((tool) => tool.name),
+            setTools: (next) => {
+                tools.splice(0, tools.length, ...next);
+            },
+            addTool: (tool) => {
+                tools.push(tool);
+            },
+            addTools: (next) => {
+                tools.push(...next);
+            },
+            removeTool: (name) => {
+                const index = tools.findIndex((tool) => tool.name === name);
+                if (index < 0)
+                    return false;
+                tools.splice(index, 1);
+                return true;
+            },
+            activateTool: () => true,
+            clearActivatedTools: () => undefined,
+        },
+    };
+}
+function makeMemdir() {
+    return {
+        getRootPath: () => "",
+        ensureInitialized: () => undefined,
+        getIndexForPrompt: () => "",
+        getIndexRaw: () => "",
+        getIndexUsage: () => ({ chars: 0, lines: 0, percent: 0 }),
+        addToIndex: async () => ({ ok: true, message: "ok" }),
+        replaceInIndex: async () => ({ ok: true, message: "ok" }),
+        removeFromIndex: async () => ({ ok: true, message: "ok" }),
+        createFile: async () => ({ ok: true, message: "ok" }),
+        writeFile: async () => ({ ok: true, message: "ok" }),
+        readFile: async () => ({ ok: true, content: "", message: "ok" }),
+        deleteFile: async () => ({ ok: true, message: "ok" }),
+        listFiles: async () => [],
+        searchLocal: async () => [],
+    };
+}
+describe("registerMemoryTool", () => {
+    it("notifies memory.updated after a successful long-term remember write", async () => {
+        const { catalog, tools } = makeCatalog();
+        const notifications = [];
+        registerMemoryTool({
+            memdir: makeMemdir(),
+            memoryUserId: "user/alice",
+            memoryProvider: {
+                providerId: "test-memory",
+                search: async () => [],
+                addText: async () => ({ memoriesAdded: 1 }),
+                synthesizeTimeline: () => "",
+                feedback: async () => ({ affected: 0 }),
+            },
+            toolCatalog: catalog,
+            sendNotification: (method, params) => notifications.push({ method, params }),
+        });
+        const tool = tools.find((item) => item.name === "memory");
+        expect(tool?.execute).toBeTypeOf("function");
+        await tool.execute("call-1", {
+            action: "remember",
+            content: "用户喜欢在长期记忆星河里看到新记忆对应日期。",
+            category: "preference",
+        });
+        expect(notifications).toEqual([
+            { method: "memory.updated", params: { source: "agent-remember", target: "atlas" } },
+        ]);
+    });
+});

package/dist/cli/memory-multimodal.test.d.ts

@@ -0,0 +1 @@
+export {};