@qvac/core 0.0.0 → 0.1.1

package/dist-lib/lib/assistant-tree.js

@@ -0,0 +1,184 @@
+import Supervisor, {} from 'bare-supervisor';
+import { harnessClearKvCache, harnessDeleteModel, harnessListModels, harnessSkillCatalog, harnessSkillManagement, harnessSpeak, harnessSpeakStream, harnessTools, harnessTranscribe, QvacAssistant } from "./assistant.js";
+import { Client } from "./client.js";
+import { startCustomModelPusher } from "./custom-model-pusher.js";
+import { duplexPair } from '@qvac/harness/transport';
+export function assistantTree(opts) {
+    const { core, harness, logger = null, imageCacheDir, imageCacheMaxBytes, imageCacheMaxAgeMs, embedder, extractors, onHarness, platform, preloadCurrentAgentModel } = opts;
+    const sup = new Supervisor();
+    const logged = ['child-died', 'child-restarting', 'child-ready', 'gave-up', 'stall'];
+    for (const event of logged) {
+        sup.on(event, (payload) => logger?.warn('assistant-tree', event, { ...payload, error: payload.error?.message }));
+    }
+    sup.on('power', (payload) => logger?.info('assistant-tree', 'power', payload));
+    let offDiagnostics = null;
+    let offListModels = null;
+    let offDeleteModel = null;
+    let offClearKvCache = null;
+    let offDeleteChatKvCache = null;
+    let offCompactChat = null;
+    let offRetryModelDownload = null;
+    let offSkills = null;
+    let offSkillCatalog = null;
+    let offSkillManagement = null;
+    let offTools = null;
+    let offEmbedder = null;
+    let offHarness = null;
+    let offTranscribe = null;
+    let offSpeak = null;
+    let offSpeakStream = null;
+    let offModelCatalogWatch = null;
+    let offCustomModels = null;
+    sup.add('engine', {
+        start: async () => {
+            const [server, client] = duplexPair();
+            await core.connect(server);
+            return new Client(() => client, { logger });
+        }
+    });
+    if (typeof harness === 'function') {
+        sup.add('harness', {
+            deps: ['engine'],
+            start: (ctx) => harness({ engine: ctx.get('engine'), onDeath: ctx.onDeath }),
+            presuspend: (h) => h.presuspend?.(),
+            suspend: (h) => h.suspend?.(),
+            wakeup: (h) => h.wakeup?.(),
+            resume: (h) => h.resume?.()
+        });
+    }
+    else {
+        sup.add('harness', { ...harness, deps: ['engine', ...(harness.deps ?? [])] });
+    }
+    sup.add('assistant', {
+        deps: ['engine', 'harness'],
+        start: (ctx) => {
+            const harness = ctx.get('harness');
+            const engine = ctx.get('engine');
+            const assistant = new QvacAssistant(engine, harness, {
+                logger,
+                imageCacheDir,
+                imageCacheMaxBytes,
+                imageCacheMaxAgeMs,
+                ...(platform ? { platform } : {}),
+                ...(preloadCurrentAgentModel !== undefined ? { preloadCurrentAgentModel } : {}),
+                ...(core.fsDrives ? { drives: core.fsDrives } : {})
+            });
+            offDiagnostics = core.registerDiagnostics(() => assistant.diagnosticsSlice());
+            offListModels = core.registerListModels(harnessListModels(harness));
+            offDeleteModel = core.registerDeleteModel(harnessDeleteModel(harness));
+            offClearKvCache = core.registerClearKvCache(harnessClearKvCache(harness));
+            offDeleteChatKvCache = core.registerDeleteChatKvCache((chatId) => assistant.deleteChatKvCache(chatId));
+            offCompactChat = core.registerCompactChat((chatId) => assistant.compactChat(chatId));
+            offModelCatalogWatch = core.registerModelCatalogWatch(() => assistant.modelCatalogWatch());
+            offCustomModels = startCustomModelPusher(harness, core.local, logger);
+            offRetryModelDownload = core.registerRetryModelDownload((name) => assistant.retryModelDownload(name));
+            offSkills = core.registerSkills((agentId, modelName, options) => assistant.skills(agentId, modelName, options));
+            const transcribe = harnessTranscribe(harness);
+            offTranscribe = core.registerTranscribe(async (request) => {
+                await assistant.ensureMediaModelUnpaused('transcription', request.model);
+                return transcribe(request);
+            });
+            const speak = harnessSpeak(harness);
+            offSpeak = core.registerSpeak(async (request) => {
+                await assistant.ensureMediaModelUnpaused('tts', request.model);
+                return speak(request);
+            });
+            const speakStream = harnessSpeakStream(harness);
+            offSpeakStream = core.registerSpeakStream((text) => (async function* () {
+                await assistant.ensureMediaModelUnpaused('tts');
+                yield* speakStream(text);
+            })());
+            offSkillCatalog = core.registerSkillCatalog(harnessSkillCatalog(assistant, () => offHarness?.sync?.()));
+            offSkillManagement = core.registerSkillManagement(harnessSkillManagement(harness));
+            offTools = core.registerTools(harnessTools(assistant));
+            const emb = embedder?.(harness);
+            if (emb) {
+                let ensured = false;
+                const wrapped = {
+                    model: emb.model,
+                    embed: async (input) => {
+                        if (!ensured)
+                            ensured = await assistant.ensureMediaModelUnpaused('embedding');
+                        return emb.embed(input);
+                    }
+                };
+                offEmbedder = core.registerEmbedder(wrapped, extractors);
+            }
+            const off = onHarness?.(harness, { engine });
+            if (typeof off === 'function')
+                offHarness = off;
+            return assistant;
+        },
+        stop: async (assistant) => {
+            offDiagnostics?.();
+            offDiagnostics = null;
+            offListModels?.();
+            offListModels = null;
+            offDeleteModel?.();
+            offDeleteModel = null;
+            offClearKvCache?.();
+            offClearKvCache = null;
+            offDeleteChatKvCache?.();
+            offDeleteChatKvCache = null;
+            offCompactChat?.();
+            offCompactChat = null;
+            offModelCatalogWatch?.();
+            offModelCatalogWatch = null;
+            await offCustomModels?.();
+            offCustomModels = null;
+            offRetryModelDownload?.();
+            offRetryModelDownload = null;
+            offSkills?.();
+            offSkills = null;
+            offSkillCatalog?.();
+            offSkillCatalog = null;
+            offSkillManagement?.();
+            offSkillManagement = null;
+            offTools?.();
+            offTools = null;
+            await offEmbedder?.();
+            offEmbedder = null;
+            await offHarness?.();
+            offHarness = null;
+            offTranscribe?.();
+            offTranscribe = null;
+            offSpeak?.();
+            offSpeak = null;
+            offSpeakStream?.();
+            offSpeakStream = null;
+            await assistant.close();
+        },
+        presuspend: (assistant) => assistant.presuspend(),
+        suspend: (assistant) => assistant.suspend(),
+        wakeup: (assistant) => assistant.wakeup(),
+        resume: (assistant) => assistant.resume()
+    });
+    return sup;
+}
+export function assistantChild(opts) {
+    const { harness, core = 'core', logger = null, imageCacheDir, imageCacheMaxBytes, imageCacheMaxAgeMs, embedder, extractors, onHarness, preloadCurrentAgentModel, ...spec } = opts;
+    return {
+        ...spec,
+        deps: [core],
+        start(ctx) {
+            const tree = assistantTree({
+                core: ctx.get(core),
+                harness,
+                logger,
+                imageCacheDir,
+                imageCacheMaxBytes,
+                imageCacheMaxAgeMs,
+                embedder,
+                extractors,
+                onHarness,
+                ...(preloadCurrentAgentModel !== undefined ? { preloadCurrentAgentModel } : {})
+            });
+            tree.on('gave-up', ({ error }) => ctx.onDeath(error));
+            return tree;
+        },
+        presuspend: (tree) => tree.presuspend(),
+        suspend: (tree) => tree.suspend(),
+        wakeup: (tree) => tree.wakeup(),
+        resume: (tree) => tree.resume()
+    };
+}

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

@@ -0,0 +1,425 @@
+import { type AbortSignal } from 'bare-abort-controller';
+import type { ApprovalCall, InstallStep, MemoryBudget, ModelCategory, SkillRequires, SkillSetup } from '@qvac/harness';
+import type { ManagedSkill, SkillFileContent } from '@qvac/harness/lib/tools/skills/overlay-crud.ts';
+import type { SkillManagementHooks } from './core.ts';
+import type { DriveOpFn, GrantedDrive } from '@qvac/harness/lib/tools/fs/remote.ts';
+import ReadyResource from 'ready-resource';
+import type { AssistantAgent, AssistantCapabilityProfile, AssistantChunk, AssistantChunkContentAttachment, AssistantDeleteModelRequest, AssistantDeleteModelResponse, AssistantKvCacheDeletionResponse, AssistantListModelsRequest, AssistantModelCatalogRevision, AssistantModelInfoList, AssistantSkillCatalogResponse, AssistantSpeakRequest, AssistantSpeakResponse, AssistantToolCatalogResponse, AssistantTranscribeRequest, AssistantTranscribeResponse } from '../spec/hyperschema/types.d.ts';
+import type { Capabilities } from './api/index.ts';
+import { type DocumentAttachment } from './core/document-attachment.ts';
+import type { DriveHost } from './core/fs-drives.ts';
+import { type DiagnosticsSlice, type HarnessDiagnostics } from './diagnostics.ts';
+import type { Logger } from './log.ts';
+import { type DownloadArgs, type DownloadEventStream } from './model-download.ts';
+interface ChatMessage {
+    role: 'user' | 'assistant' | 'tool';
+    content: string;
+    attachments?: {
+        path: string;
+    }[];
+    images?: AttachmentRef[];
+    audioAttachments?: AttachmentRef[];
+    documents?: DocumentAttachment[];
+}
+export declare const IMAGE_ONLY_USER_PROMPT = "The user sent one or more images without any accompanying text. Describe what the images show and respond to anything notable in them.";
+export declare const DOCUMENT_ONLY_USER_PROMPT = "The user sent one or more documents without any accompanying text. Summarize the attached documents.";
+export declare const IMAGE_AND_DOCUMENT_USER_PROMPT = "The user sent one or more images together with one or more documents, and no accompanying text. Describe what the images show and summarize the attached documents.";
+export declare function unreadableImagesNotice(fileNames: readonly string[]): string;
+export declare function annotateUnreadableImages(unreadable: ReadonlyMap<ChatMessage, string[]>): void;
+export declare function unheardAudioNotice(label: string, reason: string, opts?: {
+    retryable?: boolean;
+}): string;
+interface AttachmentRef {
+    id: string;
+    fileName: string;
+    mimeType: string;
+    blobId: string;
+    url?: string | null;
+}
+interface AttachInput {
+    fileName: string;
+    mimeType: string;
+    bytes: Uint8Array;
+    raw?: boolean;
+}
+interface AttachmentMeta {
+    id: string;
+    fileName: string;
+    mimeType: string;
+    byteLength: number;
+}
+interface FetchedAttachment extends AttachmentMeta {
+    bytes: Uint8Array;
+}
+interface HarnessEvent {
+    type: string;
+    text?: string;
+    message?: string;
+    [key: string]: unknown;
+}
+export interface HarnessInfo {
+    toolNames: string[];
+    skills: string[];
+    supportsImages: boolean;
+}
+export type ModelType = string;
+export interface ModelInfo {
+    name: string;
+    type: ModelType;
+    registryPath: string;
+    registrySource: string;
+    isCached: boolean;
+    isLoaded: boolean;
+    supportsImages?: boolean;
+    expectedSize: number;
+    actualSize?: number;
+}
+export interface ListModelsOptions {
+    type?: ModelType;
+    cachedOnly?: boolean;
+    fullRegistry?: boolean;
+}
+export interface DeleteModelSummary {
+    name: string;
+    removed: number;
+    freedBytes: number;
+}
+export interface ToolCatalogEntry {
+    name: string;
+    description: string;
+    skillGated: boolean;
+    scopeRequired: boolean;
+    toolset?: string | null;
+    rootsRequired?: boolean;
+    writeRootsRequired?: boolean;
+    promptChars?: number;
+}
+export interface Harness {
+    completion(context: {
+        model: string;
+        agent: AssistantAgent;
+        messages: ChatMessage[];
+        cacheKey?: string;
+        thinkingDefault?: string;
+        toolConfigs?: Record<string, Record<string, unknown>>;
+        grantedDirs?: string[];
+        grantedDrives?: GrantedDrive[];
+        driveOp?: DriveOpFn;
+        grantedWriteDirs?: string[];
+        generationParams?: {
+            temp?: number;
+            top_p?: number;
+            top_k?: number;
+            presence_penalty?: number;
+            repeat_penalty?: number;
+            frequency_penalty?: number;
+            reasoning_budget: 0 | -1;
+        };
+        responseFormat?: {
+            type: 'text';
+        } | {
+            type: 'json_object';
+        } | {
+            type: 'json_schema';
+            json_schema: {
+                name: string;
+                description?: string;
+                schema: Record<string, unknown>;
+                strict?: boolean;
+            };
+        };
+        approve?: (call: ApprovalCall) => Promise<boolean>;
+        attach?: (input: AttachInput) => Promise<AssistantChunkContentAttachment>;
+        fetchAttachment?: (query: {
+            attachmentId?: string;
+            signal?: AbortSignal;
+            meta?: boolean;
+        }) => Promise<FetchedAttachment | AttachmentMeta | null>;
+        ragSearch?: (input: {
+            query: string;
+            limit?: number;
+        }) => Promise<{
+            enabled: boolean;
+            indexEmpty: boolean;
+            hasKnowledge: boolean;
+            pendingReferenced?: boolean;
+            errorMessage?: string | null;
+            hits: ReadonlyArray<{
+                content: string;
+                metadataJson?: string | null;
+                score: number;
+            }>;
+        }>;
+        progress?: (update: {
+            percentage: number;
+        } | null) => void;
+        signal?: AbortSignal;
+    }): AsyncIterable<HarnessEvent>;
+    describe?(): Promise<HarnessInfo | null> | HarnessInfo;
+    embed?(context: {
+        model: string;
+        texts: string[];
+        signal?: AbortSignal;
+    }): Promise<number[][]>;
+    list?(options?: ListModelsOptions): Promise<ReadonlyArray<ModelInfo>>;
+    warmModel?(context: {
+        model: string;
+        agent?: AssistantAgent;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    deleteModel?(name: string): Promise<DeleteModelSummary>;
+    clearKvCache?(): Promise<AssistantKvCacheDeletionResponse>;
+    deleteKvCache?(kvCacheKey: string): Promise<AssistantKvCacheDeletionResponse>;
+    infraModels?(profile: string): Promise<ReadonlyArray<{
+        name: string;
+        addon: string;
+    }>>;
+    capability?(): Promise<{
+        capabilityProfile: AssistantCapabilityProfile;
+        recommendedModelName: string;
+        memoryBudget?: MemoryBudget;
+    }>;
+    download?(args: DownloadArgs): DownloadEventStream;
+    transcribe?(context: {
+        model: string;
+        audio: Buffer;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    speak?(context: {
+        model: string;
+        text: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        audio: Buffer;
+        sampleRate: number;
+    }>;
+    speakStream?(context: {
+        model: string;
+        text: AsyncIterable<string>;
+        signal?: AbortSignal;
+    }): AsyncIterable<{
+        audio: Buffer;
+        sampleRate: number;
+    }>;
+    setCredentials?(entries: ReadonlyArray<{
+        key: string;
+        token?: string | null;
+        expiresAt?: number | null;
+        agentId?: string | null;
+    }>): void | Promise<void>;
+    setCustomModels?(entries: ReadonlyArray<{
+        name: string;
+        src: string;
+        projectionSrc?: string;
+    }>): void | Promise<void>;
+    on?(event: 'model' | 'status', listener: (...args: never[]) => void): unknown;
+    off?(event: 'model' | 'status', listener: (...args: never[]) => void): unknown;
+    presuspend?(): Promise<void> | void;
+    suspend?(): Promise<void> | void;
+    wakeup?(): Promise<void> | void;
+    resume?(): Promise<void> | void;
+    skills?(agentId?: string | null, modelName?: string | null, options?: {
+        readonly refresh?: boolean;
+        readonly skipCredentialProbe?: boolean;
+    }): Promise<ReadonlyArray<Skill>>;
+    tools?(): Promise<ReadonlyArray<ToolCatalogEntry>>;
+    listManagedSkills?(): Promise<ReadonlyArray<ManagedSkill>>;
+    readSkillFile?(name: string): Promise<SkillFileContent | null>;
+    writeSkillFile?(name: string, content: string): Promise<{
+        ok: boolean;
+    }>;
+    copyBaseForEdit?(name: string): Promise<{
+        copied: boolean;
+    }>;
+    deleteOverlaySkill?(name: string): Promise<{
+        removed: boolean;
+    }>;
+    diagnostics?(): HarnessDiagnostics;
+    fetchDiagnostics?(): Promise<HarnessDiagnostics | null>;
+    toolNames?: string[];
+    skillNames?: string[];
+    supportsImages?: boolean;
+    supportsImagesFor?(model: string): boolean;
+}
+export declare function harnessListModels(harness: Pick<Harness, 'list'>): (options: AssistantListModelsRequest) => Promise<AssistantModelInfoList>;
+export declare function harnessDeleteModel(harness: Pick<Harness, 'deleteModel'>): (options: AssistantDeleteModelRequest) => Promise<AssistantDeleteModelResponse>;
+export declare function harnessClearKvCache(harness: Pick<Harness, 'clearKvCache'>): () => Promise<AssistantKvCacheDeletionResponse>;
+export declare function harnessTranscribe(harness: Pick<Harness, 'transcribe'>): (request: AssistantTranscribeRequest) => Promise<AssistantTranscribeResponse>;
+export declare function harnessSpeak(harness: Pick<Harness, 'speak'>): (request: AssistantSpeakRequest) => Promise<AssistantSpeakResponse>;
+export declare function harnessSkillCatalog(harness: Pick<Harness, 'skills'>, syncCredentials?: () => Promise<void> | undefined): (agentId?: string | null, modelName?: string | null, options?: {
+    readonly refresh?: boolean;
+    readonly skipCredentialProbe?: boolean;
+}) => Promise<AssistantSkillCatalogResponse>;
+export declare function harnessSkillManagement(harness: Pick<Harness, 'listManagedSkills' | 'readSkillFile' | 'writeSkillFile' | 'copyBaseForEdit' | 'deleteOverlaySkill'>): SkillManagementHooks;
+export declare function harnessTools(harness: Pick<Harness, 'tools'>): () => Promise<AssistantToolCatalogResponse>;
+export declare function harnessSpeakStream(harness: Pick<Harness, 'speakStream'>): (text: AsyncIterable<string>) => AsyncIterable<AssistantSpeakResponse>;
+export interface Skill {
+    name: string;
+    description: string;
+    status: string;
+    tools: string[];
+    credentials: string[];
+    allowList: string[];
+    platform: string[];
+    requires?: SkillRequires;
+    install?: InstallStep[];
+    setup?: SkillSetup;
+    stub?: boolean;
+    minCapabilityProfile?: string;
+    emoji?: string;
+}
+export interface StaleToolRuns {
+    runIds: Set<string>;
+    questionChunkIds: Set<string>;
+}
+export declare function listHistoryChunks(engine: Pick<Capabilities, 'listChunks'>, chatId: string): Promise<AssistantChunk[]>;
+export interface CompactOptions {
+    readonly signal?: AbortSignal;
+    readonly onFold?: () => Promise<void> | void;
+}
+export type CompactionTrigger = 'before-run' | 'turn-filled-window' | 'overflow';
+export interface CompactResult {
+    readonly compacted: boolean;
+    readonly foldedTurns?: number;
+    readonly reason?: string;
+}
+export declare function historyFromChunks(chunks: ReadonlyArray<AssistantChunk>, stale?: Partial<StaleToolRuns>): ChatMessage[];
+export declare function staleToolRunIds(historyChunks: ReadonlyArray<AssistantChunk>, approvalChunks: ReadonlyArray<AssistantChunk>, currentRunId: string): StaleToolRuns;
+export interface AssistantOptions {
+    logger?: Logger | null;
+    imageCacheDir?: string;
+    imageCacheMaxBytes?: number;
+    imageCacheMaxAgeMs?: number;
+    downloadRetryMs?: number;
+    platform?: string;
+    preloadCurrentAgentModel?: boolean;
+    drives?: DriveHost;
+    blobReadTimeoutMs?: number;
+}
+export declare class QvacAssistant extends ReadyResource {
+    private readonly _engine;
+    private readonly _harness;
+    private readonly _log;
+    private readonly _imageCacheDir;
+    private readonly _imageCacheMaxBytes?;
+    private readonly _imageCacheMaxAgeMs?;
+    private readonly _downloadRetryMs?;
+    private readonly _platform;
+    private readonly _mobileClass;
+    private readonly _preloadCurrentAgentModel;
+    private readonly _drives?;
+    private readonly _blobReadTimeoutMs;
+    private readonly _warmAbort;
+    private _warmedModel;
+    private _warmedModelName;
+    private readonly _modelStatusLogged;
+    private _deviceId;
+    private _info;
+    private _lastCapabilities;
+    private _readySkills;
+    private _recordingReadiness;
+    private _readinessDirty;
+    private _reconciling;
+    private readonly _onlineBoot;
+    private _capability;
+    private _downloads;
+    private _state;
+    private _harnessDiagnostics;
+    private _harnessDeath;
+    private _refreshingDiagnostics;
+    private _requests;
+    private _retry;
+    private _retryMs;
+    private _chatList;
+    private _agentList;
+    private readonly _chatListWatch;
+    private readonly _agentWatch;
+    private readonly _runs;
+    private readonly _seen;
+    private readonly _lifecycle;
+    private readonly _audioTranscripts;
+    private readonly _chats;
+    private readonly _runImageCacheNames;
+    private readonly _reconciledCompactions;
+    private readonly _modelCatalog;
+    private readonly _onHarnessStatus;
+    private readonly _onModelCatalogEvent;
+    constructor(engine: Capabilities, harness: Harness, { logger, imageCacheDir, imageCacheMaxBytes, imageCacheMaxAgeMs, downloadRetryMs, platform, preloadCurrentAgentModel, drives, blobReadTimeoutMs }?: AssistantOptions);
+    _open(): Promise<void>;
+    private _triggerModelWarm;
+    private _warmCurrentAgentModel;
+    private _currentAgent;
+    private _bootOnline;
+    onlineReady(): Promise<void>;
+    private _clearPersistedPauses;
+    ensureMediaModelUnpaused(category: ModelCategory, model?: string | null): Promise<boolean>;
+    private _persistedProfile;
+    private _sweepImageCache;
+    private _imageCacheInUse;
+    private _referencedImageNames;
+    private _describeHarness;
+    diagnosticsSlice(): DiagnosticsSlice;
+    private _refreshHarnessDiagnostics;
+    private _reportCapabilities;
+    private _ensureCapability;
+    private _reconcileDeviceProfile;
+    _close(): Promise<void>;
+    get suspended(): boolean;
+    presuspend(): Promise<void>;
+    suspend(): Promise<void>;
+    wakeup(): Promise<void>;
+    resume(): Promise<void>;
+    listModels(options?: ListModelsOptions): Promise<ReadonlyArray<ModelInfo>>;
+    deleteModel(name: string): Promise<DeleteModelSummary>;
+    modelCatalogWatch(): AsyncIterable<AssistantModelCatalogRevision>;
+    retryModelDownload(name: string): Promise<void>;
+    skills(agentId?: string | null, modelName?: string | null, options?: {
+        readonly refresh?: boolean;
+        readonly skipCredentialProbe?: boolean;
+    }): Promise<ReadonlyArray<Skill>>;
+    private _recordSkillReadiness;
+    tools(): Promise<ReadonlyArray<ToolCatalogEntry>>;
+    private _startConsume;
+    private _rearmingWatch;
+    private _watchChatList;
+    private _watchAgents;
+    private _reclaimAgentChatCaches;
+    private _reconcileCompaction;
+    deleteChatKvCache(chatId: string): Promise<AssistantKvCacheDeletionResponse>;
+    private _deleteChatKvCache;
+    private _rearmConsume;
+    private _consume;
+    private _dispatch;
+    private _citeWebSources;
+    private _searchKnowledge;
+    private _isHandled;
+    private _execute;
+    private _loadToolConfigs;
+    private _loadFsGrants;
+    private _readRootGrants;
+    private _readWriteGrants;
+    private _fetchAttachment;
+    private _readBlob;
+    private _uploadGenerated;
+    private _hydrateAudio;
+    private _transcribeAttachment;
+    private _hydrateImages;
+    private _hydrateImage;
+    private _compactIfNearFull;
+    private _runCompaction;
+    private _lastRunMetrics;
+    compactChat(chatId: string, options?: CompactOptions): Promise<CompactResult>;
+    private _summarize;
+    private _autoTitle;
+    private _generateChatTitle;
+    private _titleFromCompletion;
+    private _createApprove;
+    private _abortOutcome;
+    private _watchSettled;
+    private _watchOwnership;
+    private _yieldDownloads;
+    private _logModelStatus;
+    private _modelHolder;
+    private _watchModelProgress;
+}
+export {};