qlogicagent 2.13.5 → 2.13.6

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

@@ -1,341 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

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

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

@@ -1,78 +0,0 @@
-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

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