@qvac/core 0.0.0 → 0.1.0

package/dist-lib/lib/audio-format.d.ts

@@ -0,0 +1,4 @@
+export { isAudioAttachment as isAudioFile } from './core/audio-attachment.ts';
+export { AUDIO_EXTENSIONS } from '../schema/helpers.js';
+export { wavDurationSeconds } from './wav-duration.ts';
+export declare const MAX_AUDIO_ATTACHMENT_BYTES: number;

package/dist-lib/lib/audio-format.js

@@ -0,0 +1,4 @@
+export { isAudioAttachment as isAudioFile } from "./core/audio-attachment.js";
+export { AUDIO_EXTENSIONS } from '../schema/helpers.js';
+export { wavDurationSeconds } from "./wav-duration.js";
+export const MAX_AUDIO_ATTACHMENT_BYTES = 25 * 1024 * 1024;

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

@@ -0,0 +1,5 @@
+export declare function isDefaultChatTitle(title: string | null | undefined): boolean;
+export declare function buildTitlePrompt(input: string): string;
+export declare function normalizeModelTitle(raw: string): string | null;
+export declare function parseTitleResponse(raw: string): string | null;
+export declare function deriveChatTitle(content: string): string | null;

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

@@ -0,0 +1,58 @@
+import { unwrap } from 'asenion';
+const DEFAULT_TITLES = new Set(['New Chat', 'General']);
+const MAX_TITLE_WORDS = 6;
+const DERIVED_TITLE_WORDS = 3;
+const MAX_TITLE_LENGTH = 60;
+export function isDefaultChatTitle(title) {
+    return DEFAULT_TITLES.has((title ?? '').trim());
+}
+const TITLE_INSTRUCTION = 'Generate a short, descriptive title of 3 to 6 words for a conversation that begins with the ' +
+    'message below. Name the conversation; do not answer it.';
+export function buildTitlePrompt(input) {
+    return `${TITLE_INSTRUCTION}\n\nMessage:\n${input}`;
+}
+export function normalizeModelTitle(raw) {
+    const firstLine = raw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean);
+    if (!firstLine)
+        return null;
+    const unlabeled = firstLine.replace(/^title\s*[:\-–]\s*/i, '');
+    const unquoted = unwrap(unlabeled)
+        .replace(/^["'`]+|["'`]+$/g, '')
+        .trim();
+    const words = unquoted.split(/\s+/).filter(Boolean).slice(0, MAX_TITLE_WORDS);
+    if (words.length === 0)
+        return null;
+    const title = words
+        .join(' ')
+        .replace(/[.,;:!?]+$/, '')
+        .trim()
+        .slice(0, MAX_TITLE_LENGTH)
+        .trim();
+    return title || null;
+}
+export function parseTitleResponse(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            return typeof parsed.title === 'string' ? normalizeModelTitle(parsed.title) : null;
+        }
+        catch {
+        }
+    }
+    return normalizeModelTitle(trimmed);
+}
+export function deriveChatTitle(content) {
+    const words = content
+        .replace(/[`*_#[\]()]/g, ' ')
+        .split(/\s+/)
+        .map((word) => word.replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, ''))
+        .filter(Boolean)
+        .slice(0, DERIVED_TITLE_WORDS);
+    if (words.length === 0)
+        return null;
+    return words.join(' ').slice(0, MAX_TITLE_LENGTH);
+}

package/dist-lib/lib/client.d.ts

@@ -0,0 +1,25 @@
+import ReadyResource from 'ready-resource';
+import type { Capabilities } from './api/index.ts';
+import type { CapabilityHandlers } from '../spec/capabilities.d.ts';
+import type { Logger } from '../index.ts';
+import { type EngineSpec } from './spec-loader.ts';
+import { type Transport } from '@qvac/harness/rpc';
+export interface ClientOptions {
+    logger?: Logger | null;
+    spec?: () => Promise<EngineSpec>;
+    handlers?: Partial<CapabilityHandlers>;
+}
+export interface Client extends Capabilities {
+}
+export declare class Client extends ReadyResource {
+    private readonly _transport;
+    private readonly _log;
+    private readonly _spec;
+    private readonly _handlers;
+    private readonly _watches;
+    private _stream;
+    constructor(transport: Transport, { logger, spec, handlers }?: ClientOptions);
+    _open(): Promise<void>;
+    private _reconnecting;
+    _close(): Promise<void>;
+}

package/dist-lib/lib/client.js

@@ -0,0 +1,53 @@
+import ReadyResource from 'ready-resource';
+import reconnectingWatch from "./reconnecting-watch.js";
+import { openLocalEngineSpec } from "./spec-loader.js";
+import { settleOnClose } from '@qvac/harness/rpc';
+export class Client extends ReadyResource {
+    _transport;
+    _log;
+    _spec;
+    _handlers;
+    _watches;
+    _stream;
+    constructor(transport, { logger = null, spec = openLocalEngineSpec, handlers } = {}) {
+        super();
+        this._transport = transport;
+        this._log = logger;
+        this._spec = spec;
+        this._handlers = handlers;
+        this._watches = new Set();
+        this._stream = null;
+    }
+    async _open() {
+        this._stream = await this._transport();
+        const { bindApi, engineClient, HRPC } = await this._spec();
+        const rpc = settleOnClose(new HRPC(this._stream));
+        const declined = { storeIdentityPhrase: () => ({ ok: false }) };
+        bindApi(rpc, { ...declined, ...this._handlers });
+        const capabilities = engineClient(rpc);
+        const modelDownloadsWatch = this._reconnecting(capabilities.modelDownloadsWatch, 'model-download');
+        const modelCatalogWatch = this._reconnecting(capabilities.modelCatalogWatch, 'model-catalog');
+        Object.assign(this, capabilities, { modelCatalogWatch, modelDownloadsWatch });
+        this._log?.info('lifecycle', 'client open');
+    }
+    _reconnecting(open, scope) {
+        return (input) => {
+            const watch = reconnectingWatch(() => open(input), (error) => this._log?.warn(scope, 'watch disconnected — reopening', error));
+            this._watches.add(watch);
+            watch.on('close', () => this._watches.delete(watch));
+            return watch;
+        };
+    }
+    async _close() {
+        for (const watch of this._watches)
+            watch.destroy();
+        this._watches.clear();
+        const stream = this._stream;
+        if (stream && !stream.destroyed) {
+            const closed = new Promise((resolve) => stream.on('close', resolve));
+            stream.destroy();
+            await closed;
+        }
+        this._log?.info('lifecycle', 'client closed');
+    }
+}

package/dist-lib/lib/collabora/convert.d.ts

@@ -0,0 +1,9 @@
+import type { AbortSignal } from 'bare-abort-controller';
+export type ConvertInput = {
+    readonly bytes: Uint8Array;
+    readonly fileName: string;
+    readonly to: string;
+    readonly signal?: AbortSignal;
+};
+export declare function convert(input: ConvertInput): Promise<Uint8Array>;
+export declare function convertToText(input: ConvertInput): Promise<string>;

package/dist-lib/lib/collabora/convert.js

@@ -0,0 +1,62 @@
+import b4a from 'b4a';
+import { randomBytes } from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { convertInWorker } from "./worker.js";
+const ZIP_SIGNATURE = 0x04034b50;
+const EOCD_SIGNATURE = 0x06054b50;
+const EOCD_SIZE = 22;
+const EOCD_SCAN = 65_535 + EOCD_SIZE;
+export async function convert(input) {
+    assertIntactZip(input.bytes);
+    const base = path.join(os.tmpdir(), `qvac-collabora-${randomBytes(8).toString('hex')}`);
+    const src = `${base}${sourceExtension(input.fileName)}`;
+    const out = `${base}.${input.to}`;
+    try {
+        await fs.promises.writeFile(src, input.bytes);
+        await convertInWorker({ src, out, format: input.to }, input.signal);
+        return await fs.promises.readFile(out);
+    }
+    finally {
+        await unlinkQuiet(src);
+        await unlinkQuiet(out);
+    }
+}
+export async function convertToText(input) {
+    const bytes = await convert(input);
+    return stripBom(b4a.toString(bytes, 'utf8'));
+}
+function assertIntactZip(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (bytes.byteLength < EOCD_SIZE || view.getUint32(0, true) !== ZIP_SIGNATURE)
+        return;
+    const eocd = findEocd(view);
+    if (eocd === -1)
+        throw new Error('truncated document: the zip central directory is missing');
+    const directoryEnd = view.getUint32(eocd + 16, true) + view.getUint32(eocd + 12, true);
+    if (directoryEnd > eocd)
+        throw new Error('truncated document: zip central directory is cut off');
+}
+function findEocd(view) {
+    const from = Math.max(0, view.byteLength - EOCD_SCAN);
+    for (let at = view.byteLength - EOCD_SIZE; at >= from; at--) {
+        if (view.getUint32(at, true) === EOCD_SIGNATURE)
+            return at;
+    }
+    return -1;
+}
+function sourceExtension(fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    return ext || '.doc';
+}
+function stripBom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+async function unlinkQuiet(file) {
+    try {
+        await fs.promises.unlink(file);
+    }
+    catch {
+    }
+}

package/dist-lib/lib/collabora/entry.d.ts

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

package/dist-lib/lib/collabora/entry.js

@@ -0,0 +1,44 @@
+import { asHostJob } from "./protocol.js";
+async function main() {
+    const self = Bare.Thread.self;
+    if (!self)
+        throw new Error('collabora entry loaded on the main thread');
+    const { default: Channel } = await import('bare-channel');
+    const port = Channel.from(handleFrom(self.data)).connect();
+    const convert = await load();
+    for (;;) {
+        const job = asHostJob(await port.read());
+        if (!job)
+            break;
+        if (typeof convert === 'string') {
+            port.write({ id: job.id, error: convert });
+            break;
+        }
+        port.write(run(convert, job));
+    }
+    await port.close();
+}
+async function load() {
+    try {
+        const { Document } = await import('bare-collabora');
+        return (job) => void new Document(job.src).saveAs(job.out, job.format);
+    }
+    catch (error) {
+        return `the document engine failed to load: ${error.message}`;
+    }
+}
+function run(convert, job) {
+    try {
+        convert(job);
+        return { id: job.id, ok: true };
+    }
+    catch (error) {
+        return { id: job.id, error: error.message };
+    }
+}
+function handleFrom(data) {
+    if (typeof data === 'object' && data !== null && 'handle' in data)
+        return data.handle;
+    throw new Error('collabora worker started without a channel handle');
+}
+await main();

package/dist-lib/lib/collabora/protocol.d.ts

@@ -0,0 +1,15 @@
+export type HostJob = {
+    readonly id: number;
+    readonly src: string;
+    readonly out: string;
+    readonly format: string;
+};
+export type WorkerReply = {
+    readonly id: number;
+    readonly ok: true;
+} | {
+    readonly id: number;
+    readonly error: string;
+};
+export declare function asWorkerReply(value: unknown): WorkerReply | null;
+export declare function asHostJob(value: unknown): HostJob | null;

package/dist-lib/lib/collabora/protocol.js

@@ -0,0 +1,24 @@
+export function asWorkerReply(value) {
+    if (typeof value !== 'object' || value === null || !('id' in value))
+        return null;
+    const id = value.id;
+    if (typeof id !== 'number')
+        return null;
+    if ('ok' in value && value.ok === true)
+        return { id, ok: true };
+    if ('error' in value && typeof value.error === 'string')
+        return { id, error: value.error };
+    return null;
+}
+export function asHostJob(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    if (!('id' in value && 'src' in value && 'out' in value && 'format' in value))
+        return null;
+    const { id, src, out, format } = value;
+    if (typeof id !== 'number')
+        return null;
+    if (typeof src !== 'string' || typeof out !== 'string' || typeof format !== 'string')
+        return null;
+    return { id, src, out, format };
+}

package/dist-lib/lib/collabora/worker.d.ts

@@ -0,0 +1,5 @@
+import type { AbortSignal } from 'bare-abort-controller';
+import { type HostJob } from './protocol.ts';
+export type ConvertJob = Omit<HostJob, 'id'>;
+export declare function convertInWorker(job: ConvertJob, signal?: AbortSignal): Promise<void>;
+export declare function closeCollaboraWorker(): void;

package/dist-lib/lib/collabora/worker.js

@@ -0,0 +1,111 @@
+import process from 'process';
+import ScopeLock from 'scope-lock';
+import safetyCatch from 'safety-catch';
+import { fileURLToPath } from 'url';
+import { asWorkerReply } from "./protocol.js";
+const DEADLINE_MS = 60_000;
+const lock = new ScopeLock();
+let active = null;
+export async function convertInWorker(job, signal) {
+    await lock.lock();
+    try {
+        const worker = active ?? (active = await spawn());
+        const id = worker.nextId++;
+        worker.link.write({ id, ...job });
+        await settle(worker, id, signal);
+    }
+    finally {
+        lock.unlock();
+    }
+}
+export function closeCollaboraWorker() {
+    if (!active)
+        return;
+    active.link.kill();
+    active = null;
+}
+async function settle(worker, id, signal) {
+    const deadline = timeout(deadlineMs());
+    const cancel = cancellation(signal);
+    try {
+        const landed = reply(worker, id).catch((error) => {
+            abandon(worker);
+            throw error;
+        });
+        const outcome = await Promise.race([landed, deadline.expired, cancel.cancelled]);
+        if (typeof outcome === 'string') {
+            abandon(worker);
+            throw new Error(outcome === 'deadline' ? 'the document engine stopped responding' : 'conversion cancelled');
+        }
+        if (outcome.error)
+            throw new Error(outcome.error);
+    }
+    finally {
+        deadline.clear();
+        cancel.clear();
+    }
+}
+async function reply(worker, id) {
+    const message = asWorkerReply(await worker.link.read());
+    if (!message)
+        throw new Error('the document engine closed unexpectedly');
+    if (message.id !== id)
+        throw new Error('the document engine answered a different conversion');
+    return 'error' in message ? { error: message.error } : {};
+}
+function abandon(worker) {
+    if (active === worker)
+        active = null;
+    worker.link.kill();
+}
+async function spawn() {
+    if (typeof Bare === 'undefined')
+        throw new Error('the document engine needs the Bare runtime');
+    const { default: Channel } = await import('bare-channel');
+    const channel = new Channel();
+    const thread = new Bare.Thread(entry(), { data: { handle: channel.handle } });
+    const port = channel.connect();
+    return {
+        nextId: 1,
+        link: {
+            read: () => port.read(),
+            write: (job) => void port.write(job),
+            kill() {
+                try {
+                    thread.terminate();
+                }
+                catch (error) {
+                    safetyCatch(error);
+                }
+                port.close().catch(safetyCatch);
+            }
+        }
+    };
+}
+function entry() {
+    return (process.env.QVAC_COLLABORA_WORKER_ENTRY ||
+        fileURLToPath(new URL('./entry.ts', import.meta.url).href));
+}
+function deadlineMs() {
+    const ms = Number(process.env.QVAC_COLLABORA_TIMEOUT_MS);
+    return ms > 0 ? ms : DEADLINE_MS;
+}
+function timeout(ms) {
+    let timer;
+    const expired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('deadline'), ms);
+    });
+    return { expired, clear: () => clearTimeout(timer) };
+}
+function cancellation(signal) {
+    if (!signal)
+        return { cancelled: new Promise(() => { }), clear: () => { } };
+    if (signal.aborted)
+        return { cancelled: Promise.resolve('aborted'), clear: () => { } };
+    let onAbort = () => { };
+    const cancelled = new Promise((resolve) => {
+        onAbort = () => resolve('aborted');
+        signal.addEventListener('abort', onAbort);
+    });
+    return { cancelled, clear: () => signal.removeEventListener('abort', onAbort) };
+}

package/dist-lib/lib/compaction.d.ts

@@ -0,0 +1,30 @@
+import type { AssistantChunk } from '../spec/hyperschema/types.d.ts';
+export declare const COMPACTION_KEEP_TURNS = 1;
+export declare const COMPACTION_TURN_PREFIX = "[Summary of the earlier conversation in this chat, written by another model. Treat it as established context, not as a new request.]";
+export declare function compactionTurn(summary: string): string;
+export declare function foldReducesPrompt(folded: ReadonlyArray<{
+    readonly content: string;
+}>, summary: string): boolean;
+export declare function canCompact(ctxSize: number | undefined): boolean;
+export declare function buildCompactionPrompt(turns: ReadonlyArray<{
+    role: string;
+    content: string;
+}>, hasPriorSummary: boolean): string;
+export declare function parseCompactionSummary(text: string): string | null;
+export interface CompactionBoundary {
+    throughId: string;
+    foldedTurns: number;
+}
+export declare function compactionBoundary(chunks: ReadonlyArray<AssistantChunk>, keepTurns?: number): CompactionBoundary | null;
+export declare function lastCompactedThroughId(chunks: ReadonlyArray<AssistantChunk>): string | null;
+export interface FoldedChunks {
+    chunks: ReadonlyArray<AssistantChunk>;
+    summary: string | null;
+}
+export declare function foldCompactedChunks(chunks: ReadonlyArray<AssistantChunk>): FoldedChunks;
+export declare const COMPACTION_TRIGGER_RATIO = 0.95;
+export declare const COMPACTION_TRIGGER_RATIO_SMALL = 0.9;
+export declare const COMPACTION_SMALL_CTX_SIZE = 4096;
+export declare function compactionTriggerRatio(ctxSize: number): number;
+export declare function nearContextLimit(cacheTokens: number | undefined, ctxSize: number | undefined): boolean;
+export declare function isContextOverflowFailure(message: string | undefined): boolean;

package/dist-lib/lib/compaction.js

@@ -0,0 +1,95 @@
+import { CONTEXT_OVERFLOW_MESSAGE } from '@qvac/harness';
+import { COMPACTION_MIN_CTX_SIZE } from "./model-context.js";
+export const COMPACTION_KEEP_TURNS = 1;
+export const COMPACTION_TURN_PREFIX = '[Summary of the earlier conversation in this chat, written by another model. Treat it as established context, not as a new request.]';
+export function compactionTurn(summary) {
+    return `${COMPACTION_TURN_PREFIX}\n\n${summary}`;
+}
+export function foldReducesPrompt(folded, summary) {
+    const replaced = folded.reduce((total, turn) => total + turn.content.length, 0);
+    return compactionTurn(summary).length < replaced;
+}
+export function canCompact(ctxSize) {
+    return (ctxSize ?? 0) >= COMPACTION_MIN_CTX_SIZE;
+}
+export function buildCompactionPrompt(turns, hasPriorSummary) {
+    const transcript = turns
+        .map((turn) => `${turn.role === 'user' ? 'User' : 'Assistant'}: ${turn.content}`)
+        .join('\n\n');
+    return [
+        'Summarize the conversation below so another model can continue it without seeing it.',
+        hasPriorSummary
+            ? 'The conversation opens with an earlier summary. Carry everything from it that is still true into your new summary — it is discarded after this, so whatever you leave out is lost — and correct it where the later turns disagree.'
+            : null,
+        'Output exactly these four sections, in this order, keeping every heading even when it has nothing under it:',
+        '## Objective\n## Facts and decisions\n## State\n## Next steps',
+        'Rules: at most three bullets per section, at most fifteen words per bullet. Preserve names, numbers, file paths and identifiers exactly. Write "(none)" under a heading with nothing to say. Do not continue the conversation, do not answer anything asked in it, and do not mention summarizing.',
+        '<conversation>',
+        transcript,
+        '</conversation>'
+    ]
+        .filter((part) => part !== null)
+        .join('\n\n');
+}
+export function parseCompactionSummary(text) {
+    const summary = text.trim();
+    return summary.length > 0 ? summary : null;
+}
+export function compactionBoundary(chunks, keepTurns = COMPACTION_KEEP_TURNS) {
+    const userTurns = [];
+    for (let index = 0; index < chunks.length; index++) {
+        if (chunks[index].userMessage)
+            userTurns.push(index);
+    }
+    if (userTurns.length <= keepTurns)
+        return null;
+    const firstKept = userTurns[userTurns.length - keepTurns];
+    let from = firstKept;
+    for (let index = firstKept - 1; index > userTurns[userTurns.length - keepTurns - 1]; index--) {
+        if (chunks[index].attachment && !chunks[index].runId)
+            from = index;
+    }
+    const boundary = chunks[from - 1];
+    if (!boundary)
+        return null;
+    return { throughId: boundary.id, foldedTurns: userTurns.length - keepTurns };
+}
+function newestCompaction(chunks) {
+    let newest = null;
+    for (const chunk of chunks) {
+        if (chunk.compaction && (!newest || chunk.seq > newest.seq))
+            newest = chunk;
+    }
+    return newest;
+}
+export function lastCompactedThroughId(chunks) {
+    return newestCompaction(chunks)?.compaction?.throughId ?? null;
+}
+export function foldCompactedChunks(chunks) {
+    const compaction = newestCompaction(chunks)?.compaction;
+    if (!compaction)
+        return { chunks, summary: null };
+    const through = chunks.find((chunk) => chunk.id === compaction.throughId);
+    if (!through)
+        return { chunks, summary: null };
+    return {
+        chunks: chunks.filter((chunk) => chunk.seq > through.seq && !chunk.compaction),
+        summary: compaction.summary
+    };
+}
+export const COMPACTION_TRIGGER_RATIO = 0.95;
+export const COMPACTION_TRIGGER_RATIO_SMALL = 0.9;
+export const COMPACTION_SMALL_CTX_SIZE = 4_096;
+export function compactionTriggerRatio(ctxSize) {
+    return ctxSize <= COMPACTION_SMALL_CTX_SIZE
+        ? COMPACTION_TRIGGER_RATIO_SMALL
+        : COMPACTION_TRIGGER_RATIO;
+}
+export function nearContextLimit(cacheTokens, ctxSize) {
+    if (!cacheTokens || !ctxSize)
+        return false;
+    return cacheTokens >= ctxSize * compactionTriggerRatio(ctxSize);
+}
+export function isContextOverflowFailure(message) {
+    return message === CONTEXT_OVERFLOW_MESSAGE;
+}

package/dist-lib/lib/constants.d.ts

@@ -0,0 +1,4 @@
+export { COMPACTION_MIN_CTX_SIZE, contextOptionsForModel, DEFAULT_CONTEXT_SIZE, defaultContextForModel, formatTokenCount, MODEL_CONTEXT_TARGET, type ModelContextTarget, maxContextForModel, modelContextTargetForPlatform } from './model-context.ts';
+export declare const CANCELED_CHAT_MESSAGE = "Stopped the current run. Send a follow-up to steer the next step.";
+export declare const HOMEBREW_BIN_DIRS: ReadonlyArray<string>;
+export declare const SAFE_BIN_NAME: RegExp;

package/dist-lib/lib/constants.js

@@ -0,0 +1,4 @@
+export { COMPACTION_MIN_CTX_SIZE, contextOptionsForModel, DEFAULT_CONTEXT_SIZE, defaultContextForModel, formatTokenCount, MODEL_CONTEXT_TARGET, maxContextForModel, modelContextTargetForPlatform } from "./model-context.js";
+export const CANCELED_CHAT_MESSAGE = 'Stopped the current run. Send a follow-up to steer the next step.';
+export const HOMEBREW_BIN_DIRS = ['/opt/homebrew/bin', '/usr/local/bin'];
+export const SAFE_BIN_NAME = /^[A-Za-z0-9._-]+$/;

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

@@ -0,0 +1,15 @@
+import type { AssistantCreateAgentRequest, AssistantUpdateAgentRequest } from '../../spec/hyperschema/types.d.ts';
+import type { QvacAgent } from '../../spec/mesh/hyperschema/types.d.ts';
+import type { Mesh } from './mesh.ts';
+type CreateAgentInput = AssistantCreateAgentRequest;
+type UpdateAgentInput = AssistantUpdateAgentRequest;
+export declare function listAgents(store: Mesh): Promise<QvacAgent[]>;
+export declare function getAgent(store: Mesh, id: string): Promise<QvacAgent | null>;
+export declare function isOrphaned(store: Mesh, agent: QvacAgent): Promise<boolean>;
+export declare function liveProviderIds(store: Mesh): Promise<Set<string>>;
+export declare function mustGetAgent(store: Mesh, id: string): Promise<QvacAgent>;
+export declare function mustGetActiveAgent(store: Mesh, id: string): Promise<QvacAgent>;
+export declare function createAgent(store: Mesh, input: CreateAgentInput): Promise<QvacAgent>;
+export declare function updateAgent(store: Mesh, input: UpdateAgentInput): Promise<QvacAgent>;
+export declare function deleteAgent(store: Mesh, deviceId: Buffer | null, id: string): Promise<QvacAgent>;
+export {};