@qvac/core 0.0.0 → 0.1.0

package/dist-lib/lib/api/index.js

@@ -0,0 +1,172 @@
+import { toAsyncIterable } from "../core/async-iterable.js";
+import { normalizeImageForModel } from "../core/image/normalize.js";
+import { detectImageMime } from "../core/image/sniff.js";
+import { createAgentsApi } from "./agents.js";
+import { createApprovalRulesApi } from "./approval-rules.js";
+import { createAttachmentsApi } from "./attachments.js";
+import { createChatApi } from "./chat.js";
+import { createChatGroupsApi } from "./chat-groups.js";
+import { createChunksApi } from "./chunks.js";
+import { createAppConfigApi } from "./app-config.js";
+import { createConfigApi } from "./config.js";
+import { createDevicesApi } from "./devices.js";
+import { createDiagnosticsApi } from "./diagnostics.js";
+import { createExecutionApi } from "./execution.js";
+import { createKnowledgeApi } from "./knowledge.js";
+import { createFilesApi } from "./files.js";
+import { createLogsApi } from "./logs.js";
+import { instrument } from "./instrument.js";
+import { watchable } from "./watchable.js";
+import { createMeshApi } from "./mesh.js";
+import { createNetworkApi } from "./network.js";
+import { createNotificationsApi } from "./notifications.js";
+import { createModelDownloadApi } from "./model-download.js";
+import { createCustomModelApi } from "./custom-models.js";
+import { createRagApi } from "./rag.js";
+import { createSyncApi } from "./sync.js";
+import { createToolActivityApi } from "./tool-activity.js";
+import { createToolConfigsApi } from "./tool-configs.js";
+import { effectiveCtxSize } from "./effective-ctx-size.js";
+export function createApi(deps = {}) {
+    const mesh = deps.mesh ?? null;
+    const retryModelDownload = deps.retryModelDownload;
+    const state = deps.state ?? null;
+    return instrument({
+        ...(state ? createConfigApi(state) : null),
+        ...(state ? createAppConfigApi(state) : null),
+        ...(state ? createModelDownloadApi(state) : null),
+        ...(state ? createCustomModelApi(state) : null),
+        ...(mesh ? createAgentsApi(mesh, deps.deviceId ?? null) : null),
+        ...(mesh ? createChatApi(mesh, deps.deviceId ?? null) : null),
+        ...(mesh ? createChatGroupsApi(mesh) : null),
+        ...(mesh ? createApprovalRulesApi(mesh) : null),
+        ...(mesh ? createChunksApi(mesh) : null),
+        ...(mesh && deps.deviceId && deps.deviceHost
+            ? createDevicesApi(mesh, deps.deviceId, deps.deviceHost.removeWriter, deps.deviceHost.renameLocal, deps.deviceHost.saveProfileLocal, deps.deviceHost.readLocalProfile)
+            : null),
+        ...(mesh ? createAttachmentsApi(mesh, { deviceId: deps.deviceId }) : null),
+        ...(mesh ? createKnowledgeApi(mesh, { deviceId: deps.deviceId }) : null),
+        ...(mesh ? createFilesApi(mesh) : null),
+        ...(mesh
+            ? createRagApi(mesh, deps.ragIndex ?? (() => null), deps.ragEmbed ?? (() => null), state
+                ? async (agent) => effectiveCtxSize(agent, (await state.getAppConfigRow())?.ctxSize ?? 0, deps.platform?.() ?? null)
+                : null)
+            : null),
+        ...(mesh && deps.deviceId ? createExecutionApi(mesh, deps.deviceId) : null),
+        ...(mesh ? createSyncApi(mesh) : null),
+        ...(mesh ? createToolConfigsApi(mesh) : null),
+        ...(mesh ? createToolActivityApi(mesh, deps.deviceId ?? null) : null),
+        ...(mesh && state
+            ? createNotificationsApi(mesh, state, {
+                deviceId: deps.deviceId,
+                lifetime: deps.notificationLifetime,
+                changes: deps.meshStatus ?? undefined
+            })
+            : null),
+        ...(deps.meshStatus ? createMeshApi(deps.meshStatus) : null),
+        ...(deps.network ? createNetworkApi(deps.network) : null),
+        ...(deps.diagnostics ? createDiagnosticsApi(deps.diagnostics) : null),
+        ...(deps.logs ? createLogsApi(deps.logs) : null),
+        ...(deps.lifecycle
+            ? {
+                suspend: async () => {
+                    await deps.lifecycle?.suspend();
+                    return { ok: true };
+                },
+                resume: async () => {
+                    await deps.lifecycle?.resume();
+                    return { ok: true };
+                }
+            }
+            : null),
+        transcodeImage,
+        ...(deps.listModels ? { listModels: deps.listModels } : null),
+        ...(deps.deleteModel ? { deleteModel: deps.deleteModel } : null),
+        ...(deps.clearKvCache ? { clearKvCache: deps.clearKvCache } : null),
+        ...(deps.deleteChatKvCache
+            ? { deleteChatKvCache: ({ id }) => deps.deleteChatKvCache(id) }
+            : null),
+        ...(deps.compactChat
+            ? { compactChat: ({ id }) => deps.compactChat(id) }
+            : null),
+        ...(deps.modelCatalogWatch ? { modelCatalogWatch: deps.modelCatalogWatch } : null),
+        ...(retryModelDownload
+            ? {
+                retryModelDownload: async (request) => {
+                    await retryModelDownload(request);
+                    return { ok: true };
+                }
+            }
+            : null),
+        ...(deps.pushSkillSecret
+            ? {
+                pushSkillSecret: async (request) => {
+                    await deps.pushSkillSecret?.(request);
+                    return { ok: true };
+                }
+            }
+            : null),
+        ...(deps.transcribe ? { transcribe: deps.transcribe } : null),
+        ...(deps.speak ? { speak: deps.speak } : null),
+        ...(deps.speakStream
+            ? {
+                speakStream: async function* (stream) {
+                    const text = (async function* () {
+                        for await (const frame of toAsyncIterable(stream))
+                            if (frame.text)
+                                yield frame.text;
+                    })();
+                    yield* deps.speakStream(text);
+                }
+            }
+            : null),
+        ...(deps.skills
+            ? {
+                skills: async (req) => ({
+                    skills: await deps.skills?.(req?.agentId, req?.modelName, {
+                        refresh: req?.refresh === true
+                    })
+                })
+            }
+            : null),
+        ...(deps.skillCatalog
+            ? {
+                skillCatalog: async (req) => deps.skillCatalog?.(req?.agentId, req?.modelName, {
+                    refresh: req?.refresh === true
+                }) ?? Promise.resolve({ skills: [] })
+            }
+            : null),
+        ...(deps.listManagedSkills
+            ? {
+                listManagedSkills: async (req) => deps.listManagedSkills(req?.agentId)
+            }
+            : null),
+        ...(deps.readSkillFile
+            ? {
+                readSkillFile: async (req) => deps.readSkillFile(req?.name, req?.agentId)
+            }
+            : null),
+        ...(deps.writeSkillFile
+            ? {
+                writeSkillFile: async (req) => deps.writeSkillFile(req?.name, req?.content, req?.agentId)
+            }
+            : null),
+        ...(deps.copySkillForEdit
+            ? {
+                copySkillForEdit: async (req) => deps.copySkillForEdit(req?.name, req?.agentId)
+            }
+            : null),
+        ...(deps.deleteOverlaySkill
+            ? {
+                deleteOverlaySkill: async (req) => deps.deleteOverlaySkill(req?.name, req?.agentId)
+            }
+            : null),
+        ...(deps.tools ? { tools: deps.tools } : null)
+    });
+}
+async function transcodeImage(request) {
+    const normalized = await normalizeImageForModel(request.bytes);
+    if (normalized === request.bytes || detectImageMime(normalized) !== 'image/jpeg')
+        return {};
+    return { bytes: normalized };
+}

package/dist-lib/lib/api/instrument.d.ts

@@ -0,0 +1,2 @@
+import '../logger.ts';
+export declare function instrument<T extends object>(handlers: T): T;

package/dist-lib/lib/api/instrument.js

@@ -0,0 +1,86 @@
+import b4a from 'b4a';
+import "../logger.js";
+const SCOPE = ['api'];
+const MAX_STRING = 40;
+export function instrument(handlers) {
+    const out = {};
+    for (const [name, handler] of Object.entries(handlers)) {
+        out[name] = typeof handler === 'function' ? wrap(name, handler) : handler;
+    }
+    return out;
+}
+function wrap(name, handler) {
+    return function (...args) {
+        const started = Date.now();
+        const request = summarize(args[0]);
+        let result;
+        try {
+            result = handler.apply(this, args);
+        }
+        catch (err) {
+            logger.debug(SCOPE, `${name} failed`, { request, ms: Date.now() - started, err: reason(err) });
+            throw err;
+        }
+        if (isStream(result)) {
+            logger.debug(SCOPE, `${name} opened`, { request });
+            return result;
+        }
+        if (isPromise(result)) {
+            return result.then((value) => {
+                logger.debug(SCOPE, name, { request, ms: Date.now() - started, ...count(value) });
+                return value;
+            }, (err) => {
+                logger.debug(SCOPE, `${name} failed`, {
+                    request,
+                    ms: Date.now() - started,
+                    err: reason(err)
+                });
+                throw err;
+            });
+        }
+        logger.debug(SCOPE, name, { request, ms: Date.now() - started, ...count(result) });
+        return result;
+    };
+}
+function isPromise(value) {
+    return isRecord(value) && typeof value.then === 'function';
+}
+function isStream(value) {
+    return isRecord(value) && typeof value[Symbol.asyncIterator] === 'function';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function count(value) {
+    if (!isRecord(value))
+        return null;
+    for (const field of Object.values(value)) {
+        if (Array.isArray(field))
+            return { n: field.length };
+    }
+    return null;
+}
+function summarize(request) {
+    if (!isRecord(request))
+        return '';
+    return Object.entries(request)
+        .map(([key, value]) => `${key}=${scalar(value)}`)
+        .join(' ');
+}
+function scalar(value) {
+    if (value === null || value === undefined)
+        return String(value);
+    if (b4a.isBuffer(value))
+        return `<${value.byteLength}b>`;
+    if (Array.isArray(value))
+        return `[${value.length}]`;
+    if (typeof value === 'string') {
+        return value.length > MAX_STRING ? `<str:${value.length}>` : value;
+    }
+    if (typeof value === 'object')
+        return '{}';
+    return String(value);
+}
+function reason(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist-lib/lib/api/knowledge.d.ts

@@ -0,0 +1,8 @@
+import type { CapabilityHandlers } from '../../spec/capabilities.d.ts';
+import { type CurrentMesh } from './current-mesh.ts';
+export { MAX_KNOWLEDGE_BYTES } from '../core/files/knowledge.ts';
+export declare function createKnowledgeApi(current: CurrentMesh, options?: {
+    maxBytes?: number;
+    inactivityMs?: number;
+    deviceId?: Buffer | null;
+}): Pick<CapabilityHandlers, 'uploadKnowledge' | 'downloadKnowledge' | 'removeKnowledge' | 'listKnowledge' | 'knowledgeWatch' | 'listIndexing' | 'indexingWatch' | 'fileStatusWatch' | 'indexingProgressWatch'>;

package/dist-lib/lib/api/knowledge.js

@@ -0,0 +1,26 @@
+import { requireMesh } from "./current-mesh.js";
+import { watchable } from "./watchable.js";
+export { MAX_KNOWLEDGE_BYTES } from "../core/files/knowledge.js";
+export function createKnowledgeApi(current, options = {}) {
+    return {
+        async *uploadKnowledge(frames) {
+            yield* (await requireMesh(current)).files.knowledge(options).uploadKnowledge(frames);
+        },
+        async *downloadKnowledge(request) {
+            yield* (await requireMesh(current)).files.knowledge(options).downloadKnowledge(request);
+        },
+        async removeKnowledge(request) {
+            return (await requireMesh(current)).files.knowledge(options).removeKnowledge(request);
+        },
+        async listKnowledge(request) {
+            return (await requireMesh(current)).files.knowledge(options).listKnowledge(request);
+        },
+        async listIndexing(request) {
+            return (await requireMesh(current)).files.knowledge(options).listIndexing(request);
+        },
+        knowledgeWatch: watchable('knowledgeWatch', () => requireMesh(current), async (request, mesh) => mesh.files.knowledge(options).listKnowledge(request)),
+        indexingWatch: watchable('indexingWatch', async () => (await requireMesh(current)).files, ({ chatId }, files) => files.listIndexing(chatId)),
+        fileStatusWatch: watchable('fileStatusWatch', async () => (await requireMesh(current)).files, ({ chatId }, files) => files.status(chatId)),
+        indexingProgressWatch: watchable('indexingProgressWatch', async () => (await requireMesh(current)).files, ({ chatId }, files) => Promise.resolve({ entries: files.progress(chatId) }))
+    };
+}

package/dist-lib/lib/api/logs.d.ts

@@ -0,0 +1,14 @@
+import type { CapabilityHandlers } from '../../spec/capabilities.d.ts';
+import type { LogLevel, LogRecord } from '../log.ts';
+export interface LogSource {
+    backfill(): ReadonlyArray<LogRecord>;
+    subscribe(listener: (record: LogRecord) => void): void;
+    unsubscribe(listener: (record: LogRecord) => void): void;
+    write(input: {
+        level: LogLevel;
+        scope: ReadonlyArray<string>;
+        message: string;
+        at: number;
+    }): void;
+}
+export declare function createLogsApi(source: LogSource): Pick<CapabilityHandlers, 'logsWatch' | 'writeLog'>;

package/dist-lib/lib/api/logs.js

@@ -0,0 +1,116 @@
+import { Readable } from 'streamx';
+import { LEVELS } from "../log-levels.js";
+const MAX_LIVE_QUEUE = 1000;
+export function createLogsApi(source) {
+    return {
+        logsWatch: (request) => logStream(source, request),
+        writeLog: (request) => {
+            source.write({
+                level: request.level,
+                scope: request.scope ?? [],
+                message: request.message,
+                at: request.at
+            });
+            return { ok: true };
+        }
+    };
+}
+function logStream(source, request) {
+    const matches = makeFilter(request);
+    const queue = [];
+    let dropped = 0;
+    let droppedSeq = 0;
+    let backfill = null;
+    let wake = null;
+    const onRecord = (record) => {
+        if (!matches(record))
+            return;
+        if (queue.length >= MAX_LIVE_QUEUE) {
+            droppedSeq = queue.shift().seq;
+            dropped++;
+        }
+        queue.push(toLine(record));
+        wake?.resolve();
+        wake = null;
+    };
+    const stream = new Readable({
+        open(cb) {
+            source.subscribe(onRecord);
+            const history = source.backfill().filter(matches);
+            backfill = request.backfill ? history.slice(-request.backfill).map(toLine) : [];
+            cb(null);
+        },
+        async read(cb) {
+            try {
+                if (backfill) {
+                    const initial = backfill;
+                    backfill = null;
+                    if (initial.length) {
+                        stream.push({ lines: initial });
+                        return cb(null);
+                    }
+                }
+                while (!stream.destroying) {
+                    if (queue.length === 0) {
+                        wake = Promise.withResolvers();
+                        await wake.promise;
+                        continue;
+                    }
+                    const lines = queue.splice(0);
+                    if (dropped > 0) {
+                        lines.unshift(droppedMarker(dropped, droppedSeq));
+                        dropped = 0;
+                    }
+                    stream.push({ lines });
+                    break;
+                }
+                cb(null);
+            }
+            catch (err) {
+                cb(err);
+            }
+        },
+        predestroy() {
+            wake?.resolve();
+            wake = null;
+        },
+        destroy(cb) {
+            source.unsubscribe(onRecord);
+            cb(null);
+        }
+    });
+    return stream;
+}
+function makeFilter(request) {
+    const minLevel = request.level ? LEVELS[request.level] : 0;
+    const scope = request.scope ?? [];
+    const origin = request.origin ?? null;
+    return (record) => {
+        if (LEVELS[record.level] < minLevel)
+            return false;
+        if (origin && record.origin !== origin)
+            return false;
+        return scope.every((s) => record.scope.includes(s));
+    };
+}
+function toLine(record) {
+    return {
+        seq: record.seq,
+        at: record.at,
+        level: record.level,
+        scope: [...record.scope],
+        message: record.message,
+        origin: record.origin,
+        originDeviceId: record.originDeviceId
+    };
+}
+function droppedMarker(count, seq) {
+    return {
+        seq,
+        at: Date.now(),
+        level: 'warn',
+        scope: ['logs'],
+        message: `dropped ${count} log lines (slow reader)`,
+        origin: 'core'
+    };
+}

package/dist-lib/lib/api/mesh.d.ts

@@ -0,0 +1,13 @@
+import type { AssistantMeshStatus } from '../../spec/hyperschema/types.d.ts';
+import type { CapabilityHandlers } from '../../spec/capabilities.d.ts';
+export interface MeshStatusSource {
+    watch(listener: () => void): void;
+    unwatch(listener: () => void): void;
+    snapshot(): AssistantMeshStatus;
+    leave(): Promise<void>;
+    acknowledgeKicked(): void;
+    join(invite: string): Promise<void>;
+    cancelJoin(): void;
+    invite(): Promise<string | null>;
+}
+export declare function createMeshApi(status: MeshStatusSource): Pick<CapabilityHandlers, 'meshStatusWatch' | 'leaveMesh' | 'acknowledgeKicked' | 'joinMesh' | 'cancelMeshJoin' | 'meshInvite'>;

package/dist-lib/lib/api/mesh.js

@@ -0,0 +1,25 @@
+import { watchable } from "./watchable.js";
+export function createMeshApi(status) {
+    return {
+        meshStatusWatch: watchable('meshStatusWatch', () => status, async () => status.snapshot()),
+        leaveMesh: async () => {
+            await status.leave();
+            return { ok: true };
+        },
+        acknowledgeKicked: async () => {
+            status.acknowledgeKicked();
+            return { ok: true };
+        },
+        joinMesh: async ({ invite }) => {
+            await status.join(invite);
+            return { ok: true };
+        },
+        cancelMeshJoin: async () => {
+            status.cancelJoin();
+            return { ok: true };
+        },
+        meshInvite: async () => ({
+            invite: (await status.invite()) ?? undefined
+        })
+    };
+}

package/dist-lib/lib/api/model-download.d.ts

@@ -0,0 +1,5 @@
+import type { openLocalStore } from '../core/local/index.ts';
+import type { CapabilityHandlers } from '../../spec/capabilities.d.ts';
+type LocalStore = Awaited<ReturnType<typeof openLocalStore>>;
+export declare function createModelDownloadApi(state: LocalStore): Pick<CapabilityHandlers, 'modelDownloadsWatch' | 'setModelDownloadStatus' | 'clearModelDownload' | 'beginModelTransfer' | 'completeModelTransfer'>;
+export {};

package/dist-lib/lib/api/model-download.js

@@ -0,0 +1,47 @@
+import { watchable } from "./watchable.js";
+async function readDownloads(state) {
+    const rows = await state.getModelDownloadRows();
+    return {
+        downloads: rows.map((row) => ({
+            name: row.name,
+            phase: row.phase,
+            percentage: row.percentage ?? 0,
+            error: row.error ?? null,
+            updatedAt: row.updatedAt,
+            downloaded: row.downloaded ?? 0,
+            total: row.total ?? 0,
+            bytesPerSecond: row.bytesPerSecond ?? 0
+        }))
+    };
+}
+export function createModelDownloadApi(state) {
+    return {
+        beginModelTransfer: async ({ name, transferred }) => {
+            const { transferId } = await state.beginModelTransfer(name, { transferred });
+            return { name, transferId };
+        },
+        completeModelTransfer: async (request) => {
+            await state.completeModelTransfer(request);
+            return { ok: true };
+        },
+        modelDownloadsWatch: watchable('modelDownloadsWatch', () => state, () => readDownloads(state)),
+        setModelDownloadStatus: async (input) => {
+            const row = {
+                name: input.name,
+                phase: input.phase,
+                percentage: input.percentage ?? 0,
+                error: input.error ?? null,
+                updatedAt: Date.now(),
+                downloaded: input.downloaded ?? 0,
+                total: input.total ?? 0,
+                bytesPerSecond: input.bytesPerSecond ?? 0
+            };
+            await state.putModelDownloadRow(row);
+            return { ok: true };
+        },
+        clearModelDownload: async ({ name }) => {
+            await state.deleteModelDownloadRow(name);
+            return { ok: true };
+        }
+    };
+}

package/dist-lib/lib/api/network.d.ts

@@ -0,0 +1,8 @@
+import type { AssistantNetworkStatus } from '../../spec/hyperschema/types.d.ts';
+import type { CapabilityHandlers } from '../../spec/capabilities.d.ts';
+export interface NetworkSource {
+    watch(listener: () => void): void;
+    unwatch(listener: () => void): void;
+    snapshot(): AssistantNetworkStatus;
+}
+export declare function createNetworkApi(source: NetworkSource): Pick<CapabilityHandlers, 'networkWatch'>;

package/dist-lib/lib/api/network.js

@@ -0,0 +1,6 @@
+import { watchable } from "./watchable.js";
+export function createNetworkApi(source) {
+    return {
+        networkWatch: watchable('networkWatch', () => source, async () => source.snapshot())
+    };
+}

package/dist-lib/lib/api/notifications.d.ts

@@ -0,0 +1,21 @@
+import type { CapabilityHandlers } from '../../spec/capabilities.d.ts';
+import type { openLocalStore } from '../core/local/index.ts';
+import { type CurrentMesh } from './current-mesh.ts';
+type LocalStore = Awaited<ReturnType<typeof openLocalStore>>;
+type NotificationCapabilities = Pick<CapabilityHandlers, 'notificationsWatch' | 'ackNotification'>;
+export interface NotificationLifetime {
+    once(event: 'close', listener: () => void): unknown;
+    off(event: 'close', listener: () => void): unknown;
+    readonly closing: unknown;
+    readonly closed: boolean;
+}
+interface NotificationOptions {
+    readonly deviceId?: Buffer | null;
+    readonly lifetime?: NotificationLifetime;
+    readonly changes?: {
+        watch(listener: () => void): void;
+        unwatch(listener: () => void): void;
+    };
+}
+export declare function createNotificationsApi(current: CurrentMesh, local: LocalStore, options?: NotificationOptions): NotificationCapabilities;
+export {};

package/dist-lib/lib/api/notifications.js

@@ -0,0 +1,108 @@
+import { deriveNotifications } from "../core/notification.js";
+import { requireMesh } from "./current-mesh.js";
+import { watchable } from "./watchable.js";
+export function createNotificationsApi(current, local, options = {}) {
+    return {
+        notificationsWatch: watchable('notificationsWatch', () => notificationSource(current, local, options), (request) => notificationSnapshot(current, local, request?.limit, options.deviceId)),
+        ackNotification: async ({ chatId, seq, notificationId }) => {
+            if (notificationId) {
+                if ((chatId !== undefined && chatId !== null) || (seq ?? 0) !== 0) {
+                    throw new Error('notification acknowledgement must select one source');
+                }
+                await local.ackModelNotification(notificationId);
+            }
+            else {
+                if (!chatId || seq === undefined || seq === null) {
+                    throw new Error('chat acknowledgement requires chatId and seq');
+                }
+                await requireMesh(current);
+                await local.ackChatNotify(chatId, seq);
+            }
+            return { ok: true };
+        }
+    };
+}
+function notificationSource(current, local, options) {
+    let mesh = null;
+    let generation = 0;
+    let watching = false;
+    let listener = null;
+    const notify = () => listener?.();
+    const detach = () => {
+        mesh?.unwatch(notify);
+        mesh?.off('close', changed);
+        mesh = null;
+    };
+    const changed = () => {
+        const version = ++generation;
+        detach();
+        notify();
+        void Promise.resolve(current())
+            .then((next) => {
+            if (!watching || version !== generation || next?.closing || next?.closed)
+                return;
+            mesh = next;
+            mesh?.watch(notify);
+            mesh?.once('close', changed);
+            notify();
+        })
+            .catch(notify);
+    };
+    return {
+        watch(onChange) {
+            listener = onChange;
+            watching = true;
+            local.watch(notify);
+            options.changes?.watch(changed);
+            changed();
+        },
+        unwatch() {
+            watching = false;
+            generation++;
+            detach();
+            local.unwatch(notify);
+            options.changes?.unwatch(changed);
+            listener = null;
+        },
+        once: (event, onClose) => options.lifetime?.once(event, onClose),
+        off: (event, onClose) => options.lifetime?.off(event, onClose),
+        get closing() {
+            return options.lifetime?.closing;
+        },
+        get closed() {
+            return options.lifetime?.closed ?? false;
+        }
+    };
+}
+async function notificationSnapshot(current, local, requestedLimit, deviceId) {
+    const mesh = await current();
+    let chats = { notifications: [] };
+    if (mesh && !mesh.closing && !mesh.closed) {
+        try {
+            chats = await deriveNotifications(mesh, local, Number.MAX_SAFE_INTEGER, deviceId);
+        }
+        catch (error) {
+            if (mesh === (await current()) && !mesh.closing && !mesh.closed)
+                throw error;
+        }
+    }
+    const models = await local.getModelNotifications();
+    if (mesh !== (await current()) || mesh?.closing || mesh?.closed)
+        chats = { notifications: [] };
+    const notifications = [
+        ...(chats.notifications ?? []),
+        ...models
+            .filter((row) => row.notificationId && !row.acknowledged)
+            .map((row) => ({
+            kind: 'model-downloaded',
+            notificationId: row.notificationId,
+            modelName: row.name,
+            createdAt: row.completedAt
+        }))
+    ].sort((left, right) => right.createdAt - left.createdAt || (right.seq ?? 0) - (left.seq ?? 0));
+    const limit = requestedLimit || 200;
+    return {
+        notifications: notifications.slice(0, limit),
+        truncated: notifications.length > limit || undefined
+    };
+}