@qvac/core 0.0.0 → 0.1.0

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

@@ -0,0 +1,38 @@
+import { AbortController } from 'bare-abort-controller';
+import { createChat, deleteChat, listSidebar, mustGetActiveChatListing, renameChat, setChatRagEnabled, setChatWebSearchEnabled } from "../core/chat.js";
+import { listChatActivity } from "../core/chat-activity.js";
+import { searchChats } from "../core/chat-search.js";
+import { requireMesh } from "./current-mesh.js";
+import { watchable } from "./watchable.js";
+const SEARCH_SUPERSEDED_ABORT = 'superseded by a newer chat search';
+export function createChatApi(current, deviceId) {
+    let searchAbort = null;
+    const chatList = (mesh) => listSidebar(mesh);
+    const chatActivity = (mesh, chatIds) => listChatActivity(mesh, chatIds ?? undefined).then((activities) => ({ activities }));
+    return {
+        createChat: async (input) => createChat(await requireMesh(current), input),
+        listChats: async () => chatList(await requireMesh(current)),
+        getChat: async ({ id }) => mustGetActiveChatListing(await requireMesh(current), id),
+        renameChat: async ({ id, title }) => renameChat(await requireMesh(current), id, title),
+        setChatRagEnabled: async ({ id, enabled }) => setChatRagEnabled(await requireMesh(current), id, enabled ?? false),
+        setChatWebSearchEnabled: async ({ id, enabled }) => setChatWebSearchEnabled(await requireMesh(current), id, enabled ?? false),
+        deleteChat: async ({ id }) => deleteChat(await requireMesh(current), deviceId, id),
+        chatsWatch: watchable('chatsWatch', () => requireMesh(current), (_request, store) => chatList(store)),
+        listChatActivity: async (input) => chatActivity(await requireMesh(current), input?.chatIds),
+        chatActivityWatch: watchable('chatActivityWatch', () => requireMesh(current), (request, store) => chatActivity(store, request?.chatIds)),
+        searchChats: async (input) => {
+            searchAbort?.abort(SEARCH_SUPERSEDED_ABORT);
+            const controller = new AbortController();
+            searchAbort = controller;
+            return {
+                hits: [
+                    ...(await searchChats(await requireMesh(current), {
+                        query: input.query,
+                        limit: input.limit,
+                        signal: controller.signal
+                    }))
+                ]
+            };
+        }
+    };
+}

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

@@ -0,0 +1,5 @@
+import { type CurrentMesh } from './current-mesh.ts';
+import type { CapabilityHandlers } from '../../spec/capabilities.d.ts';
+type ChunkCapabilities = Pick<CapabilityHandlers, 'appendChunk' | 'updateChunk' | 'resolveApproval' | 'listChunks' | 'listAttachmentsByKind' | 'chunksWatch' | 'runRequestsWatch'>;
+export declare function createChunksApi(current: CurrentMesh): ChunkCapabilities;
+export {};

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

@@ -0,0 +1,61 @@
+import { appendChunk, listAttachmentsByKind, listChunks, resolveApproval, updateChunk } from "../core/chunk.js";
+import { requireMesh } from "./current-mesh.js";
+import { watchable } from "./watchable.js";
+export function createChunksApi(current) {
+    return {
+        appendChunk: async (input) => appendChunk(await requireMesh(current), input),
+        updateChunk: async (input) => {
+            await updateChunk(await requireMesh(current), input);
+            return { ok: true };
+        },
+        resolveApproval: async (input) => {
+            await resolveApproval(await requireMesh(current), {
+                id: input.id,
+                approved: input.approved === true,
+                scope: input.scope ?? undefined,
+                expiresAt: input.expiresAt || undefined,
+                agentId: input.agentId ?? undefined
+            });
+            return { ok: true };
+        },
+        listChunks: async ({ chatId, type, types, fromSeq, reverse, limit }) => ({
+            chunks: await listChunks(await requireMesh(current), {
+                chatId,
+                type: type ?? undefined,
+                types: types ?? undefined,
+                fromSeq: fromSeq || undefined,
+                reverse: reverse === true,
+                limit: limit || undefined
+            })
+        }),
+        listAttachmentsByKind: async ({ kind, origin, fromCreatedAt, reverse, limit }) => ({
+            chunks: await listAttachmentsByKind(await requireMesh(current), {
+                kind,
+                origin: origin ?? undefined,
+                fromCreatedAt: fromCreatedAt || undefined,
+                reverse: reverse === true,
+                limit: limit || undefined
+            })
+        }),
+        chunksWatch: watchable('chunksWatch', () => requireMesh(current), async ({ chatId, type, types, fromSeq, reverse, limit }, mesh) => ({
+            chunks: await listChunks(mesh, {
+                chatId,
+                type: type ?? undefined,
+                types: types ?? undefined,
+                fromSeq: fromSeq || undefined,
+                reverse: reverse === true,
+                limit: limit || undefined
+            })
+        })),
+        runRequestsWatch: watchable('runRequestsWatch', () => requireMesh(current), async (_request, mesh) => {
+            const snap = mesh.view.snapshot();
+            try {
+                const chunks = await snap.find('@qvac/run-requests').toArray();
+                return { chunks };
+            }
+            finally {
+                await snap.close();
+            }
+        })
+    };
+}

package/dist-lib/lib/api/config.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 createConfigApi(state: LocalStore): Pick<CapabilityHandlers, 'configGet' | 'configSet' | 'configWatch'>;
+export {};

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

@@ -0,0 +1,15 @@
+import { watchable } from "./watchable.js";
+export function createConfigApi(state) {
+    return {
+        async configGet({ key }) {
+            return { value: await state.get(key) };
+        },
+        async configSet({ key, value }) {
+            await state.set(key, value);
+            return { ok: true };
+        },
+        configWatch: watchable('configWatch', () => state, async ({ key }) => ({
+            value: await state.get(key)
+        }))
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { Mesh } from '../core/mesh.ts';
+export type CurrentMesh = () => Mesh | null | Promise<Mesh | null>;
+export declare const NO_ACTIVE_MESH = "no active mesh";
+export declare function requireMesh(current: CurrentMesh): Promise<Mesh>;
+export declare function isMeshTransition(err: unknown): boolean;

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

@@ -0,0 +1,12 @@
+export const NO_ACTIVE_MESH = 'no active mesh';
+export async function requireMesh(current) {
+    const mesh = await current();
+    if (!mesh)
+        throw new Error(NO_ACTIVE_MESH);
+    if (!mesh.opened)
+        await mesh.ready();
+    return mesh;
+}
+export function isMeshTransition(err) {
+    return err instanceof Error && err.message === NO_ACTIVE_MESH;
+}

package/dist-lib/lib/api/custom-models.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 createCustomModelApi(state: LocalStore): Pick<CapabilityHandlers, 'customModelsWatch' | 'addCustomModel' | 'removeCustomModel'>;
+export {};

package/dist-lib/lib/api/custom-models.js

@@ -0,0 +1,45 @@
+import { watchable } from "./watchable.js";
+import { normalizeModelSource, probeModelSource } from "../custom-model-source.js";
+async function readCustomModels(state) {
+    const rows = await state.getCustomModelRows();
+    return {
+        models: rows.map((row) => ({
+            name: row.name,
+            src: row.src,
+            mmprojSrc: row.mmprojSrc ?? null,
+            supportsTools: row.supportsTools ?? false,
+            supportsThinking: row.supportsThinking ?? false,
+            supportsVision: row.supportsVision ?? false,
+            expectedSize: row.expectedSize ?? 0,
+            createdAt: row.createdAt
+        }))
+    };
+}
+export function createCustomModelApi(state) {
+    return {
+        customModelsWatch: watchable('customModelsWatch', () => state, () => readCustomModels(state)),
+        addCustomModel: async (input) => {
+            const src = normalizeModelSource(input.src);
+            const mmprojSrc = input.mmprojSrc ? normalizeModelSource(input.mmprojSrc) : null;
+            const expectedSize = input.expectedSize && input.expectedSize > 0
+                ? input.expectedSize
+                : await probeModelSource(src);
+            const row = {
+                name: input.name,
+                src,
+                mmprojSrc,
+                supportsTools: input.supportsTools ?? false,
+                supportsThinking: input.supportsThinking ?? false,
+                supportsVision: input.supportsVision ?? false,
+                expectedSize,
+                createdAt: Date.now()
+            };
+            await state.putCustomModelRow(row);
+            return { ok: true };
+        },
+        removeCustomModel: async ({ name }) => {
+            await state.deleteCustomModelRow(name);
+            return { ok: true };
+        }
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { AssistantCapabilityProfile } from '../../spec/hyperschema/types.d.ts';
+import { type CurrentMesh } from './current-mesh.ts';
+import type { CapabilityHandlers } from '../../spec/capabilities.d.ts';
+export declare function createDevicesApi(current: CurrentMesh, deviceId: Buffer, removeWriter: (writerKey: Buffer, deviceId: Buffer) => Promise<void>, renameLocal: (name: string) => Promise<void>, saveProfileLocal: (capabilityProfile: AssistantCapabilityProfile, recommendedModelName: string, platform?: string) => Promise<void>, readLocalProfile: () => {
+    capabilityProfile: AssistantCapabilityProfile;
+    recommendedModelName: string;
+    platform?: string;
+} | null): Pick<CapabilityHandlers, 'listDevices' | 'devicesWatch' | 'deviceInfo' | 'saveDeviceCapabilities' | 'saveDeviceProfile' | 'removeDevice' | 'renameDevice'>;

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

@@ -0,0 +1,125 @@
+import { saveDeviceCapabilities } from "../core/devices.js";
+import { requireMesh } from "./current-mesh.js";
+import { watchable } from "./watchable.js";
+const DEVICES = '@qvac/devices';
+function toEngineDevice(device, overrides = {}) {
+    return {
+        id: device.id,
+        name: device.name,
+        joinedAt: device.joinedAt,
+        revoked: device.revoked ?? false,
+        installedToolNames: device.installedToolNames ?? [],
+        installedSkillNames: device.installedSkillNames ?? [],
+        readySkillNames: device.readySkillNames,
+        toolCatalog: device.toolCatalog,
+        installedModelNames: device.installedModelNames ?? [],
+        cachedModelNames: device.cachedModelNames ?? [],
+        capabilityProfile: device.capabilityProfile,
+        recommendedModelName: device.recommendedModelName,
+        appVersion: device.appVersion,
+        appBuild: device.appBuild,
+        appChannel: device.appChannel,
+        platform: device.platform,
+        ...overrides
+    };
+}
+export function createDevicesApi(current, deviceId, removeWriter, renameLocal, saveProfileLocal, readLocalProfile) {
+    const mustGetDevice = async (mesh, id) => {
+        const snap = mesh.view.snapshot();
+        try {
+            const device = await snap.get(DEVICES, { id });
+            if (!device)
+                throw new Error(`device not found: ${id.toString('hex')}`);
+            return device;
+        }
+        finally {
+            await snap.close();
+        }
+    };
+    const list = async () => {
+        const mesh = await requireMesh(current);
+        const snap = mesh.view.snapshot();
+        try {
+            const devices = await snap.find(DEVICES).toArray();
+            return { devices: devices.map((device) => toEngineDevice(device)) };
+        }
+        finally {
+            await snap.close();
+        }
+    };
+    return {
+        listDevices: list,
+        devicesWatch: watchable('devicesWatch', () => requireMesh(current), list),
+        deviceInfo: async () => {
+            logger.info(['api', 'devices'], 'deviceInfo handler reached');
+            return { id: deviceId, supportsKvCacheDeletion: true };
+        },
+        saveDeviceCapabilities: async (input) => {
+            await saveDeviceCapabilities(await requireMesh(current), {
+                deviceId,
+                installedToolNames: input.installedToolNames ?? [],
+                installedSkillNames: input.installedSkillNames ?? [],
+                installedModelNames: input.installedModelNames ?? [],
+                cachedModelNames: input.cachedModelNames ?? [],
+                readySkillNames: input.readySkillNames ?? null,
+                toolCatalog: input.toolCatalog ?? null
+            });
+            return { ok: true };
+        },
+        removeDevice: async ({ id }) => {
+            if (id.equals(deviceId))
+                throw new Error('cannot remove own device, use leaveMesh');
+            const device = await mustGetDevice(await requireMesh(current), id);
+            if (device.revoked)
+                return { ok: true };
+            if (!device.writerKey)
+                throw new Error('device has no writer key, cannot remove');
+            await removeWriter(device.writerKey, id);
+            return { ok: true };
+        },
+        renameDevice: async ({ id, name }) => {
+            if (!id.equals(deviceId)) {
+                throw new Error('can only rename this device, a device owns its row');
+            }
+            const trimmed = name.trim();
+            if (!trimmed)
+                throw new Error('device name must not be empty');
+            const mesh = await requireMesh(current);
+            const device = await mustGetDevice(mesh, id);
+            await renameLocal(trimmed);
+            try {
+                await mesh.dispatch('update-device', { device: { ...device, name: trimmed } });
+            }
+            catch (err) {
+                await renameLocal(device.name);
+                throw err;
+            }
+            return toEngineDevice(device, { name: trimmed });
+        },
+        saveDeviceProfile: async ({ capabilityProfile, recommendedModelName, platform }) => {
+            const mesh = await requireMesh(current);
+            const prior = readLocalProfile();
+            await saveProfileLocal(capabilityProfile, recommendedModelName, platform ?? undefined);
+            try {
+                await mesh.dispatch('update-device-profile', {
+                    deviceId,
+                    capabilityProfile,
+                    recommendedModelName,
+                    platform
+                });
+            }
+            catch (err) {
+                if (prior) {
+                    await saveProfileLocal(prior.capabilityProfile, prior.recommendedModelName, prior.platform);
+                }
+                throw err;
+            }
+            const device = await mustGetDevice(mesh, deviceId);
+            return toEngineDevice(device, {
+                capabilityProfile,
+                recommendedModelName,
+                platform: platform ?? device.platform
+            });
+        }
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { CapabilityHandlers } from '../../spec/capabilities.d.ts';
+export interface DiagnosticsSource {
+    watch(listener: () => void): void;
+    unwatch(listener: () => void): void;
+    snapshot(): Record<string, unknown>;
+}
+export declare function createDiagnosticsApi(source: DiagnosticsSource): Pick<CapabilityHandlers, 'diagnostics' | 'diagnosticsWatch'>;

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

@@ -0,0 +1,7 @@
+import { watchable } from "./watchable.js";
+export function createDiagnosticsApi(source) {
+    return {
+        diagnostics: async () => ({ stats: source.snapshot() }),
+        diagnosticsWatch: watchable('diagnosticsWatch', () => source, async () => ({ stats: source.snapshot() }))
+    };
+}

package/dist-lib/lib/api/effective-ctx-size.d.ts

@@ -0,0 +1,2 @@
+import type { QvacAgent } from '../../spec/mesh/hyperschema/types.d.ts';
+export declare function effectiveCtxSize(agent: Pick<QvacAgent, 'ctxSize' | 'modelName'> | null, appCtxSize: number, platform: string | null): number;

package/dist-lib/lib/api/effective-ctx-size.js

@@ -0,0 +1,10 @@
+import { defaultContextForModel, MOBILE_CONTEXT_SIZE, MODEL_CONTEXT_TARGET, modelContextTargetForPlatform } from "../model-context.js";
+export function effectiveCtxSize(agent, appCtxSize, platform) {
+    const configured = agent?.ctxSize || appCtxSize;
+    if (configured)
+        return configured;
+    if (modelContextTargetForPlatform(platform) === MODEL_CONTEXT_TARGET.mobile) {
+        return MOBILE_CONTEXT_SIZE;
+    }
+    return defaultContextForModel(agent?.modelName ?? '');
+}

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

@@ -0,0 +1,3 @@
+import { type CurrentMesh } from './current-mesh.ts';
+import type { CapabilityHandlers } from '../../spec/capabilities.d.ts';
+export declare function createExecutionApi(current: CurrentMesh, deviceId: Buffer): Pick<CapabilityHandlers, 'sendMessage' | 'runAgent' | 'stopRun'>;

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

@@ -0,0 +1,45 @@
+import { appendChunk, listChunks } from "../core/chunk.js";
+import { randomId } from "../core/id.js";
+import { parentRequestId, sendMessage } from "../core/send.js";
+import { requireMesh } from "./current-mesh.js";
+const TERMINAL_STATES = new Set(['completed', 'failed', 'canceled']);
+export function createExecutionApi(current, deviceId) {
+    return {
+        sendMessage: async (input) => sendMessage(await requireMesh(current), {
+            text: input.text,
+            chatId: input.chatId ?? undefined,
+            agentId: input.agentId ?? undefined,
+            title: input.title ?? undefined,
+            parentRunId: input.parentRunId ?? undefined,
+            originDeviceId: deviceId
+        }),
+        runAgent: async ({ chatId, agentId, parentRunId }) => {
+            const mesh = await requireMesh(current);
+            const parentId = parentRunId ? await parentRequestId(mesh, chatId, parentRunId) : undefined;
+            await appendChunk(mesh, {
+                chatId,
+                runId: randomId(),
+                type: 'run-request',
+                runRequest: { agentId },
+                parentId,
+                originDeviceId: deviceId
+            });
+            return { ok: true };
+        },
+        stopRun: async ({ chatId, runId }) => {
+            const mesh = await requireMesh(current);
+            const statuses = await listChunks(mesh, { chatId, type: 'run-status' });
+            const settled = statuses.some((c) => c.runId === runId && TERMINAL_STATES.has(c.runStatus?.state ?? ''));
+            if (settled)
+                return { ok: true };
+            await appendChunk(mesh, {
+                chatId,
+                runId,
+                type: 'run-status',
+                runStatus: { state: 'canceled' },
+                originDeviceId: deviceId
+            });
+            return { ok: true };
+        }
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { CapabilityHandlers } from '../../spec/capabilities.d.ts';
+import { type CurrentMesh } from './current-mesh.ts';
+export declare function createFilesApi(current: CurrentMesh): Pick<CapabilityHandlers, 'fileRead' | 'filePreview' | 'fileRetry'>;

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

@@ -0,0 +1,48 @@
+import { AbortController } from 'bare-abort-controller';
+import { Readable } from 'streamx';
+import { requireMesh } from "./current-mesh.js";
+export function createFilesApi(current) {
+    return {
+        async filePreview(request) {
+            return (await requireMesh(current)).files.preview(request);
+        },
+        async fileRetry(request) {
+            await (await requireMesh(current)).files.retry(request);
+            return { ok: true };
+        },
+        fileRead(request) {
+            const abort = new AbortController();
+            async function* read() {
+                const mesh = await requireMesh(current);
+                const close = () => stream.destroy();
+                mesh.files.once('close', close);
+                try {
+                    yield* mesh.files.fileRead(request, { signal: abort.signal });
+                }
+                finally {
+                    mesh.files.off('close', close);
+                }
+            }
+            const iterator = read();
+            const stream = new Readable({
+                read(callback) {
+                    iterator
+                        .next()
+                        .then((frame) => {
+                        stream.push(frame.done ? null : frame.value);
+                        callback(null);
+                    })
+                        .catch(callback);
+                },
+                predestroy: () => abort.abort('file read closed'),
+                destroy(callback) {
+                    iterator
+                        .return(undefined)
+                        .then(() => callback(null))
+                        .catch(callback);
+                }
+            });
+            return stream;
+        }
+    };
+}

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

@@ -0,0 +1,62 @@
+import type { CapabilityHandlers } from '../../spec/capabilities.d.ts';
+import type { AssistantCapabilityProfile, AssistantClearModelDownloadRequest, AssistantDeleteModelRequest, AssistantDeleteModelResponse, AssistantCompactChatResponse, AssistantKvCacheDeletionResponse, AssistantListModelsRequest, AssistantModelCatalogRevision, AssistantCopySkillResponse, AssistantDeleteSkillResponse, AssistantManagedSkillsResponse, AssistantModelInfoList, AssistantOkResponse, AssistantPushSkillSecretRequest, AssistantSkillCatalogResponse, AssistantSkillFileResponse, AssistantSpeakRequest, AssistantSpeakResponse, AssistantToolCatalogResponse, AssistantTranscribeRequest, AssistantTranscribeResponse } from '../../spec/hyperschema/types.d.ts';
+import type { openLocalStore } from '../core/local/index.ts';
+import type { CurrentMesh } from './current-mesh.ts';
+import { type DiagnosticsSource } from './diagnostics.ts';
+import { type LogSource } from './logs.ts';
+import { type MeshStatusSource } from './mesh.ts';
+import { type NetworkSource } from './network.ts';
+import { type NotificationLifetime } from './notifications.ts';
+import type { IndexingEmbedder, VectorIndex } from '../core/files/index.ts';
+interface ApiDeps {
+    state?: Awaited<ReturnType<typeof openLocalStore>> | null;
+    notificationLifetime?: NotificationLifetime;
+    mesh?: CurrentMesh | null;
+    meshStatus?: MeshStatusSource | null;
+    network?: NetworkSource | null;
+    diagnostics?: DiagnosticsSource | null;
+    logs?: LogSource | null;
+    deviceId?: Buffer | null;
+    lifecycle?: {
+        suspend(): Promise<void>;
+        resume(): Promise<void>;
+    } | null;
+    listModels?: ((options: AssistantListModelsRequest) => Promise<AssistantModelInfoList>) | null;
+    deleteModel?: ((options: AssistantDeleteModelRequest) => Promise<AssistantDeleteModelResponse>) | null;
+    clearKvCache?: (() => Promise<AssistantKvCacheDeletionResponse>) | null;
+    deleteChatKvCache?: ((chatId: string) => Promise<AssistantKvCacheDeletionResponse>) | null;
+    compactChat?: ((chatId: string) => Promise<AssistantCompactChatResponse>) | null;
+    modelCatalogWatch?: (() => AsyncIterable<AssistantModelCatalogRevision>) | null;
+    retryModelDownload?: ((request: AssistantClearModelDownloadRequest) => Promise<void>) | null;
+    transcribe?: ((request: AssistantTranscribeRequest) => Promise<AssistantTranscribeResponse>) | null;
+    speak?: ((request: AssistantSpeakRequest) => Promise<AssistantSpeakResponse>) | null;
+    speakStream?: ((text: AsyncIterable<string>) => AsyncIterable<AssistantSpeakResponse>) | null;
+    deviceHost?: {
+        removeWriter: (writerKey: Buffer, deviceId: Buffer) => Promise<void>;
+        renameLocal: (name: string) => Promise<void>;
+        saveProfileLocal: (capabilityProfile: AssistantCapabilityProfile, recommendedModelName: string, platform?: string) => Promise<void>;
+        readLocalProfile: () => {
+            capabilityProfile: AssistantCapabilityProfile;
+            recommendedModelName: string;
+            platform?: string;
+        } | null;
+    } | null;
+    ragIndex?: (() => VectorIndex | null) | null;
+    ragEmbed?: (() => IndexingEmbedder | null) | null;
+    platform?: (() => string | null) | null;
+    pushSkillSecret?: ((request: AssistantPushSkillSecretRequest) => Promise<void>) | null;
+    skills?: ((agentId?: string | null, modelName?: string | null, options?: {
+        readonly refresh?: boolean;
+    }) => Promise<unknown>) | null;
+    skillCatalog?: ((agentId?: string | null, modelName?: string | null, options?: {
+        readonly refresh?: boolean;
+    }) => Promise<AssistantSkillCatalogResponse>) | null;
+    tools?: (() => Promise<AssistantToolCatalogResponse>) | null;
+    listManagedSkills?: ((agentId?: string | null) => Promise<AssistantManagedSkillsResponse>) | null;
+    readSkillFile?: ((name: string, agentId?: string | null) => Promise<AssistantSkillFileResponse>) | null;
+    writeSkillFile?: ((name: string, content: string, agentId?: string | null) => Promise<AssistantOkResponse>) | null;
+    copySkillForEdit?: ((name: string, agentId?: string | null) => Promise<AssistantCopySkillResponse>) | null;
+    deleteOverlaySkill?: ((name: string, agentId?: string | null) => Promise<AssistantDeleteSkillResponse>) | null;
+}
+export type { Capabilities, WatchStream } from '../../spec/capabilities.d.ts';
+export declare function createApi(deps?: ApiDeps): Partial<CapabilityHandlers>;