sidekick-shared 0.24.5 → 0.25.0

package/dist/providers/codex.js

@@ -53,6 +53,7 @@ const sessionContext_1 = require("../context/sessionContext");
 const codexParser_1 = require("../parsers/codexParser");
 const codexDatabase_1 = require("./codexDatabase");
 const codexProfiles_1 = require("../codexProfiles");
+const diagnostics_1 = require("./diagnostics");
 const modelContext_1 = require("../modelContext");
 const observedContextWindows_1 = require("../observedContextWindows");
 const usageNormalization_1 = require("../usageNormalization");
@@ -165,6 +166,40 @@ function findRolloutFilesInConfiguredHomes() {
     }
     return results;
 }
+async function findRolloutFilesAsync(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...(await findRolloutFilesAsync(fullPath)));
+        }
+        else if (entry.isFile() && isRolloutFile(entry.name)) {
+            try {
+                const stats = await fs.promises.stat(fullPath);
+                if (stats.size > 0) {
+                    results.push({
+                        path: fullPath,
+                        mtime: stats.mtime,
+                        sizeBytes: stats.size,
+                        sessionId: extractSessionId(entry.name),
+                    });
+                }
+            }
+            catch {
+                // Skip inaccessible files.
+            }
+        }
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    return results;
+}
 /**
  * Locates the rollout file for a Codex session id by walking
  * `<home>/sessions/YYYY/MM/DD/rollout-<timestamp>-<id>.jsonl`.
@@ -298,6 +333,41 @@ function readSessionMeta(rolloutPath) {
     }
     return null;
 }
+async function readSessionMetaAsync(rolloutPath) {
+    // Mirrors readSessionMeta()/readFirstLines(): chunk-read until the first
+    // line is complete under the same 256 KiB cap — session_meta carries
+    // `instructions` and can far exceed a single chunk.
+    const maxBytes = 256 * 1024;
+    const chunkSize = 64 * 1024;
+    let handle = null;
+    try {
+        handle = await fs.promises.open(rolloutPath, 'r');
+        const chunks = [];
+        let totalRead = 0;
+        let newlineFound = false;
+        while (totalRead < maxBytes && !newlineFound) {
+            const buffer = Buffer.alloc(Math.min(chunkSize, maxBytes - totalRead));
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, totalRead);
+            if (bytesRead === 0)
+                break;
+            const chunk = buffer.subarray(0, bytesRead);
+            chunks.push(chunk);
+            totalRead += bytesRead;
+            newlineFound = chunk.includes(0x0a);
+        }
+        const firstLine = Buffer.concat(chunks).toString('utf8').split('\n', 1)[0]?.trim();
+        if (!firstLine)
+            return null;
+        const parsed = JSON.parse(firstLine);
+        return parsed.type === 'session_meta' ? parsed.payload : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
 /** Read the CWD from a rollout file's session_meta. Cached. */
 const cwdCache = new Map();
 function readSessionCwd(rolloutPath) {
@@ -309,6 +379,16 @@ function readSessionCwd(rolloutPath) {
     cwdCache.set(rolloutPath, cwd);
     return cwd;
 }
+/** Async twin of readSessionCwd, sharing its cache so repeat listings do no content reads. */
+async function readSessionCwdAsync(rolloutPath) {
+    const cached = cwdCache.get(rolloutPath);
+    if (cached !== undefined)
+        return cached;
+    const meta = await readSessionMetaAsync(rolloutPath);
+    const cwd = meta?.cwd || null;
+    cwdCache.set(rolloutPath, cwd);
+    return cwd;
+}
 /** Check if a session's CWD matches a workspace path. */
 function cwdMatches(sessionCwd, workspacePath) {
     const normalizedSession = normalizePath(sessionCwd);
@@ -333,48 +413,65 @@ function normalizePath(input) {
  */
 function extractFirstUserMessage(rolloutPath) {
     try {
-        const lines = readFirstLines(rolloutPath, 20);
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const parsed = JSON.parse(trimmed);
-                // Check response_item with user message
-                if (parsed.type === 'response_item') {
-                    const payload = parsed.payload;
-                    if (payload.role === 'user') {
-                        const content = payload.content;
-                        if (typeof content === 'string' && content.trim() && !isSystemInjection(content)) {
-                            return truncate(content, 60);
-                        }
-                        if (Array.isArray(content)) {
-                            for (const part of content) {
-                                const p = part;
-                                if (p.text?.trim() && !isSystemInjection(p.text)) {
-                                    return truncate(p.text, 60);
-                                }
+        return extractFirstUserMessageFromLines(readFirstLines(rolloutPath, 20));
+    }
+    catch {
+        return null;
+    }
+}
+function extractFirstUserMessageFromLines(lines) {
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            // Check response_item with user message
+            if (parsed.type === 'response_item') {
+                const payload = parsed.payload;
+                if (payload.role === 'user') {
+                    const content = payload.content;
+                    if (typeof content === 'string' && content.trim() && !isSystemInjection(content)) {
+                        return truncate(content, 60);
+                    }
+                    if (Array.isArray(content)) {
+                        for (const part of content) {
+                            const p = part;
+                            if (p.text?.trim() && !isSystemInjection(p.text)) {
+                                return truncate(p.text, 60);
                             }
                         }
                     }
                 }
-                // Check event_msg with user_message
-                if (parsed.type === 'event_msg') {
-                    const payload = parsed.payload;
-                    if (payload.type === 'user_message' && payload.message?.trim()) {
-                        return truncate(payload.message, 60);
-                    }
-                }
             }
-            catch {
-                // Skip malformed lines
+            // Check event_msg with user_message
+            if (parsed.type === 'event_msg') {
+                const payload = parsed.payload;
+                if (payload.type === 'user_message' && payload.message?.trim()) {
+                    return truncate(payload.message, 60);
+                }
             }
         }
-        return null;
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return null;
+}
+async function extractFirstUserMessageAsync(rolloutPath) {
+    let handle = null;
+    try {
+        handle = await fs.promises.open(rolloutPath, 'r');
+        const buffer = Buffer.alloc(256 * 1024);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        return extractFirstUserMessageFromLines(buffer.toString('utf8', 0, bytesRead).split('\n').slice(0, 20));
     }
     catch {
         return null;
     }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
 }
 /** Extract searchable text from a rollout line. */
 function extractSearchableText(line) {
@@ -661,9 +758,14 @@ class CodexProvider {
     displayName = 'Codex CLI';
     db = null;
     dbInitialized = false;
+    dbStatus = { available: false, kind: 'db_missing' };
+    diagnostics;
     dynamicContextWindowLimit = null;
     lastRateLimitsData = null;
     lastTokenUsageData = null;
+    constructor(options = {}) {
+        this.diagnostics = new diagnostics_1.ProviderDiagnosticTracker(this.id, options);
+    }
     // --- Database ---
     /** Lazy-initialize database connection. */
     ensureDb() {
@@ -675,8 +777,34 @@ class CodexProvider {
         if (db.isAvailable() && db.open()) {
             this.db = db;
         }
+        if (typeof db.getRuntimeStatus === 'function') {
+            this.dbStatus = db.getRuntimeStatus();
+        }
         return this.db;
     }
+    async ensureDbAsync() {
+        if (this.db)
+            return this.db;
+        return new codexDatabase_1.CodexDatabase(getCodexHome());
+    }
+    /**
+     * Cache an async-created database only after an operation proved it usable.
+     * Sync paths treat a cached `db` as "open() succeeded", so adopting an
+     * unproven instance would silently disable their file fallbacks.
+     */
+    adoptDbIfAvailable(db) {
+        if (this.db || !db.getRuntimeStatus().available)
+            return;
+        this.db = db;
+        this.dbInitialized = true;
+    }
+    getRuntimeStatus() {
+        const db = this.ensureDb();
+        return db && typeof db.getRuntimeStatus === 'function' ? db.getRuntimeStatus() : this.dbStatus;
+    }
+    getLastOperationStatus() {
+        return this.diagnostics.getLastOperationStatus();
+    }
     // --- Path resolution ---
     getSessionDirectory(workspacePath) {
         // Codex doesn't use workspace-encoded directories like Claude Code.
@@ -686,10 +814,13 @@ class CodexProvider {
         if (db) {
             const thread = db.getMostRecentThread(workspacePath);
             if (thread?.rollout_path) {
+                this.recordDatabaseFallback('getSessionDirectory', true);
                 return path.dirname(thread.rollout_path);
             }
         }
-        return getSessionsDir();
+        const directory = getSessionsDir();
+        this.recordDatabaseFallback('getSessionDirectory', true);
+        return directory;
     }
     discoverSessionDirectory(workspacePath) {
         // DB: find latest rollout directory for this workspace
@@ -697,23 +828,29 @@ class CodexProvider {
         if (db) {
             const thread = db.getMostRecentThread(workspacePath);
             if (thread?.rollout_path && fs.existsSync(thread.rollout_path)) {
+                this.recordDatabaseFallback('discoverSessionDirectory', true);
                 return path.dirname(thread.rollout_path);
             }
         }
         // File scan: look for any rollout file whose session_meta.cwd matches
         const files = findRolloutFilesInConfiguredHomes();
-        if (files.length === 0)
+        if (files.length === 0) {
+            this.recordDatabaseFallback('discoverSessionDirectory', true);
             return null;
+        }
         // Sort by mtime descending
         files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
         for (const file of files) {
             const meta = readSessionMeta(file.path);
             if (meta && cwdMatches(meta.cwd, workspacePath)) {
+                this.recordDatabaseFallback('discoverSessionDirectory', true);
                 return path.dirname(file.path);
             }
         }
         // Fallback: return the most relevant base sessions dir if one exists
-        return getSessionsDir();
+        const directory = getSessionsDir();
+        this.recordDatabaseFallback('discoverSessionDirectory', true);
+        return directory;
     }
     // --- Session discovery ---
     findActiveSession(workspacePath) {
@@ -722,6 +859,7 @@ class CodexProvider {
         if (db) {
             const thread = db.getMostRecentThread(workspacePath);
             if (thread?.rollout_path && fs.existsSync(thread.rollout_path)) {
+                this.recordDatabaseFallback('findActiveSession', true);
                 return thread.rollout_path;
             }
         }
@@ -731,9 +869,11 @@ class CodexProvider {
         for (const file of files) {
             const meta = readSessionMeta(file.path);
             if (meta && cwdMatches(meta.cwd, workspacePath)) {
+                this.recordDatabaseFallback('findActiveSession', true);
                 return file.path;
             }
         }
+        this.recordDatabaseFallback('findActiveSession', true);
         return null;
     }
     findAllSessions(workspacePath) {
@@ -744,18 +884,33 @@ class CodexProvider {
             const dbPaths = threads
                 .filter((t) => t.rollout_path && fs.existsSync(t.rollout_path))
                 .map((t) => t.rollout_path);
-            if (dbPaths.length > 0)
+            if (dbPaths.length > 0) {
+                this.recordDatabaseFallback('findAllSessions', true);
                 return dbPaths;
+            }
         }
         // File scan
         const files = findRolloutFilesInConfiguredHomes();
         files.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        return files
+        const sessions = files
             .filter((f) => {
             const meta = readSessionMeta(f.path);
             return meta && cwdMatches(meta.cwd, workspacePath);
         })
             .map((f) => f.path);
+        this.recordDatabaseFallback('findAllSessions', true);
+        return sessions;
+    }
+    findSessionById(_workspacePath, sessionId) {
+        try {
+            const found = findCodexRolloutFile(sessionId);
+            this.recordDatabaseFallback('findSessionById', true);
+            return found;
+        }
+        catch {
+            this.recordDatabaseFallback('findSessionById', false);
+            return null;
+        }
     }
     /** Backward-compatible alias for findAllSessions. */
     findSessionFiles(workspacePath) {
@@ -767,7 +922,28 @@ class CodexProvider {
         return files.map((f) => f.path);
     }
     listAllSessionFiles() {
-        return findRolloutFilesInConfiguredHomes();
+        const files = findRolloutFilesInConfiguredHomes();
+        this.recordDatabaseFallback('listAllSessionFiles', true);
+        return files;
+    }
+    async listSessionFilesAsync(workspacePath) {
+        const seen = new Set();
+        const results = [];
+        for (const sessionsDir of getSessionsDirs()) {
+            for (const file of await findRolloutFilesAsync(sessionsDir)) {
+                if (seen.has(file.path))
+                    continue;
+                seen.add(file.path);
+                if (workspacePath) {
+                    const cwd = await readSessionCwdAsync(file.path);
+                    if (!cwd || !cwdMatches(cwd, workspacePath))
+                        continue;
+                    file.workspacePath = cwd;
+                }
+                results.push(file);
+            }
+        }
+        return results.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
     }
     getAllProjectFolders(workspacePath) {
         const folders = [];
@@ -823,6 +999,7 @@ class CodexProvider {
             }
             return b.lastModified.getTime() - a.lastModified.getTime();
         });
+        this.recordDatabaseFallback('getAllProjectFolders', true);
         return folders;
     }
     // --- File identification ---
@@ -842,13 +1019,43 @@ class CodexProvider {
         if (db) {
             const sessionId = this.getSessionId(sessionPath);
             const thread = db.getThread(sessionId);
-            if (thread?.title)
+            if (thread?.title) {
+                this.recordDatabaseFallback('extractSessionLabel', true);
                 return truncate(thread.title, 60);
-            if (thread?.first_user_message)
+            }
+            if (thread?.first_user_message) {
+                this.recordDatabaseFallback('extractSessionLabel', true);
                 return truncate(thread.first_user_message, 60);
+            }
         }
         // File fallback: parse first user message
-        return extractFirstUserMessage(sessionPath);
+        const label = extractFirstUserMessage(sessionPath);
+        this.recordDatabaseFallback('extractSessionLabel', true);
+        return label;
+    }
+    async extractSessionLabelsAsync(sessionPaths) {
+        const results = new Map();
+        const byId = new Map(sessionPaths.map((sessionPath) => [this.getSessionId(sessionPath), sessionPath]));
+        const db = await this.ensureDbAsync();
+        const threads = await db.getThreadsByIdsAsync([...byId.keys()]);
+        for (const thread of threads) {
+            const sessionPath = byId.get(thread.id);
+            if (!sessionPath)
+                continue;
+            const label = thread.title ?? thread.first_user_message;
+            if (label)
+                results.set(sessionPath, truncate(label, 60));
+        }
+        this.dbStatus = db.getRuntimeStatus();
+        this.adoptDbIfAvailable(db);
+        for (const sessionPath of sessionPaths) {
+            if (!results.has(sessionPath)) {
+                results.set(sessionPath, await extractFirstUserMessageAsync(sessionPath));
+                await new Promise((resolve) => setImmediate(resolve));
+            }
+        }
+        this.recordDatabaseFallback('extractSessionLabelsAsync', true);
+        return results;
     }
     // --- Data reading ---
     createReader(sessionPath) {
@@ -1015,6 +1222,9 @@ class CodexProvider {
     getProjectsBaseDir() {
         return getSessionsDir();
     }
+    getWatchRoots() {
+        return getSessionsDirs();
+    }
     // --- Stats ---
     readSessionStats(sessionPath) {
         const sessionId = extractSessionId(path.basename(sessionPath));
@@ -1094,9 +1304,28 @@ class CodexProvider {
         this.db?.close();
         this.db = null;
         this.dbInitialized = false;
+        this.dbStatus = { available: false, kind: 'db_missing' };
         this.dynamicContextWindowLimit = null;
         this.lastRateLimitsData = null;
         this.lastTokenUsageData = null;
     }
+    recordDatabaseFallback(operation, usable) {
+        if (!this.dbInitialized) {
+            this.diagnostics.available(operation);
+            return;
+        }
+        const status = this.getRuntimeStatus();
+        const diagnostic = (0, diagnostics_1.diagnosticFromRuntimeStatus)(this.id, 'query', status);
+        if (!diagnostic) {
+            this.diagnostics.available(operation);
+            return;
+        }
+        this.diagnostics.degraded(operation, status, {
+            kind: diagnostic.kind,
+            severity: diagnostic.severity,
+            phase: diagnostic.phase,
+            message: diagnostic.message,
+        }, usable);
+    }
 }
 exports.CodexProvider = CodexProvider;

package/dist/providers/codexDatabase.d.ts

@@ -3,14 +3,18 @@
  * Ported from sidekick-vscode/src/services/providers/CodexDatabase.ts
  */
 import type { CodexDbThread } from '../types/codex';
+import type { ProviderRuntimeStatus } from './types';
 export declare class CodexDatabase {
     private readonly dbPath;
     private sqlite3Available;
+    private runtimeStatus;
     constructor(codexHome: string);
     isAvailable(): boolean;
     open(): boolean;
+    getRuntimeStatus(): ProviderRuntimeStatus;
     close(): void;
     private query;
+    private queryAsync;
     private queryOne;
     getThreadsByCwd(cwd: string): CodexDbThread[];
     getMostRecentThread(cwd: string): CodexDbThread | null;
@@ -20,6 +24,11 @@ export declare class CodexDatabase {
         lastUpdated: number;
     }>;
     getThread(id: string): CodexDbThread | null;
+    /**
+     * Resolve many thread ids with non-blocking sqlite3 subprocesses — one per
+     * chunk of ids, so the inlined query stays clear of argv length limits.
+     */
+    getThreadsByIdsAsync(ids: readonly string[]): Promise<CodexDbThread[]>;
     /** Get all threads forked from a given session ID. */
     getThreadsByForkedFromId(parentId: string): CodexDbThread[];
     /** Get the database file's mtime (ms epoch). Returns 0 if unavailable. */

package/dist/providers/codexDatabase.js

@@ -41,9 +41,15 @@ exports.CodexDatabase = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+/**
+ * Ids per inlined `IN (…)` query. Values are passed inside a single argv
+ * element to sqlite3, so an unbounded list would hit E2BIG on large stores.
+ */
+const SQL_ID_CHUNK_SIZE = 400;
 class CodexDatabase {
     dbPath;
     sqlite3Available = null;
+    runtimeStatus = null;
     constructor(codexHome) {
         this.dbPath = findLatestStateDatabase(codexHome) ?? path.join(codexHome, 'state.sqlite');
     }
@@ -58,6 +64,11 @@ class CodexDatabase {
     open() {
         if (this.sqlite3Available !== null)
             return this.sqlite3Available;
+        if (!this.isAvailable()) {
+            this.sqlite3Available = false;
+            this.runtimeStatus = { available: false, kind: 'db_missing' };
+            return false;
+        }
         try {
             (0, child_process_1.execFileSync)('sqlite3', ['--version'], {
                 encoding: 'utf-8',
@@ -66,13 +77,26 @@ class CodexDatabase {
                 stdio: ['pipe', 'pipe', 'pipe'],
             });
             this.sqlite3Available = true;
+            this.runtimeStatus = { available: true, kind: 'available' };
             return true;
         }
-        catch {
+        catch (error) {
             this.sqlite3Available = false;
+            this.runtimeStatus = classifySqliteError(error);
             return false;
         }
     }
+    getRuntimeStatus() {
+        if (this.runtimeStatus)
+            return this.runtimeStatus;
+        if (!this.isAvailable())
+            return { available: false, kind: 'db_missing' };
+        return {
+            available: false,
+            kind: 'query_failed',
+            message: 'Codex database has not been initialized yet.',
+        };
+    }
     close() { }
     query(sql, params = []) {
         if (!this.sqlite3Available)
@@ -103,7 +127,34 @@ class CodexDatabase {
                 return [];
             return JSON.parse(trimmed);
         }
-        catch {
+        catch (error) {
+            this.runtimeStatus = {
+                ...classifySqliteError(error, 'query_failed'),
+                available: this.sqlite3Available === true,
+            };
+            return [];
+        }
+    }
+    async queryAsync(sql, params = []) {
+        if (!this.isAvailable()) {
+            this.runtimeStatus = { available: false, kind: 'db_missing' };
+            return [];
+        }
+        const query = bindSqlParams(sql, params);
+        try {
+            const result = await execSqlite(this.dbPath, query, 10 * 1024 * 1024);
+            this.sqlite3Available = true;
+            this.runtimeStatus = { available: true, kind: 'available' };
+            const trimmed = result.trim();
+            return trimmed ? JSON.parse(trimmed) : [];
+        }
+        catch (error) {
+            const status = classifySqliteError(error, 'query_failed');
+            // Only a missing sqlite3 binary gates future attempts. A failed query
+            // is transient and must not latch the database off (mirrors query()).
+            if (status.kind === 'sqlite_missing')
+                this.sqlite3Available = false;
+            this.runtimeStatus = status;
             return [];
         }
     }
@@ -132,6 +183,19 @@ class CodexDatabase {
     getThread(id) {
         return this.queryOne('SELECT * FROM threads WHERE id = ?', [id]);
     }
+    /**
+     * Resolve many thread ids with non-blocking sqlite3 subprocesses — one per
+     * chunk of ids, so the inlined query stays clear of argv length limits.
+     */
+    async getThreadsByIdsAsync(ids) {
+        const results = [];
+        for (let i = 0; i < ids.length; i += SQL_ID_CHUNK_SIZE) {
+            const chunk = ids.slice(i, i + SQL_ID_CHUNK_SIZE);
+            const placeholders = chunk.map(() => '?').join(', ');
+            results.push(...(await this.queryAsync(`SELECT * FROM threads WHERE id IN (${placeholders})`, [...chunk])));
+        }
+        return results;
+    }
     /** Get all threads forked from a given session ID. */
     getThreadsByForkedFromId(parentId) {
         return this.query('SELECT * FROM threads WHERE forked_from_id = ? ORDER BY created_at ASC', [parentId]);
@@ -147,6 +211,47 @@ class CodexDatabase {
     }
 }
 exports.CodexDatabase = CodexDatabase;
+function classifySqliteError(error, fallback = 'sqlite_blocked') {
+    const code = error?.code;
+    if (code === 'ENOENT') {
+        return {
+            available: false,
+            kind: 'sqlite_missing',
+            message: 'The sqlite3 executable was not found.',
+        };
+    }
+    return {
+        available: false,
+        kind: fallback,
+        message: error instanceof Error ? error.message : 'sqlite3 could not be executed.',
+    };
+}
+function bindSqlParams(sql, params) {
+    let paramIndex = 0;
+    return sql.replace(/\?/g, () => {
+        if (paramIndex >= params.length)
+            return '?';
+        const param = params[paramIndex++];
+        if (typeof param === 'number')
+            return Number.isFinite(param) ? String(param) : '0';
+        return `'${String(param).replace(/'/g, "''")}'`;
+    });
+}
+function execSqlite(dbPath, query, maxBuffer) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)('sqlite3', ['-json', '-readonly', dbPath, query], {
+            encoding: 'utf8',
+            timeout: 4_000,
+            killSignal: 'SIGKILL',
+            maxBuffer,
+        }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(stdout);
+        });
+    });
+}
 function findLatestStateDatabase(codexHome) {
     try {
         const entries = fs.readdirSync(codexHome, { withFileTypes: true });

package/dist/providers/diagnostics.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderId, ProviderOperationStatus, ProviderRuntimeStatus, SessionProviderDiagnostic, SessionProviderOptions } from './types';
+/** Small per-provider diagnostic state; it never stores transcript or environment contents. */
+export declare class ProviderDiagnosticTracker {
+    private readonly providerId;
+    private readonly options;
+    private lastEmittedSignature;
+    private lastStatus;
+    constructor(providerId: ProviderId, options?: SessionProviderOptions);
+    available(operation: string): void;
+    degraded(operation: string, runtimeStatus: ProviderRuntimeStatus, diagnostic: Omit<SessionProviderDiagnostic, 'providerId'>, usable?: boolean): void;
+    getLastOperationStatus(): ProviderOperationStatus;
+}
+export declare function diagnosticFromRuntimeStatus(providerId: ProviderId, phase: SessionProviderDiagnostic['phase'], status: ProviderRuntimeStatus): SessionProviderDiagnostic | null;