@qvac/core 0.0.0 → 0.1.1

package/dist-lib/lib/core/chat-group.js

@@ -0,0 +1,79 @@
+import { randomId } from "./id.js";
+const CHAT_GROUPS = '@qvac/chat-groups';
+const ACTIVE_CHAT_GROUPS = '@qvac/active-chat-groups';
+const NAME_MAX_LENGTH = 100;
+export function byGroupOrder(a, b) {
+    return b.createdAt - a.createdAt || (a.id < b.id ? -1 : 1);
+}
+export async function listChatGroupsIn(snap) {
+    const groups = await snap.find(ACTIVE_CHAT_GROUPS).toArray();
+    return groups.sort(byGroupOrder);
+}
+export async function listChatGroups(store) {
+    const snap = store.view.snapshot();
+    try {
+        return await listChatGroupsIn(snap);
+    }
+    finally {
+        await snap.close();
+    }
+}
+export async function getChatGroup(store, id) {
+    const snap = store.view.snapshot();
+    try {
+        const group = await snap.get(CHAT_GROUPS, { id });
+        return group;
+    }
+    finally {
+        await snap.close();
+    }
+}
+export async function mustGetChatGroup(store, id) {
+    const group = await getChatGroup(store, id);
+    if (!group)
+        throw new Error(`chat group not found: ${id}`);
+    return group;
+}
+export async function mustGetActiveChatGroup(store, id) {
+    const group = await mustGetChatGroup(store, id);
+    if (group.deletedAt)
+        throw new Error(`chat group not found: ${id}`);
+    return group;
+}
+function assertGroupName(name) {
+    const trimmed = name.trim();
+    if (!trimmed)
+        throw new Error('chat group name is required');
+    if (trimmed.length > NAME_MAX_LENGTH) {
+        throw new Error(`chat group name exceeds ${NAME_MAX_LENGTH} characters`);
+    }
+    return trimmed;
+}
+export async function createChatGroup(store, input) {
+    const now = Date.now();
+    const group = {
+        id: randomId(),
+        name: assertGroupName(input.name),
+        createdAt: now,
+        updatedAt: now,
+        deletedAt: undefined
+    };
+    await store.dispatch('put-chat-group', { group });
+    return group;
+}
+async function patchChatGroup(store, id, patch) {
+    const current = await mustGetActiveChatGroup(store, id);
+    const updated = { ...current, ...patch, updatedAt: Date.now() };
+    await store.dispatch('put-chat-group', { group: updated });
+    return updated;
+}
+export async function renameChatGroup(store, id, name) {
+    return patchChatGroup(store, id, { name: assertGroupName(name) });
+}
+export async function deleteChatGroup(store, id) {
+    const current = await mustGetChatGroup(store, id);
+    const now = Date.now();
+    const deleted = { ...current, deletedAt: now, updatedAt: now };
+    await store.dispatch('put-chat-group', { group: deleted });
+    return deleted;
+}

package/dist-lib/lib/core/chat-search.d.ts

@@ -0,0 +1,17 @@
+import type { AbortSignal } from 'bare-abort-controller';
+import { type ChatListing } from './chat.ts';
+import type { Mesh } from './mesh.ts';
+export type ChatSearchMatch = 'title' | 'content';
+export type ChatSearchHit = {
+    readonly chat: ChatListing;
+    readonly match: ChatSearchMatch;
+    readonly snippet: string;
+    readonly chunkId: string;
+    readonly runId: string;
+};
+export type ChatSearchInput = {
+    readonly query: string;
+    readonly limit?: number;
+    readonly signal?: AbortSignal;
+};
+export declare function searchChats(store: Mesh, input: ChatSearchInput): Promise<ReadonlyArray<ChatSearchHit>>;

package/dist-lib/lib/core/chat-search.js

@@ -0,0 +1,199 @@
+import { diagramRepairAccepted, diagramRepairLinks, isDiagramRepairPrompt } from '@qvac/harness/lib/diagram-repair.ts';
+import { chunkTypeOrdinal } from '../../schema/helpers.js';
+import { enrichAll, lastActivity, liveGroupIds } from "./chat.js";
+import { foldSearchText } from "./search-fold.js";
+const ACTIVE_CHATS = '@qvac/active-chats';
+const CHUNKS_BY_TYPE = '@qvac/chunks-by-type';
+const DEFAULT_LIMIT = 100;
+const PER_CHAT_LIMIT = 20;
+const SNIPPET_PAD = 40;
+export async function searchChats(store, input) {
+    const needle = foldSearchText(input.query.trim());
+    if (!needle)
+        return [];
+    const limit = input.limit || DEFAULT_LIMIT;
+    const snap = store.view.snapshot();
+    try {
+        const rows = sortChatsNewestFirst(await snap.find(ACTIVE_CHATS).toArray());
+        const [activity, groups] = await Promise.all([lastActivity(snap), liveGroupIds(snap)]);
+        const chats = enrichAll(rows, activity, groups);
+        const titled = [];
+        const untitled = [];
+        for (const chat of chats) {
+            if (foldSearchText(chat.title).includes(needle))
+                titled.push(chat);
+            else
+                untitled.push(chat);
+        }
+        const hits = [];
+        for (const chat of titled) {
+            hits.push(titleHit(chat));
+            if (hits.length >= limit)
+                return hits;
+        }
+        for (const chat of [...titled, ...untitled]) {
+            if (input.signal?.aborted)
+                break;
+            hits.push(...(await contentHits(snap, chat, needle, remainingCap(hits.length, limit))));
+            if (hits.length >= limit)
+                break;
+        }
+        return hits;
+    }
+    finally {
+        await snap.close();
+    }
+}
+function remainingCap(used, limit) {
+    return Math.min(PER_CHAT_LIMIT, limit - used);
+}
+function titleHit(chat) {
+    return { chat, match: 'title', snippet: '', chunkId: '', runId: '' };
+}
+async function contentHits(snap, chat, needle, cap) {
+    if (cap <= 0)
+        return [];
+    const [users, content, attachments, requests, statuses] = await Promise.all([
+        chunksOfType(snap, chat.id, 'user-message'),
+        chunksOfType(snap, chat.id, 'content'),
+        chunksOfType(snap, chat.id, 'attachment'),
+        chunksOfType(snap, chat.id, 'run-request'),
+        chunksOfType(snap, chat.id, 'run-status')
+    ]);
+    const repairs = diagramRepairLinks([...users, ...requests], (chunk) => {
+        return chunk.userMessage?.text ?? null;
+    });
+    const hiddenPromptIds = new Set(users.filter((user) => isDiagramRepairPrompt(user.userMessage?.text ?? '')).map((u) => u.id));
+    const repairText = (target) => content
+        .filter((chunk) => chunk.runId === target)
+        .map((chunk) => chunk.content?.text ?? '')
+        .join('');
+    const completedRunIds = new Set(statuses
+        .filter((status) => status.runStatus?.state === 'completed' && status.runId)
+        .map((status) => status.runId));
+    const hiddenRunIds = new Set();
+    const redactedRunIds = new Set();
+    for (const repair of repairs) {
+        const parentRunId = requests.find((request) => request.id === repair.parentId)?.runId;
+        if (completedRunIds.has(repair.runId) && diagramRepairAccepted(repairText(repair.runId))) {
+            if (parentRunId)
+                hiddenRunIds.add(parentRunId);
+        }
+        else {
+            hiddenRunIds.add(repair.runId);
+            if (parentRunId)
+                redactedRunIds.add(parentRunId);
+        }
+    }
+    const matches = [
+        ...matchUserMessages(users, needle, cap, hiddenPromptIds),
+        ...matchJoinedContent(content, needle, cap, { hidden: hiddenRunIds, redacted: redactedRunIds }),
+        ...matchAttachments(attachments, needle, cap)
+    ];
+    return matches
+        .sort((left, right) => left.seq - right.seq)
+        .slice(0, cap)
+        .map((found) => ({
+        chat,
+        match: 'content',
+        snippet: found.snippet,
+        chunkId: found.chunkId,
+        runId: found.runId
+    }));
+}
+async function chunksOfType(snap, chatId, type) {
+    const ordinal = chunkTypeOrdinal(type);
+    return snap
+        .find(CHUNKS_BY_TYPE, {
+        gte: { chatId, type: ordinal },
+        lte: { chatId, type: ordinal }
+    })
+        .toArray();
+}
+function matchUserMessages(chunks, needle, cap, hiddenIds) {
+    const matches = [];
+    for (const chunk of chunks) {
+        if (matches.length >= cap)
+            break;
+        const text = chunk.userMessage?.text;
+        if (!text || hiddenIds.has(chunk.id))
+            continue;
+        const found = locate(text, needle);
+        if (!found)
+            continue;
+        matches.push({ seq: chunk.seq, snippet: found, chunkId: chunk.id, runId: chunk.runId ?? '' });
+    }
+    return matches;
+}
+function matchJoinedContent(chunks, needle, cap, runs) {
+    const byRun = new Map();
+    const order = [];
+    for (const chunk of chunks) {
+        const runId = chunk.runId;
+        if (!runId || runs.hidden.has(runId))
+            continue;
+        const group = byRun.get(runId);
+        if (group) {
+            group.push(chunk);
+            continue;
+        }
+        byRun.set(runId, [chunk]);
+        order.push(runId);
+    }
+    const matches = [];
+    for (const runId of order) {
+        if (matches.length >= cap)
+            break;
+        const group = byRun.get(runId);
+        const first = group?.[0];
+        if (!group || !first)
+            continue;
+        const content = group.map((chunk) => chunk.content?.text ?? '').join('');
+        const text = runs.redacted.has(runId) ? withoutMermaidDiagrams(content) : content;
+        const found = locate(text, needle);
+        if (!found)
+            continue;
+        matches.push({ seq: first.seq, snippet: found, chunkId: first.id, runId });
+    }
+    return matches;
+}
+function withoutMermaidDiagrams(content) {
+    return content.replace(/^[ \t]{0,3}(`{3,}|~{3,})[ \t]*mermaid[ \t]*\r?\n[\s\S]*?(?:^[ \t]{0,3}\1[ \t]*$|(?![\s\S]))/gm, '');
+}
+function matchAttachments(chunks, needle, cap) {
+    const matches = [];
+    for (const chunk of chunks) {
+        if (matches.length >= cap)
+            break;
+        const attachment = chunk.attachment;
+        if (!attachment || (attachment.deletedAt ?? 0) > 0)
+            continue;
+        const found = locate(attachment.fileName, needle);
+        if (!found)
+            continue;
+        matches.push({ seq: chunk.seq, snippet: found, chunkId: chunk.id, runId: chunk.runId ?? '' });
+    }
+    return matches;
+}
+function locate(text, needle) {
+    if (!text)
+        return null;
+    const index = foldSearchText(text).indexOf(needle);
+    if (index < 0)
+        return null;
+    return snippetAround(text, index, needle.length);
+}
+function snippetAround(text, index, needleLength) {
+    const start = Math.max(0, index - SNIPPET_PAD);
+    const end = Math.min(text.length, index + needleLength + SNIPPET_PAD);
+    const body = text.slice(start, end).replace(/\s+/g, ' ').trim();
+    const prefix = start > 0 ? '...' : '';
+    const suffix = end < text.length ? '...' : '';
+    return `${prefix}${body}${suffix}`;
+}
+function sortChatsNewestFirst(chats) {
+    return [...chats].sort((left, right) => chatRecency(right) - chatRecency(left));
+}
+function chatRecency(chat) {
+    return chat.updatedAt || chat.createdAt;
+}

package/dist-lib/lib/core/chat.d.ts

@@ -0,0 +1,37 @@
+import type HyperDB from 'hyperdb';
+import type { QvacChat, QvacChatGroup } from '../../spec/mesh/hyperschema/types.d.ts';
+import type { Mesh } from './mesh.ts';
+export interface ChatListing extends QvacChat {
+    readonly lastActivityAt: number;
+}
+export interface Sidebar {
+    readonly chats: ChatListing[];
+    readonly groups: QvacChatGroup[];
+}
+export declare function liveGroupIds(snap: HyperDB): Promise<Set<string>>;
+export declare function lastActivity(snap: HyperDB): Promise<Map<string, number>>;
+export declare function enrichChat(store: Mesh, chat: QvacChat): Promise<ChatListing>;
+export declare function enrichIn(snap: HyperDB, chat: QvacChat): Promise<ChatListing>;
+export declare function enrichAll(chats: ReadonlyArray<QvacChat>, activity: Map<string, number>, liveGroups: Set<string>): ChatListing[];
+export declare function listSidebar(store: Mesh): Promise<Sidebar>;
+export declare function listChats(store: Mesh): Promise<ChatListing[]>;
+export declare function getChat(store: Mesh, id: string): Promise<QvacChat | null>;
+export declare function mustGetChat(store: Mesh, id: string): Promise<QvacChat>;
+export declare function mustGetActiveChat(store: Mesh, id: string): Promise<QvacChat>;
+export declare function mustGetActiveChatListing(store: Mesh, id: string): Promise<ChatListing>;
+export declare function buildChat(input: {
+    agentId: string;
+    title: string;
+}): QvacChat;
+export declare function createChat(store: Mesh, input: {
+    agentId: string;
+    title: string;
+}): Promise<ChatListing>;
+export declare function renameChat(store: Mesh, id: string, title: string): Promise<ChatListing>;
+export declare function setChatRagEnabled(store: Mesh, id: string, ragEnabled: boolean): Promise<ChatListing>;
+export declare function setChatGroup(store: Mesh, id: string, groupId: string | null | undefined): Promise<ChatListing>;
+export declare function setChatWebSearchEnabled(store: Mesh, id: string, webSearchEnabled: boolean): Promise<ChatListing>;
+export declare function removeChatKnowledge(store: Mesh, chatId: string, at: number): Promise<void>;
+export declare function removeChatAttachments(store: Mesh, deviceId: Buffer, chatId: string, at: number): Promise<void>;
+export declare function deleteChat(store: Mesh, deviceId: Buffer | null, id: string): Promise<ChatListing>;
+export declare function softDeleteChatsForAgent(store: Mesh, deviceId: Buffer | null, agentId: string): Promise<void>;

package/dist-lib/lib/core/chat.js

@@ -0,0 +1,196 @@
+import { listChatGroupsIn, mustGetActiveChatGroup } from "./chat-group.js";
+import { appendChunk, listChunks, updateOp } from "./chunk.js";
+import { randomId } from "./id.js";
+import { assertRemovableAt } from "./files/index.js";
+const CHATS = '@qvac/chats';
+const CHAT_GROUPS = '@qvac/chat-groups';
+const ACTIVE_CHATS = '@qvac/active-chats';
+const ACTIVE_CHATS_BY_AGENT = '@qvac/active-chats-by-agent';
+const ACTIVE_CHAT_GROUPS = '@qvac/active-chat-groups';
+const CHUNK_COUNTERS = '@qvac/chunk-counters';
+const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
+function byChatOrder(a, b) {
+    return a.lastActivityAt - b.lastActivityAt || (a.id < b.id ? -1 : 1);
+}
+export async function liveGroupIds(snap) {
+    const groups = await snap.find(ACTIVE_CHAT_GROUPS).toArray();
+    return new Set(groups.map((group) => group.id));
+}
+export async function lastActivity(snap) {
+    const counters = await snap.find(CHUNK_COUNTERS).toArray();
+    return new Map(counters.map((counter) => [counter.chatId, counter.lastActivityAt ?? 0]));
+}
+function listingOf(chat, inLiveGroup, activityAt) {
+    return {
+        ...chat,
+        groupId: inLiveGroup ? chat.groupId : undefined,
+        lastActivityAt: activityAt || chat.createdAt
+    };
+}
+export async function enrichChat(store, chat) {
+    const snap = store.view.snapshot();
+    try {
+        return await enrichIn(snap, chat);
+    }
+    finally {
+        await snap.close();
+    }
+}
+export async function enrichIn(snap, chat) {
+    const [group, counter] = await Promise.all([
+        chat.groupId
+            ? snap.get(CHAT_GROUPS, { id: chat.groupId })
+            : Promise.resolve(null),
+        snap.get(CHUNK_COUNTERS, { chatId: chat.id })
+    ]);
+    return listingOf(chat, Boolean(group) && !group?.deletedAt, counter?.lastActivityAt);
+}
+export function enrichAll(chats, activity, liveGroups) {
+    return chats.map((chat) => listingOf(chat, Boolean(chat.groupId && liveGroups.has(chat.groupId)), activity.get(chat.id)));
+}
+export async function listSidebar(store) {
+    const snap = store.view.snapshot();
+    try {
+        const chats = await snap.find(ACTIVE_CHATS).toArray();
+        const [activity, groups] = await Promise.all([lastActivity(snap), listChatGroupsIn(snap)]);
+        const live = new Set(groups.map((group) => group.id));
+        return { chats: enrichAll(chats, activity, live).sort(byChatOrder), groups };
+    }
+    finally {
+        await snap.close();
+    }
+}
+export async function listChats(store) {
+    return (await listSidebar(store)).chats;
+}
+export async function getChat(store, id) {
+    const snap = store.view.snapshot();
+    try {
+        const chat = await snap.get(CHATS, { id });
+        return chat;
+    }
+    finally {
+        await snap.close();
+    }
+}
+export async function mustGetChat(store, id) {
+    const chat = await getChat(store, id);
+    if (!chat)
+        throw new Error(`chat not found: ${id}`);
+    return chat;
+}
+export async function mustGetActiveChat(store, id) {
+    const chat = await mustGetChat(store, id);
+    if (chat.deletedAt)
+        throw new Error(`chat not found: ${id}`);
+    return chat;
+}
+export async function mustGetActiveChatListing(store, id) {
+    return enrichChat(store, await mustGetActiveChat(store, id));
+}
+export function buildChat(input) {
+    const now = Date.now();
+    return {
+        id: randomId(),
+        agentId: input.agentId,
+        title: input.title,
+        ragEnabled: false,
+        webSearchEnabled: true,
+        createdAt: now,
+        updatedAt: now,
+        deletedAt: undefined
+    };
+}
+export async function createChat(store, input) {
+    const chat = buildChat(input);
+    await store.dispatch('put-chat', { chat });
+    return listingOf(chat, false, undefined);
+}
+async function patchChat(store, id, patch) {
+    const current = await mustGetActiveChat(store, id);
+    const updated = { ...current, ...patch, updatedAt: Date.now() };
+    await store.dispatch('put-chat', { chat: updated });
+    return enrichChat(store, updated);
+}
+export function renameChat(store, id, title) {
+    return patchChat(store, id, { title });
+}
+export function setChatRagEnabled(store, id, ragEnabled) {
+    return patchChat(store, id, { ragEnabled });
+}
+export async function setChatGroup(store, id, groupId) {
+    if (groupId)
+        await mustGetActiveChatGroup(store, groupId);
+    return patchChat(store, id, { groupId: groupId || undefined });
+}
+export function setChatWebSearchEnabled(store, id, webSearchEnabled) {
+    return patchChat(store, id, { webSearchEnabled });
+}
+async function cancelActiveRuns(store, deviceId, chatId) {
+    const statuses = await listChunks(store, { chatId, type: 'run-status' });
+    const terminal = new Set(statuses.filter((c) => TERMINAL_RUN_STATES.has(c.runStatus?.state ?? '')).map((c) => c.runId));
+    const requests = await listChunks(store, { chatId, type: 'run-request' });
+    const runIds = new Set(requests.map((c) => c.runId).filter((id) => Boolean(id)));
+    const batch = store.batch();
+    for (const runId of runIds) {
+        if (terminal.has(runId))
+            continue;
+        await appendChunk(store, {
+            chatId,
+            runId,
+            type: 'run-status',
+            runStatus: { state: 'canceled' },
+            originDeviceId: deviceId
+        }, batch);
+    }
+    await batch.flush();
+}
+export async function removeChatKnowledge(store, chatId, at) {
+    assertRemovableAt(at);
+    const batch = store.batch();
+    for (const row of await store.files.listKnowledge(chatId)) {
+        batch.dispatch('remove-knowledge', { knowledgeId: row.id, at });
+    }
+    await batch.flush();
+}
+export async function removeChatAttachments(store, deviceId, chatId, at) {
+    const batch = store.batch();
+    for (const chunk of await listChunks(store, { chatId, type: 'attachment' })) {
+        const attachment = chunk.attachment;
+        if (!attachment || attachment.deletedAt)
+            continue;
+        if (!chunk.originDeviceId.equals(deviceId))
+            continue;
+        const tombstone = { ...attachment, deletedAt: at };
+        batch.dispatch('update-chunk', updateOp(chunk, { id: chunk.id, attachment: tombstone }));
+    }
+    await batch.flush();
+}
+export async function deleteChat(store, deviceId, id) {
+    const current = await mustGetChat(store, id);
+    const now = Date.now();
+    if (deviceId) {
+        await cancelActiveRuns(store, deviceId, id);
+        await removeChatAttachments(store, deviceId, id, now);
+    }
+    await removeChatKnowledge(store, id, now);
+    const deleted = { ...current, deletedAt: now, updatedAt: now };
+    await store.dispatch('put-chat', { chat: deleted });
+    return enrichChat(store, deleted);
+}
+export async function softDeleteChatsForAgent(store, deviceId, agentId) {
+    const snap = store.view.snapshot();
+    try {
+        for await (const chat of snap.find(ACTIVE_CHATS_BY_AGENT, {
+            gte: { agentId },
+            lte: { agentId }
+        })) {
+            if (store.closing)
+                return;
+            await deleteChat(store, deviceId, chat.id);
+        }
+    }
+    finally {
+        await snap.close();
+    }
+}

package/dist-lib/lib/core/chunk.d.ts

@@ -0,0 +1,61 @@
+import type HyperDB from 'hyperdb';
+import type { QvacChunk } from '../../spec/mesh/hyperschema/types.d.ts';
+import type { Mesh, MeshDispatcher } from './mesh.ts';
+type ChunkPayload = Pick<QvacChunk, 'userMessage' | 'content' | 'thinking' | 'toolCall' | 'toolResult' | 'attachment' | 'approvalRequest' | 'runStatus' | 'runRequest' | 'sources' | 'compaction'>;
+type AppendChunkInput = Pick<QvacChunk, 'chatId' | 'runId' | 'type' | 'originDeviceId' | 'parentId' | 'effect' | 'intent' | 'display' | 'rawCall'> & ChunkPayload & {
+    id?: string;
+};
+type UpdateChunkInput = Pick<QvacChunk, 'id' | 'runStatus' | 'attachment'>;
+export declare const HISTORY_CHUNK_TYPES: QvacChunk['type'][];
+type MediaKind = 'audio' | 'image' | 'video' | 'other';
+type AttachmentOrigin = 'uploaded' | 'generated';
+type ListAttachmentsByKindInput = {
+    kind: MediaKind;
+    origin?: AttachmentOrigin;
+    fromCreatedAt?: number;
+    reverse?: boolean;
+    limit?: number;
+};
+export type ReadChunk = QvacChunk & {
+    readonly attachment?: (NonNullable<QvacChunk['attachment']> & {
+        readonly url?: string;
+    }) | null;
+};
+type ListChunksInput = {
+    chatId: string;
+    type?: QvacChunk['type'];
+    types?: ReadonlyArray<QvacChunk['type']>;
+    fromSeq?: number;
+    reverse?: boolean;
+    limit?: number;
+};
+export declare function findChunksOfType(snap: HyperDB, chatId: string, type: QvacChunk['type'], { fromSeq, toSeq }?: {
+    fromSeq?: number;
+    toSeq?: number;
+}): Promise<QvacChunk[]>;
+export declare function listChunks(store: Mesh, { chatId, type, types, fromSeq, reverse, limit }: ListChunksInput): Promise<ReadChunk[]>;
+export declare function listAttachmentsByKind(store: Mesh, { kind, origin, fromCreatedAt, reverse, limit }: ListAttachmentsByKindInput): Promise<ReadChunk[]>;
+export declare function getChunk(store: Mesh, id: string): Promise<QvacChunk | null>;
+export declare function appendChunk(store: Mesh, { id, chatId, runId, type, originDeviceId, parentId, effect, intent, display, rawCall, ...payload }: AppendChunkInput, into?: MeshDispatcher): Promise<{
+    id: string;
+}>;
+export declare function updateChunk(store: Mesh, { id, runStatus, attachment }: UpdateChunkInput): Promise<QvacChunk>;
+export declare function updateOp(chunk: QvacChunk, { id, runStatus, attachment }: UpdateChunkInput): {
+    id: string;
+    runStatus: import("../../spec/index").QvacChunkContentRunStatus;
+    updatedAt: number;
+    attachment?: undefined;
+} | {
+    id: string;
+    attachment: import("../../spec/index").QvacChunkContentAttachment;
+    updatedAt: number;
+    runStatus?: undefined;
+};
+export declare function resolveApproval(store: Mesh, { id, approved, scope, expiresAt, agentId }: {
+    id: string;
+    approved: boolean;
+    scope?: 'once' | 'always';
+    expiresAt?: number;
+    agentId?: string;
+}): Promise<QvacChunk>;
+export {};