@qvac/core 0.0.0 → 0.1.1

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

@@ -0,0 +1,149 @@
+import { softDeleteChatsForAgent } from "./chat.js";
+import { randomId } from "./id.js";
+import { softDeleteToolConfigsForAgent } from "./tool-configs.js";
+const AGENTS = '@qvac/agents';
+const ACTIVE_AGENTS = '@qvac/active-agents';
+const DEVICES = '@qvac/devices';
+const DEFAULT_ICON_NAME = 'artificial-intelligence';
+function mergeSkills(base, enabled) {
+    return Array.from(new Set([...(base ?? []), ...(enabled ?? [])]));
+}
+function patch(next, current) {
+    return next === null || next === undefined ? current : next;
+}
+export async function listAgents(store) {
+    const snap = store.view.snapshot();
+    try {
+        const agents = await snap.find(ACTIVE_AGENTS).toArray();
+        return agents;
+    }
+    finally {
+        await snap.close();
+    }
+}
+export async function getAgent(store, id) {
+    const snap = store.view.snapshot();
+    try {
+        const agent = await snap.get(AGENTS, { id });
+        return agent;
+    }
+    finally {
+        await snap.close();
+    }
+}
+export async function isOrphaned(store, agent) {
+    const snap = store.view.snapshot();
+    try {
+        const device = await snap.get(DEVICES, { id: agent.providerDeviceId });
+        return !device || device.revoked === true;
+    }
+    finally {
+        await snap.close();
+    }
+}
+export async function liveProviderIds(store) {
+    const live = new Set();
+    const snap = store.view.snapshot();
+    try {
+        for await (const device of snap.find(DEVICES)) {
+            if (!device.revoked)
+                live.add(device.id.toString('hex'));
+        }
+        return live;
+    }
+    finally {
+        await snap.close();
+    }
+}
+export async function mustGetAgent(store, id) {
+    const agent = await getAgent(store, id);
+    if (!agent)
+        throw new Error(`agent not found: ${id}`);
+    return agent;
+}
+export async function mustGetActiveAgent(store, id) {
+    const agent = await mustGetAgent(store, id);
+    if (agent.deletedAt)
+        throw new Error(`agent not found: ${id}`);
+    return agent;
+}
+export async function createAgent(store, input) {
+    const now = Date.now();
+    const enabledSkills = input.enabledSkills ?? [];
+    const enabledTools = input.enabledTools ?? [];
+    const installedBase = input.installedSkills ?? enabledSkills;
+    const agent = {
+        id: randomId(),
+        name: input.name,
+        bio: input.bio,
+        providerDeviceId: input.providerDeviceId,
+        modelName: input.modelName,
+        reasoning: input.reasoning ?? 'inherit',
+        enabledSkills,
+        enabledTools,
+        installedSkills: mergeSkills(installedBase, enabledSkills),
+        isDefault: false,
+        createdAt: now,
+        updatedAt: now,
+        deletedAt: undefined,
+        imageModelChoice: input.imageModelChoice ?? undefined,
+        kvCacheK: input.kvCacheK ?? undefined,
+        kvCacheV: input.kvCacheV ?? undefined,
+        iconName: input.iconName ?? DEFAULT_ICON_NAME,
+        ctxSize: input.ctxSize || undefined,
+        toolsScope: input.toolsScope ?? 'selected',
+        skillsScope: input.skillsScope ?? 'selected',
+        imageSteps: input.imageSteps || undefined,
+        imageWidth: input.imageWidth || undefined,
+        imageHeight: input.imageHeight || undefined,
+        approvalMode: input.approvalMode === 'skip-all' ? 'skip-all' : 'ask',
+        disabledToolsets: input.disabledToolsets ?? []
+    };
+    await store.dispatch('put-agent', { agent });
+    return agent;
+}
+export async function updateAgent(store, input) {
+    const current = await mustGetActiveAgent(store, input.id);
+    const enabledSkills = patch(input.enabledSkills, current.enabledSkills);
+    const installedBase = patch(input.installedSkills, current.installedSkills);
+    const imageBase = input.clearImageSettings
+        ? {}
+        : current;
+    const updated = {
+        ...current,
+        name: patch(input.name, current.name),
+        bio: patch(input.bio, current.bio),
+        providerDeviceId: patch(input.providerDeviceId, current.providerDeviceId),
+        modelName: patch(input.modelName, current.modelName),
+        reasoning: patch(input.reasoning, current.reasoning),
+        enabledSkills,
+        enabledTools: patch(input.enabledTools, current.enabledTools),
+        installedSkills: mergeSkills(installedBase, enabledSkills),
+        imageModelChoice: patch(input.imageModelChoice, imageBase.imageModelChoice),
+        kvCacheK: patch(input.kvCacheK, current.kvCacheK),
+        kvCacheV: patch(input.kvCacheV, current.kvCacheV),
+        iconName: patch(input.iconName, current.iconName),
+        ctxSize: input.clearCtxSize ? undefined : input.ctxSize || current.ctxSize || undefined,
+        toolsScope: patch(input.toolsScope, current.toolsScope),
+        skillsScope: patch(input.skillsScope, current.skillsScope),
+        imageSteps: input.imageSteps || imageBase.imageSteps || undefined,
+        imageWidth: input.imageWidth || imageBase.imageWidth || undefined,
+        imageHeight: input.imageHeight || imageBase.imageHeight || undefined,
+        approvalMode: patch(input.approvalMode, current.approvalMode),
+        disabledToolsets: patch(input.disabledToolsets, current.disabledToolsets),
+        updatedAt: Date.now()
+    };
+    await store.dispatch('put-agent', { agent: updated });
+    return updated;
+}
+export async function deleteAgent(store, deviceId, id) {
+    const current = await mustGetAgent(store, id);
+    if (current.isDefault)
+        throw new Error('cannot delete the default agent');
+    const deletedAt = Date.now();
+    const updated = { ...current, deletedAt, updatedAt: deletedAt };
+    await store.dispatch('put-agent', { agent: updated });
+    await softDeleteChatsForAgent(store, deviceId, id);
+    await softDeleteToolConfigsForAgent(store, id);
+    return updated;
+}

package/dist-lib/lib/core/app-build.d.ts

@@ -0,0 +1,7 @@
+export declare const RELEASE_LANES: readonly ["dev", "staging", "prod"];
+export type ReleaseLane = (typeof RELEASE_LANES)[number];
+export interface AppBuildMetadata {
+    readonly version: string;
+    readonly build?: string;
+    readonly channel: ReleaseLane;
+}

package/dist-lib/lib/core/app-build.js

@@ -0,0 +1 @@
+export const RELEASE_LANES = ['dev', 'staging', 'prod'];

package/dist-lib/lib/core/approval-rules.d.ts

@@ -0,0 +1,15 @@
+import type { QvacApprovalRule } from '../../spec/mesh/hyperschema/types.d.ts';
+import type { Mesh } from './mesh.ts';
+export interface ResourceDescriptor {
+    kind: string;
+    label: string;
+}
+type PutApprovalRuleInput = Pick<QvacApprovalRule, 'toolName' | 'resourceKind' | 'resourcePattern' | 'decision' | 'expiresAt' | 'agentId' | 'effect'>;
+export declare function listApprovalRules(store: Mesh): Promise<QvacApprovalRule[]>;
+export declare function putApprovalRule(store: Mesh, input: PutApprovalRuleInput): Promise<QvacApprovalRule>;
+export declare function matchApprovalRule(rules: ReadonlyArray<QvacApprovalRule>, input: {
+    toolName: string;
+    resource?: ResourceDescriptor | null;
+    agentId?: string;
+}, now?: number): QvacApprovalRule | null;
+export {};

package/dist-lib/lib/core/approval-rules.js

@@ -0,0 +1,41 @@
+import { randomId } from "./id.js";
+const APPROVAL_RULES = '@qvac/approval-rules';
+export async function listApprovalRules(store) {
+    const snap = store.view.snapshot();
+    try {
+        const rules = await snap.find(APPROVAL_RULES).toArray();
+        return rules;
+    }
+    finally {
+        await snap.close();
+    }
+}
+export async function putApprovalRule(store, input) {
+    const now = Date.now();
+    const rule = { ...input, id: randomId(), createdAt: now, updatedAt: now };
+    await store.dispatch('put-approval-rule', { rule });
+    return rule;
+}
+export function matchApprovalRule(rules, input, now = Date.now()) {
+    for (const rule of rules) {
+        if (rule.expiresAt && rule.expiresAt <= now)
+            continue;
+        if (rule.toolName && rule.toolName !== input.toolName)
+            continue;
+        if (rule.agentId && rule.agentId !== input.agentId)
+            continue;
+        if (!matchesResource(rule, input.resource ?? null))
+            continue;
+        return rule;
+    }
+    return null;
+}
+function matchesResource(rule, resource) {
+    if (!rule.resourceKind || !rule.resourcePattern || rule.resourcePattern === '*')
+        return true;
+    if (!resource || resource.kind !== rule.resourceKind)
+        return false;
+    return rule.resourcePattern.endsWith('*')
+        ? resource.label.startsWith(rule.resourcePattern.slice(0, -1))
+        : resource.label === rule.resourcePattern;
+}

package/dist-lib/lib/core/async-iterable.d.ts

@@ -0,0 +1,13 @@
+interface EventStream<T> {
+    on(event: 'data', listener: (chunk: T) => void): void;
+    on(event: 'end', listener: () => void): void;
+    on(event: 'error', listener: (err: Error) => void): void;
+    resume?(): void;
+    off?: {
+        (event: 'data', listener: (chunk: T) => void): void;
+        (event: 'end', listener: () => void): void;
+        (event: 'error', listener: (error: Error) => void): void;
+    };
+}
+export declare function toAsyncIterable<T>(streamOrIterable: AsyncIterable<T> | EventStream<T>): AsyncIterable<T>;
+export {};

package/dist-lib/lib/core/async-iterable.js

@@ -0,0 +1,65 @@
+export function toAsyncIterable(streamOrIterable) {
+    if (!('on' in streamOrIterable))
+        return streamOrIterable;
+    const stream = streamOrIterable;
+    const queue = [];
+    let waiting = null;
+    let ended = false;
+    let error = null;
+    const onData = (chunk) => {
+        if (waiting) {
+            const { resolve } = waiting;
+            waiting = null;
+            resolve({ value: chunk, done: false });
+        }
+        else {
+            queue.push(chunk);
+        }
+    };
+    const onEnd = () => {
+        ended = true;
+        if (waiting) {
+            const { resolve } = waiting;
+            waiting = null;
+            resolve({ value: undefined, done: true });
+        }
+    };
+    const onError = (err) => {
+        error = err;
+        if (waiting) {
+            const { reject } = waiting;
+            waiting = null;
+            reject(err);
+        }
+    };
+    stream.on('data', onData);
+    stream.on('end', onEnd);
+    stream.on('error', onError);
+    const iterator = {
+        [Symbol.asyncIterator]() {
+            return iterator;
+        },
+        async return() {
+            onEnd();
+            queue.length = 0;
+            stream.off?.('data', onData);
+            stream.off?.('end', onEnd);
+            stream.off?.('error', onError);
+            return { done: true, value: undefined };
+        },
+        next() {
+            if (!queue.length && !ended && !error)
+                stream.resume?.();
+            if (queue.length)
+                return Promise.resolve({ value: queue.shift(), done: false });
+            if (ended)
+                return Promise.resolve({ value: undefined, done: true });
+            if (error)
+                return Promise.reject(error);
+            return new Promise((resolve, reject) => {
+                waiting = { resolve, reject };
+            });
+        }
+    };
+    return iterator;
+}

package/dist-lib/lib/core/attachment-link.d.ts

@@ -0,0 +1,7 @@
+export type LinkableAttachment = {
+    readonly blobId: string;
+    readonly mimeType: string;
+    readonly deletedAt?: number;
+};
+export type AttachmentUrl = (attachment: LinkableAttachment) => string | null;
+export declare function linkAttachment<T extends LinkableAttachment>(mint: AttachmentUrl | null, attachment: T): T;

package/dist-lib/lib/core/attachment-link.js

@@ -0,0 +1,6 @@
+export function linkAttachment(mint, attachment) {
+    if (!mint || attachment.deletedAt)
+        return attachment;
+    const url = mint(attachment);
+    return url ? { ...attachment, url } : attachment;
+}

package/dist-lib/lib/core/audio-attachment.d.ts

@@ -0,0 +1 @@
+export declare function isAudioAttachment(fileName: string, mimeType: string): boolean;

package/dist-lib/lib/core/audio-attachment.js

@@ -0,0 +1,4 @@
+import { mediaKindOf } from '../../schema/helpers.js';
+export function isAudioAttachment(fileName, mimeType) {
+    return mediaKindOf(mimeType, fileName) === 'audio';
+}

package/dist-lib/lib/core/blind-peers.d.ts

@@ -0,0 +1,6 @@
+export type BlindPeeringOpts = {
+    readonly batchIdleWait?: number;
+    readonly batchMaxWait?: number;
+};
+export declare const BLIND_RELAY_KEYS: ReadonlyArray<Buffer>;
+export declare const BLIND_PEER_KEYS: ReadonlyArray<Buffer>;

package/dist-lib/lib/core/blind-peers.js

@@ -0,0 +1,13 @@
+import { decode } from 'z32';
+export const BLIND_RELAY_KEYS = [
+    'tgbo7m8fh3hwqqxj95zrezorjgodtjr19b9dqruyauwnbafsmx8y',
+    'tfo1aqsc4hc4ok6a4akpxifkp65efoo9n13g1386zoa7umjipqpo',
+    'cobue4jgch38xkwoua9mohjkomua8bcek1okuq8rkd3gatj5hqfy',
+    'wjouex6jjz3zor3t7ww8p59t9r4kx6gw4sar89sjkq7azjcay1ao'
+].map((key) => decode(key));
+export const BLIND_PEER_KEYS = [
+    '5tskygqds4scoymmoc9bmns3qu6rnnfw5knuk8y4nrdydy47bawo',
+    'te8q3phdyntxjqyrrn7qtw8mnko3htsgcn8kg8pgymqf9uisiemo',
+    'iakqkthgz6fb9awt8og3ftj9ru87pp11ab7zdy135miwnpzjc9ty',
+    'm5oqrn5ngpheegoj4jc5yyk4uxo5kfa81t7tpemnjcyzgghc85ko'
+].map((key) => decode(key));

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

@@ -0,0 +1,7 @@
+import type { Mesh } from './mesh.ts';
+export type ChatActivityState = 'queued' | 'running' | 'generating-image' | 'generating-audio' | 'transcribing-audio' | 'awaiting-approval';
+export type ChatActivityRow = {
+    readonly id: string;
+    readonly activityState: ChatActivityState;
+};
+export declare function listChatActivity(store: Mesh, chatIds?: ReadonlyArray<string>): Promise<ChatActivityRow[]>;

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

@@ -0,0 +1,244 @@
+import ScopeLock from 'scope-lock';
+import { findChunksOfType } from "./chunk.js";
+const ACTIVE_CHATS = '@qvac/active-chats';
+const CHUNKS = '@qvac/chunks';
+const TERMINAL_RUN_STATES = new Set(['completed', 'failed', 'canceled']);
+const ACTIVITY_CHUNK_TYPES = [
+    'run-request',
+    'run-status',
+    'approval-request',
+    'tool-call',
+    'tool-result'
+];
+const IMAGE_TOOLS = new Set(['generate_image', 'edit_image']);
+const AUDIO_TOOLS = new Set(['generate_music']);
+const MEDIA_TOOLS = new Set([...IMAGE_TOOLS, ...AUDIO_TOOLS]);
+const catalogs = new WeakMap();
+export function listChatActivity(store, chatIds) {
+    let catalog = catalogs.get(store);
+    if (!catalog) {
+        catalog = new ChatActivityCatalog();
+        catalogs.set(store, catalog);
+    }
+    return catalog.list(store, chatIds);
+}
+class ChatActivityCatalog {
+    _lock;
+    _chats;
+    _head;
+    constructor() {
+        this._lock = new ScopeLock();
+        this._chats = new Map();
+        this._head = null;
+    }
+    async list(store, chatIds) {
+        await this._lock.lock();
+        try {
+            const head = store.view.db.head();
+            const snap = store.view.snapshot();
+            try {
+                const chats = await snap.find(ACTIVE_CHATS).toArray();
+                const activeChatIds = new Set(chats.map((chat) => chat.id));
+                await this._refresh(snap, head, activeChatIds);
+                const window = chatIds && chatIds.length > 0 ? new Set(chatIds) : null;
+                return [...this._states()]
+                    .filter(([id]) => !window || window.has(id))
+                    .map(([id, activityState]) => ({ id, activityState }))
+                    .sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
+            }
+            finally {
+                await snap.close();
+            }
+        }
+        finally {
+            this._lock.unlock();
+        }
+    }
+    async _refresh(snap, head, activeChatIds) {
+        if (!this._head || !head) {
+            await this._rebuild(snap, activeChatIds);
+        }
+        else {
+            this._prune(activeChatIds);
+            await this._loadMissing(snap, activeChatIds);
+            if (!(await this._applyChanges(snap, this._head, activeChatIds))) {
+                await this._rebuild(snap, activeChatIds);
+            }
+        }
+        this._head = head;
+    }
+    async _rebuild(snap, activeChatIds) {
+        this._chats.clear();
+        for (const chatId of activeChatIds)
+            await this._loadChat(snap, chatId);
+    }
+    _prune(activeChatIds) {
+        for (const chatId of this._chats.keys()) {
+            if (!activeChatIds.has(chatId))
+                this._chats.delete(chatId);
+        }
+    }
+    async _loadMissing(snap, activeChatIds) {
+        for (const chatId of activeChatIds) {
+            if (!this._chats.has(chatId))
+                await this._loadChat(snap, chatId);
+        }
+    }
+    async _loadChat(snap, chatId) {
+        const activity = { runs: new Map() };
+        this._chats.set(chatId, activity);
+        for (const chunk of await activityChunks(snap, chatId))
+            applyChunk(activity, chunk);
+    }
+    async _applyChanges(snap, from, activeChatIds) {
+        const chunksByChat = new Map();
+        for await (const change of snap.changes({ from })) {
+            if (change.collection !== CHUNKS)
+                continue;
+            if (change.type === 'delete')
+                return false;
+            if (!activeChatIds.has(change.value.chatId))
+                continue;
+            const chunks = chunksByChat.get(change.value.chatId) ?? [];
+            chunks.push(change.value);
+            chunksByChat.set(change.value.chatId, chunks);
+        }
+        for (const [chatId, chunks] of chunksByChat) {
+            const activity = this._chats.get(chatId);
+            if (!activity)
+                continue;
+            chunks.sort((left, right) => left.seq - right.seq);
+            for (const chunk of chunks)
+                applyChunk(activity, chunk);
+        }
+        return true;
+    }
+    _states() {
+        const states = new Map();
+        for (const [chatId, { runs }] of this._chats) {
+            const active = [...runs.values()];
+            if (active.length === 0)
+                continue;
+            states.set(chatId, activityState(active));
+        }
+        return states;
+    }
+}
+function activityState(runs) {
+    if (runs.some((run) => run.pendingApprovals.size > 0))
+        return 'awaiting-approval';
+    const started = runs.filter((run) => run.started);
+    if (started.length === 0)
+        return 'queued';
+    return mediaState(latestRun(started)) ?? 'running';
+}
+function mediaState(run) {
+    const tool = latestTool(run.tools);
+    if (run.progress === 'generating') {
+        if (tool && AUDIO_TOOLS.has(tool.name))
+            return 'generating-audio';
+        return 'generating-image';
+    }
+    if (run.progress === 'transcribing')
+        return 'transcribing-audio';
+    if (tool && IMAGE_TOOLS.has(tool.name))
+        return 'generating-image';
+    if (tool && AUDIO_TOOLS.has(tool.name))
+        return 'generating-audio';
+    return null;
+}
+function applyChunk(activity, chunk) {
+    const runId = chunk.runId;
+    if (!runId)
+        return;
+    if (chunk.type === 'run-request') {
+        const existing = activity.runs.get(runId);
+        if (existing) {
+            existing.seen.add(chunk.id);
+            return;
+        }
+        activity.runs.set(runId, createRun(chunk));
+        return;
+    }
+    const run = activity.runs.get(runId);
+    if (!run)
+        return;
+    run.started = true;
+    if (run.seen.has(chunk.id)) {
+        applyMutableChunk(run, chunk);
+        return;
+    }
+    run.seen.add(chunk.id);
+    if (chunk.type === 'run-status') {
+        const status = chunk.runStatus;
+        const state = status?.state ?? '';
+        if (TERMINAL_RUN_STATES.has(state)) {
+            activity.runs.delete(runId);
+        }
+        else if (state === 'executing' && chunk.seq > run.attemptSeq) {
+            run.attemptSeq = chunk.seq;
+            run.progress = status?.progress?.phase ?? null;
+            run.tools.length = 0;
+        }
+        return;
+    }
+    if (chunk.type === 'approval-request') {
+        applyApproval(run, chunk);
+        return;
+    }
+    if (chunk.seq <= run.attemptSeq)
+        return;
+    if (chunk.type === 'tool-call') {
+        const name = chunk.toolCall?.name;
+        if (name && MEDIA_TOOLS.has(name))
+            run.tools.push({ name, seq: chunk.seq });
+    }
+    else if (chunk.type === 'tool-result') {
+        settleTool(run.tools, chunk.toolResult?.name ?? '');
+    }
+}
+function createRun(request) {
+    return {
+        requestSeq: request.seq,
+        attemptSeq: request.seq,
+        started: false,
+        progress: null,
+        tools: [],
+        pendingApprovals: new Set(),
+        seen: new Set([request.id])
+    };
+}
+function applyMutableChunk(run, chunk) {
+    if (chunk.type === 'run-status' &&
+        chunk.runStatus?.state === 'executing' &&
+        chunk.seq === run.attemptSeq) {
+        run.progress = chunk.runStatus.progress?.phase ?? null;
+    }
+    else if (chunk.type === 'approval-request') {
+        applyApproval(run, chunk);
+    }
+}
+function applyApproval(run, chunk) {
+    if (chunk.approvalRequest?.status === 'pending')
+        run.pendingApprovals.add(chunk.id);
+    else
+        run.pendingApprovals.delete(chunk.id);
+}
+async function activityChunks(snap, chatId) {
+    const groups = await Promise.all(ACTIVITY_CHUNK_TYPES.map((type) => findChunksOfType(snap, chatId, type)));
+    return groups.flat().sort((left, right) => left.seq - right.seq);
+}
+function settleTool(tools, name) {
+    for (let index = tools.length - 1; index >= 0; index -= 1) {
+        if (tools[index]?.name !== name)
+            continue;
+        tools.splice(index, 1);
+        return;
+    }
+}
+function latestTool(tools) {
+    return tools.reduce((latest, candidate) => (!latest || candidate.seq > latest.seq ? candidate : latest), null);
+}
+function latestRun(runs) {
+    return runs.reduce((latest, run) => (run.requestSeq > latest.requestSeq ? run : latest));
+}

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

@@ -0,0 +1,14 @@
+import type HyperDB from 'hyperdb';
+import type { QvacChatGroup } from '../../spec/mesh/hyperschema/types.d.ts';
+import type { Mesh } from './mesh.ts';
+export declare function byGroupOrder(a: QvacChatGroup, b: QvacChatGroup): number;
+export declare function listChatGroupsIn(snap: HyperDB): Promise<QvacChatGroup[]>;
+export declare function listChatGroups(store: Mesh): Promise<QvacChatGroup[]>;
+export declare function getChatGroup(store: Mesh, id: string): Promise<QvacChatGroup | null>;
+export declare function mustGetChatGroup(store: Mesh, id: string): Promise<QvacChatGroup>;
+export declare function mustGetActiveChatGroup(store: Mesh, id: string): Promise<QvacChatGroup>;
+export declare function createChatGroup(store: Mesh, input: {
+    name: string;
+}): Promise<QvacChatGroup>;
+export declare function renameChatGroup(store: Mesh, id: string, name: string): Promise<QvacChatGroup>;
+export declare function deleteChatGroup(store: Mesh, id: string): Promise<QvacChatGroup>;